[Bf-blender-cvs] [e5b18390fa5] blender2.8: Shrinkwrap: implement the use of smooth normals in constraint & modifier.

Alexander Gavrilov noreply at git.blender.org
Wed Oct 17 16:59:59 CEST 2018


Commit: e5b18390fa591c8b37b9ef9884611b2888bab188
Author: Alexander Gavrilov
Date:   Wed Oct 3 19:09:43 2018 +0300
Branches: blender2.8
https://developer.blender.org/rBe5b18390fa591c8b37b9ef9884611b2888bab188

Shrinkwrap: implement the use of smooth normals in constraint & modifier.

- Use smooth normals to displace in Above Surface mode.
- Add an option to align an axis to the normal in the constraint.

I've seen people request the alignment feature, and it seems useful.
For the actual aligning I use the damped track logic.

In order to conveniently keep mesh data needed for normal
computation together, a new data structure is introduced.

Reviewers: mont29

Differential Revision: https://developer.blender.org/D3762

===================================================================

M	release/scripts/startup/bl_ui/properties_constraint.py
M	source/blender/blenkernel/BKE_shrinkwrap.h
M	source/blender/blenkernel/intern/constraint.c
M	source/blender/blenkernel/intern/shrinkwrap.c
M	source/blender/depsgraph/intern/builder/deg_builder_relations.cc
M	source/blender/makesdna/DNA_constraint_types.h
M	source/blender/makesrna/intern/rna_constraint.c
M	source/blender/makesrna/intern/rna_modifier.c
M	source/blender/modifiers/intern/MOD_shrinkwrap.c

===================================================================

diff --git a/release/scripts/startup/bl_ui/properties_constraint.py b/release/scripts/startup/bl_ui/properties_constraint.py
index ea3b5f000ec..4be1f55b3b8 100644
--- a/release/scripts/startup/bl_ui/properties_constraint.py
+++ b/release/scripts/startup/bl_ui/properties_constraint.py
@@ -769,6 +769,13 @@ class ConstraintButtonsPanel:
             rowsub.prop(con, "use_invert_cull")
             layout.prop(con, "project_limit")
 
+        if con.shrinkwrap_type in ['PROJECT', 'NEAREST_SURFACE']:
+            layout.prop(con, "use_track_normal")
+
+            row = layout.row(align=True)
+            row.active = con.use_track_normal
+            row.prop(con, "track_axis", expand=True)
+
     def DAMPED_TRACK(self, context, layout, con):
         self.target_template(layout, con)
 
diff --git a/source/blender/blenkernel/BKE_shrinkwrap.h b/source/blender/blenkernel/BKE_shrinkwrap.h
index 40f3808b94b..d1a14003b04 100644
--- a/source/blender/blenkernel/BKE_shrinkwrap.h
+++ b/source/blender/blenkernel/BKE_shrinkwrap.h
@@ -55,27 +55,25 @@ struct ShrinkwrapModifierData;
 struct BVHTree;
 struct SpaceTransform;
 
+typedef struct ShrinkwrapTreeData {
+	Mesh *mesh;
 
-typedef struct ShrinkwrapCalcData {
-	ShrinkwrapModifierData *smd;    //shrinkwrap modifier data
+	BVHTree *bvh;
+	BVHTreeFromMesh treeData;
 
-	struct Object *ob;              //object we are applying shrinkwrap to
+	float (*clnors)[3];
+} ShrinkwrapTreeData;
 
-	struct MVert *vert;             //Array of verts being projected (to fetch normals or other data)
-	float (*vertexCos)[3];          //vertexs being shrinkwraped
-	int numVerts;
+/* Checks if the modifier needs target normals with these settings. */
+bool BKE_shrinkwrap_needs_normals(int shrinkType, int shrinkMode);
 
-	struct MDeformVert *dvert;      //Pointer to mdeform array
-	int vgroup;                     //Vertex group num
-	bool invert_vgroup;             /* invert vertex group influence */
+/* Initializes the mesh data structure from the given mesh and settings. */
+bool BKE_shrinkwrap_init_tree(struct ShrinkwrapTreeData *data, Mesh *mesh, int shrinkType, int shrinkMode, bool force_normals);
 
-	struct Mesh *target;     //mesh we are shrinking to
-	struct SpaceTransform local2target;    //transform to move between local and target space
-
-	float keepDist;                 //Distance to keep above target surface (units are in local space)
-
-} ShrinkwrapCalcData;
+/* Frees the tree data if necessary. */
+void BKE_shrinkwrap_free_tree(struct ShrinkwrapTreeData *data);
 
