Cleanup: naming

- mesh_calc_modifiers & editbmesh_calc_modifiers
  now follow similar naming.
- me and mesh were too easily confused in mesh_calc_modifiers
  (remove 'me', access ob->data).

1 files changed, 99 insertions, 103 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index b7901ad279c..c3b707b603c 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -1220,18 +1220,18 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
 
 static void add_orco_mesh(
         Object *ob, BMEditMesh *em, Mesh *mesh,
-        Mesh *orco_mesh, int layer)
+        Mesh *me_orco, int layer)
 {
 	float (*orco)[3], (*layerorco)[3];
 	int totvert, free;
 
 	totvert = mesh->totvert;
 
-	if (orco_mesh) {
+	if (me_orco) {
 		free = 1;
 
-		if (orco_mesh->totvert == totvert) {
-			orco = BKE_mesh_vertexCos_get(orco_mesh, NULL);
+		if (me_orco->totvert == totvert) {
+			orco = BKE_mesh_vertexCos_get(me_orco, NULL);
 		}
 		else {
 			orco = BKE_mesh_vertexCos_get(mesh, NULL);
@@ -1400,15 +1400,14 @@ static void mesh_calc_modifiers(
         const bool need_mapping, CustomDataMask dataMask,
         const int index, const bool useCache, const bool build_shapekey_layers,
         /* return args */
-        Mesh **r_deform_mesh, Mesh **r_final_mesh)
+        Mesh **r_deform, Mesh **r_final)
 {
-	Mesh *me = ob->data;
 	ModifierData *firstmd, *md, *previewmd = NULL;
 	CDMaskLink *datamasks, *curr;
 	/* XXX Always copying POLYINDEX, else tessellated data are no more valid! */
 	CustomDataMask mask, nextmask, previewmask = 0, append_mask = CD_MASK_ORIGINDEX;
 	float (*deformedVerts)[3] = NULL;
-	int numVerts = me->totvert;
+	int numVerts = ((Mesh *)ob->data)->totvert;
 	const bool useRenderParams = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
 	const int required_mode = useRenderParams ? eModifierMode_Render : eModifierMode_Realtime;
 	bool isPrevDeform = false;
@@ -1420,14 +1419,14 @@ static void mesh_calc_modifiers(
 
 	/* Generic preview only in object mode! */
 	const bool do_mod_mcol = (ob->mode == OB_MODE_OBJECT);
-	const bool do_loop_normals = (me->flag & ME_AUTOSMOOTH) != 0;
+	const bool do_loop_normals = (((Mesh *)ob->data)->flag & ME_AUTOSMOOTH) != 0;
 
 	VirtualModifierData virtualModifierData;
 
 	ModifierApplyFlag app_flags = useRenderParams ? MOD_APPLY_RENDER : 0;
 	ModifierApplyFlag deform_app_flags = app_flags;
 
-	BLI_assert((me->id.tag & LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT) == 0);
+	BLI_assert((((Mesh *)ob->data)->id.tag & LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT) == 0);
 
 	if (useCache)
 		app_flags |= MOD_APPLY_USECACHE;
@@ -1455,10 +1454,10 @@ static void mesh_calc_modifiers(
 	datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, previewmask);
 	curr = datamasks;
 
-	if (r_deform_mesh) {
-		*r_deform_mesh = NULL;
+	if (r_deform) {
+		*r_deform = NULL;
 	}
-	*r_final_mesh = NULL;
+	*r_final = NULL;
 
 	if (useDeform) {
 		if (inputVertexCos)
@@ -1478,7 +1477,7 @@ static void mesh_calc_modifiers(
 
 			if (mti->type == eModifierTypeType_OnlyDeform && !sculpt_dyntopo) {
 				if (!deformedVerts)
-					deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
+					deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
 
 				modwrap_deformVerts(md, &mectx_deform, NULL, deformedVerts, numVerts);
 			}
@@ -1495,17 +1494,17 @@ static void mesh_calc_modifiers(
 		 * places that wish to use the original mesh but with deformed
 		 * coordinates (vpaint, etc.)
 		 */
-		if (r_deform_mesh) {
-			*r_deform_mesh = BKE_mesh_copy_for_eval(me, true);
+		if (r_deform) {
+			*r_deform = BKE_mesh_copy_for_eval(ob->data, true);
 
 			/* XXX: Is build_shapekey_layers ever even true? This should have crashed long ago... */
 			BLI_assert(!build_shapekey_layers);
 			if (build_shapekey_layers) {
-				add_shapekey_layers(*r_deform_mesh, me, ob);
+				add_shapekey_layers(*r_deform, ob->data, ob);
 			}
 
 			if (deformedVerts) {
-				BKE_mesh_apply_vert_coords(*r_deform_mesh, deformedVerts);
+				BKE_mesh_apply_vert_coords(*r_deform, deformedVerts);
 			}
 		}
 	}
@@ -1514,16 +1513,16 @@ static void mesh_calc_modifiers(
 		if (inputVertexCos)
 			deformedVerts = inputVertexCos;
 		else
-			deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
+			deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
 	}
 
 
 	/* Now apply all remaining modifiers. If useDeform is off then skip
 	 * OnlyDeform ones.
 	 */
-	Mesh *mesh = NULL;
-	Mesh *orco_mesh = NULL;
-	Mesh *cloth_orco_mesh = NULL;
+	Mesh *me = NULL;
+	Mesh *me_orco = NULL;
+	Mesh *me_orco_cloth = NULL;
 
 	for (; md; md = md->next, curr = curr->next) {
 		const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
@@ -1536,7 +1535,7 @@ static void mesh_calc_modifiers(
 			continue;
 		}
 
-		if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && mesh) {
+		if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && me) {
 			modifier_setError(md, "Modifier requires original data, bad stack position");
 			continue;
 		}
@@ -1587,8 +1586,8 @@ static void mesh_calc_modifiers(
 		else
 			mask = 0;
 
-		if (mesh && (mask & CD_MASK_ORCO)) {
-			add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_ORCO);
+		if (me && (mask & CD_MASK_ORCO)) {
+			add_orco_mesh(ob, NULL, me, me_orco, CD_ORCO);
 		}
 
 		/* How to apply modifier depends on (a) what we already have as
@@ -1599,15 +1598,15 @@ static void mesh_calc_modifiers(
 		if (mti->type == eModifierTypeType_OnlyDeform) {
 			/* No existing verts to deform, need to build them. */
 			if (!deformedVerts) {
-				if (mesh) {
+				if (me) {
 					/* Deforming a mesh, read the vertex locations
 					 * out of the mesh and deform them. Once done with this
 					 * run of deformers verts will be written back.
 					 */
-					deformedVerts = BKE_mesh_vertexCos_get(mesh, &numVerts);
+					deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
 				}
 				else {
-					deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
+					deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
 				}
 			}
 
@@ -1615,12 +1614,12 @@ static void mesh_calc_modifiers(
 			 * to avoid giving bogus normals to the next modifier see: [#23673] */
 			if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 				/* XXX, this covers bug #23673, but we may need normal calc for other types */
-				if (mesh) {
-					BKE_mesh_apply_vert_coords(mesh, deformedVerts);
+				if (me) {
+					BKE_mesh_apply_vert_coords(me, deformedVerts);
 				}
 			}
 
-			modwrap_deformVerts(md, &mectx_deform, mesh, deformedVerts, numVerts);
+			modwrap_deformVerts(md, &mectx_deform, me, deformedVerts, numVerts);
 		}
 		else {
 			/* determine which data layers are needed by following modifiers */
@@ -1630,21 +1629,21 @@ static void mesh_calc_modifiers(
 				nextmask = dataMask;
 
 			/* apply vertex coordinates or build a Mesh as necessary */
-			if (mesh) {
+			if (me) {
 				if (deformedVerts) {
-					BKE_mesh_apply_vert_coords(mesh, deformedVerts);
+					BKE_mesh_apply_vert_coords(me, deformedVerts);
 				}
 			}
 			else {
-				mesh = BKE_mesh_copy_for_eval(me, true);
-				ASSERT_IS_VALID_MESH(mesh);
+				me = BKE_mesh_copy_for_eval(ob->data, true);
+				ASSERT_IS_VALID_MESH(me);
 
 				if (build_shapekey_layers) {
-					add_shapekey_layers(mesh, me, ob);
+					add_shapekey_layers(me, ob->data, ob);
 				}
 
 				if (deformedVerts) {
-					BKE_mesh_apply_vert_coords(mesh, deformedVerts);
+					BKE_mesh_apply_vert_coords(me, deformedVerts);
 				}
 
 				/* Constructive modifiers need to have an origindex
@@ -1656,14 +1655,14 @@ static void mesh_calc_modifiers(
 				 */
 				if (need_mapping || (nextmask & CD_MASK_ORIGINDEX)) {
 					/* calc */
-					CustomData_add_layer(&mesh->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totvert);
-					CustomData_add_layer(&mesh->edata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totedge);
-					CustomData_add_layer(&mesh->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totpoly);
+					CustomData_add_layer(&me->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totvert);
+					CustomData_add_layer(&me->edata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totedge);
+					CustomData_add_layer(&me->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totpoly);
 
 					/* Not worth parallelizing this, gives less than 0.1% overall speedup in best of best cases... */
-					range_vn_i(CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX), mesh->totvert, 0);
-					range_vn_i(CustomData_get_layer(&mesh->edata, CD_ORIGINDEX), mesh->totedge, 0);
-					range_vn_i(CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX), mesh->totpoly, 0);
+					range_vn_i(CustomData_get_layer(&me->vdata, CD_ORIGINDEX), me->totvert, 0);
+					range_vn_i(CustomData_get_layer(&me->edata, CD_ORIGINDEX), me->totedge, 0);
+					range_vn_i(CustomData_get_layer(&me->pdata, CD_ORIGINDEX), me->totpoly, 0);
 				}
 			}
 
@@ -1673,85 +1672,84 @@ static void mesh_calc_modifiers(
 			/* needMapping check here fixes bug [#28112], otherwise it's
 			 * possible that it won't be copied */
 			mask |= append_mask;
-			mesh_set_only_copy(mesh, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
+			mesh_set_only_copy(me, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
 
 			/* add cloth rest shape key if needed */
 			if (mask & CD_MASK_CLOTH_ORCO)
-				add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_CLOTH_ORCO);
+				add_orco_mesh(ob, NULL, me, me_orco, CD_CLOTH_ORCO);
 
 			/* add an origspace layer if needed */
 			if ((curr->mask) & CD_MASK_ORIGSPACE_MLOOP) {
-				if (!CustomData_has_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP)) {
-					CustomData_add_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, mesh->totloop);
-					mesh_init_origspace(mesh);
+				if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
+					CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
+					mesh_init_origspace(me);
 				}
 			}
 
-			Mesh *new_mesh = modwrap_applyModifier(md, &mectx_apply, mesh);
-			ASSERT_IS_VALID_MESH(new_mesh);
+			Mesh *me_next = modwrap_applyModifier(md, &mectx_apply, me);
+			ASSERT_IS_VALID_MESH(me_next);
 
-			if (new_mesh) {
+			if (me_next) {
 				/* if the modifier returned a new mesh, release the old one */
-				if (mesh && mesh != new_mesh) {
-					BLI_assert(mesh != me);
-					BKE_id_free(NULL, mesh);
+				if (me && me != me_next) {
+					BLI_assert(me != ob->data);
+					BKE_id_free(NULL, me);
 				}
-
-				mesh = new_mesh;
+				me = me_next;
 
 				if (deformedVerts) {
-					if (deformedVerts != inputVertexCos)
+					if (deformedVerts != inputVertexCos) {
 						MEM_freeN(deformedVerts);
-
+					}
 					deformedVerts = NULL;
 				}
 			}
 
 			/* create an orco mesh in parallel */
 			if (nextmask & CD_MASK_ORCO) {
-				if (!orco_mesh) {
-					orco_mesh = create_orco_mesh(ob, me, NULL, CD_ORCO);
+				if (!me_orco) {
+					me_orco = create_orco_mesh(ob, ob->data, NULL, CD_ORCO);
 				}
 
 				nextmask &= ~CD_MASK_ORCO;
-				mesh_set_only_copy(orco_mesh, nextmask | CD_MASK_ORIGINDEX |
+				mesh_set_only_copy(me_orco, nextmask | CD_MASK_ORIGINDEX |
 				                 (mti->requiredDataMask ?
 				                  mti->requiredDataMask(ob, md) : 0));
 
-				new_mesh = modwrap_applyModifier(md, &mectx_orco, orco_mesh);
-				ASSERT_IS_VALID_MESH(new_mesh);
+				me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
+				ASSERT_IS_VALID_MESH(me_next);
 
-				if (new_mesh) {
+				if (me_next) {
 					/* if the modifier returned a new mesh, release the old one */
-					if (orco_mesh && orco_mesh != new_mesh) {
-						BLI_assert(orco_mesh != me);
-						BKE_id_free(NULL, orco_mesh);
+					if (me_orco && me_orco != me_next) {
+						BLI_assert(me_orco != ob->data);
+						BKE_id_free(NULL, me_orco);
 					}
 
-					orco_mesh = new_mesh;
+					me_orco = me_next;
 				}
 			}
 
 			/* create cloth orco mesh in parallel */
 			if (nextmask & CD_MASK_CLOTH_ORCO) {
-				if (!cloth_orco_mesh) {
-					cloth_orco_mesh = create_orco_mesh(ob, me, NULL, CD_CLOTH_ORCO);
+				if (!me_orco_cloth) {
+					me_orco_cloth = create_orco_mesh(ob, ob->data, NULL, CD_CLOTH_ORCO);
 				}
 
 				nextmask &= ~CD_MASK_CLOTH_ORCO;
-				mesh_set_only_copy(cloth_orco_mesh, nextmask | CD_MASK_ORIGINDEX);
+				mesh_set_only_copy(me_orco_cloth, nextmask | CD_MASK_ORIGINDEX);
 
-				new_mesh = modwrap_applyModifier(md, &mectx_orco, cloth_orco_mesh);
-				ASSERT_IS_VALID_DM(new_mesh);
+				me_next = modwrap_applyModifier(md, &mectx_orco, me_orco_cloth);
+				ASSERT_IS_VALID_DM(me_next);
 
-				if (new_mesh) {
+				if (me_next) {
 					/* if the modifier returned a new mesh, release the old one */
-					if (cloth_orco_mesh && cloth_orco_mesh != new_mesh) {
-						BLI_assert(orco_mesh != me);
-						BKE_id_free(NULL, cloth_orco_mesh);
+					if (me_orco_cloth && me_orco_cloth != me_next) {
+						BLI_assert(me_orco != ob->data);
+						BKE_id_free(NULL, me_orco_cloth);
 					}
 
-					cloth_orco_mesh = new_mesh;
+					me_orco_cloth = me_next;
 				}
 			}
 
@@ -1760,7 +1758,7 @@ static void mesh_calc_modifiers(
 			if (md->type == eModifierType_DynamicPaint)
 				append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
 
-			mesh->runtime.deformed_only = false;
+			me->runtime.deformed_only = false;
 		}
 
 		isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
@@ -1781,45 +1779,43 @@ static void mesh_calc_modifiers(
 	 * need to apply these back onto the Mesh. If we have no
 	 * Mesh then we need to build one.
 	 */
-	Mesh *final_mesh;
-
-	if (mesh) {
-		final_mesh = mesh;
+	if (me) {
+		*r_final = me;
 
 		if (deformedVerts) {
-			BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
+			BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
 		}
 	}
 	else {
-		final_mesh = BKE_mesh_copy_for_eval(me, true);
+		*r_final = BKE_mesh_copy_for_eval(ob->data, true);
 
 		if (build_shapekey_layers) {
-			add_shapekey_layers(final_mesh, me, ob);
+			add_shapekey_layers(*r_final, ob->data, ob);
 		}
 
 		if (deformedVerts) {
-			BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
+			BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
 		}
 	}
 
 	/* add an orco layer if needed */
 	if (dataMask & CD_MASK_ORCO) {
-		add_orco_mesh(ob, NULL, final_mesh, orco_mesh, CD_ORCO);
+		add_orco_mesh(ob, NULL, *r_final, me_orco, CD_ORCO);
 
-		if (r_deform_mesh && *r_deform_mesh)
-			add_orco_mesh(ob, NULL, *r_deform_mesh, NULL, CD_ORCO);
+		if (r_deform && *r_deform)
+			add_orco_mesh(ob, NULL, *r_deform, NULL, CD_ORCO);
 	}
 
 	if (do_loop_normals) {
 		/* Compute loop normals (note: will compute poly and vert normals as well, if needed!) */
-		BKE_mesh_calc_normals_split(final_mesh);
-		BKE_mesh_tessface_clear(final_mesh);
+		BKE_mesh_calc_normals_split(*r_final);
+		BKE_mesh_tessface_clear(*r_final);
 	}
 
 	if (sculpt_dyntopo == false) {
 		/* watch this! after 2.75a we move to from tessface to looptri (by default) */
 		if (dataMask & CD_MASK_MFACE) {
-			BKE_mesh_tessface_ensure(final_mesh);
+			BKE_mesh_tessface_ensure(*r_final);
 		}
 
 		/* without this, drawing ngon tri's faces will show ugly tessellated face
@@ -1832,23 +1828,21 @@ static void mesh_calc_modifiers(
 		 * If using loop normals, poly nors have already been computed.
 		 */
 		if (!do_loop_normals) {
-			mesh_ensure_display_normals(final_mesh);
+			mesh_ensure_display_normals(*r_final);
 		}
 	}
 
 	/* Some modifiers, like datatransfer, may generate those data as temp layer, we do not want to keep them,
 	 * as they are used by display code when available (i.e. even if autosmooth is disabled). */
-	if (!do_loop_normals && CustomData_has_layer(&final_mesh->ldata, CD_NORMAL)) {
-		CustomData_free_layers(&final_mesh->ldata, CD_NORMAL, final_mesh->totloop);
+	if (!do_loop_normals && CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
+		CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
 	}
 
-	*r_final_mesh = final_mesh;
-
-	if (orco_mesh) {
-		BKE_id_free(NULL, orco_mesh);
+	if (me_orco) {
+		BKE_id_free(NULL, me_orco);
 	}
-	if (cloth_orco_mesh) {
-		BKE_id_free(NULL, cloth_orco_mesh);
+	if (me_orco_cloth) {
+		BKE_id_free(NULL, me_orco_cloth);
 	}
 
 	if (deformedVerts && deformedVerts != inputVertexCos)
@@ -1925,8 +1919,6 @@ static void editbmesh_calc_modifiers(
 	ModifierData *md;
 	float (*deformedVerts)[3] = NULL;
 	CustomDataMask mask = 0, append_mask = 0;
-	Mesh *me = NULL;
-	Mesh *me_orco = NULL;
 	int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
 	CDMaskLink *datamasks, *curr;
 	const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
@@ -1952,6 +1944,10 @@ static void editbmesh_calc_modifiers(
 	datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, NULL, 0);
 
 	curr = datamasks;
+
+	Mesh *me = NULL;
+	Mesh *me_orco = NULL;
+
 	for (i = 0; md; i++, md = md->next, curr = curr->next) {
 		const ModifierTypeInfo *mti = modifierType_getInfo(md->type);