Commit: 62020eddec1a54a3bba2cbeea831f11639e6f39d
Author: Campbell Barton
Date:   Wed Oct 10 15:00:37 2018 +1100
Branches: blender2.8
https://developer.blender.org/rB62020eddec1a54a3bba2cbeea831f11639e6f39d

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).

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

M       source/blender/blenkernel/intern/DerivedMesh.c

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

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);
+

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
Bf-blender-cvs@blender.org
https://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to