+/* Implementation of the Shrinkwrap modifier */
 void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd, struct Scene *scene, struct Object *ob, struct Mesh *mesh,
                                float (*vertexCos)[3], int numVerts);
 
@@ -91,12 +89,17 @@ void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd, struct Scene
  */
 bool BKE_shrinkwrap_project_normal(
         char options, const float vert[3], const float dir[3], const float ray_radius,
-        const struct SpaceTransform *transf, BVHTree *tree, BVHTreeRayHit *hit,
-        BVHTree_RayCastCallback callback, void *userdata);
+        const struct SpaceTransform *transf, struct ShrinkwrapTreeData *tree, BVHTreeRayHit *hit);
+
+/* Computes a smooth normal of the target (if applicable) at the hit location. */
+void BKE_shrinkwrap_compute_smooth_normal(
+        const struct ShrinkwrapTreeData *tree, const struct SpaceTransform *transform,
+        int looptri_idx, const float hit_co[3], const float hit_no[3], float r_no[3]);
 
 /* Apply the shrink to surface modes to the given original coordinates and nearest point. */
 void BKE_shrinkwrap_snap_point_to_surface(
-        int mode, const float hit_co[3], const float hit_no[3], float goal_dist,
+        const struct ShrinkwrapTreeData *tree, const struct SpaceTransform *transform,
+        int mode, int hit_idx, const float hit_co[3], const float hit_no[3], float goal_dist,
         const float point_co[3], float r_point_co[3]);
 
 /*
diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index 8e85cc39321..f343a62eaf7 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -107,6 +107,8 @@
  * type-info structs.
  */
 
+static void damptrack_do_transform(float matrix[4][4], const float tarvec[3], int track_axis);
+
 /* -------------- Naming -------------- */
 
 /* Find the first available, non-duplicate name for a given constraint */
@@ -3417,15 +3419,18 @@ static void shrinkwrap_get_tarmat(struct Depsgraph *depsgraph, bConstraint *con,
 
 		bool fail = false;
 		float co[3] = {0.0f, 0.0f, 0.0f};
+		bool track_normal = false;
+		float track_no[3] = {0.0f, 0.0f, 0.0f};
 
 		SpaceTransform transform;
 		Mesh *target_eval = mesh_get_eval_final(depsgraph, DEG_get_input_scene(depsgraph), ct->tar, CD_MASK_BAREMESH);
 
-		BVHTreeFromMesh treeData = {NULL};
+		copy_m4_m4(ct->matrix, cob->matrix);
 
-		unit_m4(ct->matrix);
+		bool do_track_normal = (scon->flag & CON_SHRINKWRAP_TRACK_NORMAL) != 0;
+		ShrinkwrapTreeData tree;
 
-		if (target_eval != NULL) {
+		if (BKE_shrinkwrap_init_tree(&tree, target_eval, scon->shrinkType, scon->shrinkMode, do_track_normal)) {
 			BLI_space_transform_from_matrices(&transform, cob->matrix, ct->tar->obmat);
 
 			switch (scon->shrinkType) {
@@ -3437,19 +3442,10 @@ static void shrinkwrap_get_tarmat(struct Depsgraph *depsgraph, bConstraint *con,
 					nearest.index = -1;
 					nearest.dist_sq = FLT_MAX;
 
-					if (scon->shrinkType == MOD_SHRINKWRAP_NEAREST_VERTEX)
-						BKE_bvhtree_from_mesh_get(&treeData, target_eval, BVHTREE_FROM_VERTS, 2);
-					else
-						BKE_bvhtree_from_mesh_get(&treeData, target_eval, BVHTREE_FROM_LOOPTRI, 2);
-
-					if (treeData.tree == NULL) {
-						fail = true;
-						break;
-					}
-
 					BLI_space_transform_apply(&transform, co);
 
-					BLI_bvhtree_find_nearest(treeData.tree, co, &nearest, treeData.nearest_callback, &treeData);
+					BVHTreeFromMesh *treeData = &tree.treeData;
+					BLI_bvhtree_find_nearest(treeData->tree, co, &nearest, treeData->nearest_callback, treeData);
 
 					if (nearest.index < 0) {
 						fail = true;
@@ -3457,7 +3453,13 @@ static void shrinkwrap_get_tarmat(struct Depsgraph *depsgraph, bConstraint *con,
 					}
 
 					if (scon->shrinkType == MOD_SHRINKWRAP_NEAREST_SURFACE) {
-						BKE_shrinkwrap_snap_point_to_surface(scon->shrinkMode, nearest.co, nearest.no, scon->dist, co, co);
+						if (do_track_normal) {
+							track_normal = true;
+							BKE_shrinkwrap_compute_smooth_normal(&tree, NULL, nearest.index, nearest.co, nearest.no, track_no);
+							BLI_space_transform_invert_normal(&transform, track_no);
+						}
+
+						BKE_shrinkwrap_snap_point_to_surface(&tree, NULL, scon->shrinkMode, nearest.index, nearest.co, nearest.no, scon->dist, co, co);
 					}
 					else {
 						const float dist = len_v3v3(co, nearest.co);
@@ -3504,16 +3506,9 @@ static void shrinkwrap_get_tarmat(struct Depsgraph *depsgraph, bConstraint *con,
 						break;
 					}
 
-					BKE_bvhtree_from_mesh_get(&treeData, target_eval, BVHTREE_FROM_LOOPTRI, 4);
-					if (treeData.tree == NULL) {
-						fail = true;
-						break;
-					}
-
 					char cull_mode = scon->flag & CON_SHRINKWRAP_PROJECT_CULL_MASK;
 
-					BKE_shrinkwrap_project_normal(cull_mode, co, no, 0.0f, &transform, treeData.tree,
-					                              &hit, treeData.raycast_callback, &treeData);
+					BKE_shrinkwrap_project_normal(cull_mode, co, no, 0.0f, &transform, &tree, &hit);
 
 					if (scon->flag & CON_SHRINKWRAP_PROJECT_OPPOSITE) {
 						float inv_no[3];
@@ -3523,8 +3518,7 @@ static void shrinkwrap_get_tarmat(struct Depsgraph *depsgraph, bConstraint *con,
 							cull_mode ^= CON_SHRINKWRAP_PROJECT_CULL_MASK;
 						}
 
-						BKE_shrinkwrap_project_normal(cull_mode, co, inv_no, 0.0f, &transform, treeData.tree,
-						                              &hit, treeData.raycast_callback, &treeData);
+						BKE_shrinkwrap_project_normal(cull_mode, co, inv_no, 0.0f, &transform, &tree, &hit);
 					}
 
 					if (hit.index < 0) {
@@ -3532,12 +3526,17 @@ static void shrinkwrap_get_tarmat(struct Depsgraph *depsgraph, bConstraint *con,
 						break;
 					}
 
-					BKE_shrinkwrap_snap_point_to_surface(scon->shrinkMode, hit.co, hit.no, scon->dist, co, co);
+					if (do_track_normal) {
+						track_normal = true;
+						BKE_shrinkwrap_compute_smooth_normal(&tree, &transform, hit.index, hit.co, hit.no, track_no);
+					}
+
+					BKE_shrinkwrap_snap_point_to_surface(&tree, &transform, scon->shrinkMode, hit.index, hit.co, hit.no, scon->dist, co, co);
 					break;
 				}
 			}
 
-			free_bvhtree_from_mesh(&treeData);
+			BKE_shrinkwrap_free_tree(&tree);
 
 			if (fail == true) {
 				/* Don't move the point */
@@ -3547,6 +3546,11 @@ static void shrinkwrap_get_tarmat(struct Depsgraph *depsgraph, bConstraint *con,
 			/* co is in local object coordinates, change it to global and update target position */
 			mul_m4_v3(cob->matrix, co);
 			copy_v3_v3(ct->matrix[3], co);
+
+			if (track_normal) {
+				mul_mat3_m4_v3(cob->matrix, track_no);
+				damptrack_do_transform(ct->matrix, track_no, scon->trackAxis);
+			}
 		}
 	}
 }
@@ -3557,7 +3561,7 @@ static void shrinkwrap_evaluate(bConstraint *UNUSED(con), bConstraintOb *cob, Li
 
 	/* only evaluate if there is a target */
 	if (VALID_CONS_TARGET(ct)) {
-		copy_v3_v3(cob->matrix[3], ct->matrix[3]);
+		copy_m4_m4(cob->matrix, ct->matrix);
 	}
 }
 
@@ -3631,7 +3635,22 @@ static void damptrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
 	bConstraintTarget *ct = targets->first;
 
 	if (VALID_CONS_TARGET(ct)) {
-		float obvec[3], tarvec[3], obloc[3];
+		float tarvec[3];
+
+		/* find the (unit) direction vector going from the owner to the target */
+		sub_v3_v3v3(tarvec, ct->matrix[3], cob->matrix[3]);
+
+		damptrack_do_transform(cob->matrix, tarvec, data->trackflag);
+	}
+}
+
+static void damptrack_do_transform(float matrix[4][4], const float tarvec_in[3], int track_axis)
+{
+	/* find the (unit) direction vector going from the owner to the target */
+	float tarvec[3];
+
+	if (normalize_v3_v3(tarvec, tarvec_in) != 0.0f) {
+		float obvec[3], obloc

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list