Cleanup: vertex coordinate access, naming & minor changes
authorCampbell Barton <ideasman42@gmail.com>
Wed, 21 Aug 2019 20:28:35 +0000 (06:28 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 21 Aug 2019 20:48:10 +0000 (06:48 +1000)
This also splits vertex access and allocation so it's possible
to copy coordinates into an existing array without allocating it.

35 files changed:
source/blender/blenkernel/BKE_DerivedMesh.h
source/blender/blenkernel/BKE_curve.h
source/blender/blenkernel/BKE_editmesh.h
source/blender/blenkernel/BKE_lattice.h
source/blender/blenkernel/BKE_mesh.h
source/blender/blenkernel/BKE_pbvh.h
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/crazyspace.c
source/blender/blenkernel/intern/curve.c
source/blender/blenkernel/intern/displist.c
source/blender/blenkernel/intern/editderivedmesh.c
source/blender/blenkernel/intern/editmesh.c
source/blender/blenkernel/intern/lattice.c
source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/mesh_convert.c
source/blender/blenkernel/intern/mesh_remap.c
source/blender/blenkernel/intern/multires_reshape.c
source/blender/blenkernel/intern/paint.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/pbvh.c
source/blender/draw/intern/draw_cache_impl_displist.c
source/blender/editors/mesh/editmesh_knife.c
source/blender/editors/object/object_modifier.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/sculpt_paint/sculpt_undo.c
source/blender/modifiers/intern/MOD_cloth.c
source/blender/modifiers/intern/MOD_collision.c
source/blender/modifiers/intern/MOD_correctivesmooth.c
source/blender/modifiers/intern/MOD_fluidsim_util.c
source/blender/modifiers/intern/MOD_meshdeform.c
source/blender/modifiers/intern/MOD_particlesystem.c
source/blender/modifiers/intern/MOD_surface.c
source/blender/modifiers/intern/MOD_util.c
source/blender/modifiers/intern/MOD_uvproject.c
source/blender/modifiers/intern/MOD_weightvgproximity.c

index bc115fec35afb9b4df50c7ec7da9e1990db61d5a..c866809b7c0500b1d713ff06512a29056501f5f8 100644 (file)
@@ -393,7 +393,7 @@ struct Mesh *editbmesh_get_eval_cage_and_final(struct Depsgraph *depsgraph,
                                                const struct CustomData_MeshMasks *dataMask,
                                                struct Mesh **r_final);
 
-float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
+float (*editbmesh_vert_coords_alloc(struct BMEditMesh *em, int *r_vert_len))[3];
 bool editbmesh_modifier_is_enabled(struct Scene *scene,
                                    struct ModifierData *md,
                                    bool has_prev_mesh);
index dff38f6b6098c40422e81a9f3723e79af9c7b6bd..623d0df16189548cac982fcdf9051fdc6cc949d2 100644 (file)
@@ -124,11 +124,15 @@ void BKE_curve_nurb_vert_active_set(struct Curve *cu, const struct Nurb *nu, con
 bool BKE_curve_nurb_vert_active_get(struct Curve *cu, struct Nurb **r_nu, void **r_vert);
 void BKE_curve_nurb_vert_active_validate(struct Curve *cu);
 
-float (*BKE_curve_nurbs_vertexCos_get(struct ListBase *lb, int *r_numVerts))[3];
-void BK_curve_nurbs_vertexCos_apply(struct ListBase *lb, const float (*vertexCos)[3]);
+float (*BKE_curve_nurbs_vert_coords_alloc(struct ListBase *lb, int *r_vert_len))[3];
+void BKE_curve_nurbs_vert_coords_get(struct ListBase *lb, float (*vert_coords)[3], int vert_len);
 
-float (*BKE_curve_nurbs_keyVertexCos_get(struct ListBase *lb, float *key))[3];
-void BKE_curve_nurbs_keyVertexTilts_apply(struct ListBase *lb, float *key);
+void BK_curve_nurbs_vert_coords_apply(struct ListBase *lb, const float (*vert_coords)[3]);
+
+float (*BKE_curve_nurbs_key_vert_coords_alloc(struct ListBase *lb,
+                                              float *key,
+                                              int *r_vert_len))[3];
+void BKE_curve_nurbs_key_vert_tilts_apply(struct ListBase *lb, float *key);
 
 void BKE_curve_editNurb_keyIndex_delCV(struct GHash *keyindex, const void *cv);
 void BKE_curve_editNurb_keyIndex_free(struct GHash **keyindex);
index b7280c702d2b4bd15804a3d807352d2363895840..6e4132cbc35e83db24b665a71499068a7148b889 100644 (file)
@@ -88,7 +88,7 @@ void BKE_editmesh_free(BMEditMesh *em);
 
 void BKE_editmesh_color_free(BMEditMesh *em);
 void BKE_editmesh_color_ensure(BMEditMesh *em, const char htype);
-float (*BKE_editmesh_vertexCos_get_orco(BMEditMesh *em, int *r_numVerts))[3];
+float (*BKE_editmesh_vert_coords_alloc_orco(BMEditMesh *em, int *r_vert_len))[3];
 void BKE_editmesh_lnorspace_update(BMEditMesh *em);
 void BKE_editmesh_ensure_autosmooth(BMEditMesh *em);
 
@@ -98,7 +98,7 @@ void BKE_editmesh_statvis_calc(BMEditMesh *em,
                                struct EditMeshData *emd,
                                const struct MeshStatVis *statvis);
 
-float (*BKE_editmesh_vertexCos_get(
-    struct Depsgraph *depsgraph, struct BMEditMesh *em, struct Scene *scene, int *r_numVerts))[3];
+float (*BKE_editmesh_vert_coords_alloc(
+    struct Depsgraph *depsgraph, struct BMEditMesh *em, struct Scene *scene, int *r_vert_len))[3];
 
 #endif /* __BKE_EDITMESH_H__ */
index 24594da13c64158aaf3575a735245e8abd0f475e..fbb98b290f0a7c771aa2653586b237e4bb16cedd 100644 (file)
@@ -58,7 +58,7 @@ void outside_lattice(struct Lattice *lt);
 
 void curve_deform_verts(struct Object *cuOb,
                         struct Object *target,
-                        float (*vertexCos)[3],
+                        float (*vert_coords)[3],
                         int numVerts,
                         struct MDeformVert *dvert,
                         const int defgrp_index,
@@ -73,14 +73,14 @@ void curve_deform_vector(struct Object *cuOb,
 void lattice_deform_verts(struct Object *laOb,
                           struct Object *target,
                           struct Mesh *mesh,
-                          float (*vertexCos)[3],
+                          float (*vert_coords)[3],
                           int numVerts,
                           const char *vgroup,
                           float influence);
 void armature_deform_verts(struct Object *armOb,
                            struct Object *target,
                            const struct Mesh *mesh,
-                           float (*vertexCos)[3],
+                           float (*vert_coords)[3],
                            float (*defMats)[3][3],
                            int numVerts,
                            int deformflag,
@@ -88,8 +88,8 @@ void armature_deform_verts(struct Object *armOb,
                            const char *defgrp_name,
                            struct bGPDstroke *gps);
 
-float (*BKE_lattice_vertexcos_get(const struct Lattice *lt, int *r_numVerts))[3];
-void BKE_lattice_vertexcos_apply(struct Lattice *lt, const float (*vertexCos)[3]);
+float (*BKE_lattice_vert_coords_alloc(const struct Lattice *lt, int *r_vert_len))[3];
+void BKE_lattice_vert_coords_apply(struct Lattice *lt, const float (*vert_coords)[3]);
 void BKE_lattice_modifiers_calc(struct Depsgraph *depsgraph,
                                 struct Scene *scene,
                                 struct Object *ob);
index 3de52239d840b404dee1bc39dad656523d382278..b2ae7a6dac09638ef181a7f73648554871bacb81 100644 (file)
@@ -208,8 +208,6 @@ bool BKE_mesh_uv_cdlayer_rename(struct Mesh *me,
                                 const char *new_name,
                                 bool do_tessface);
 
-float (*BKE_mesh_vertexCos_get(const struct Mesh *me, int *r_numVerts))[3];
-
 void BKE_mesh_split_faces(struct Mesh *mesh, bool free_loop_normals);
 
 /* Create new mesh from the given object at its current state.
@@ -268,8 +266,11 @@ void BKE_mesh_mselect_active_set(struct Mesh *me, int index, int type);
 
 void BKE_mesh_count_selected_items(const struct Mesh *mesh, int r_count[3]);
 
-void BKE_mesh_apply_vert_coords(struct Mesh *mesh, const float (*vertCoords)[3]);
-void BKE_mesh_apply_vert_normals(struct Mesh *mesh, const short (*vertNormals)[3]);
+float (*BKE_mesh_vert_coords_alloc(const struct Mesh *mesh, int *r_vert_len))[3];
+void BKE_mesh_vert_coords_get(const struct Mesh *mesh, float (*vert_coords)[3]);
+
+void BKE_mesh_vert_coords_apply(struct Mesh *mesh, const float (*vert_coords)[3]);
+void BKE_mesh_vert_normals_apply(struct Mesh *mesh, const short (*vertNormals)[3]);
 
 /* *** mesh_evaluate.c *** */
 
index d34ff424e05310a2fc0fcd7e0281d6b0de97a3ba..245345d9f1dcfb894e15f63dc650a3a5bf7d5ba3 100644 (file)
@@ -278,9 +278,9 @@ float *BKE_pbvh_node_layer_disp_get(PBVH *pbvh, PBVHNode *node);
 void BKE_pbvh_node_layer_disp_free(PBVHNode *node);
 
 /* vertex deformer */
-float (*BKE_pbvh_get_vertCos(struct PBVH *pbvh))[3];
-void BKE_pbvh_apply_vertCos(struct PBVH *pbvh, const float (*vertCos)[3], const int totvert);
-bool BKE_pbvh_isDeformed(struct PBVH *pbvh);
+float (*BKE_pbvh_vert_coords_alloc(struct PBVH *pbvh))[3];
+void BKE_pbvh_vert_coords_apply(struct PBVH *pbvh, const float (*vertCos)[3], const int totvert);
+bool BKE_pbvh_is_deformed(struct PBVH *pbvh);
 
 /* Vertex Iterator */
 
index f752542133e0bc9633805a7c84e6e22fd7e6fcef..165df2381da0bfb70db93eb36d0dd8d0fb55a91a 100644 (file)
@@ -889,7 +889,7 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
   orco = get_orco_coords(ob, em, layer, &free);
 
   if (orco) {
-    BKE_mesh_apply_vert_coords(mesh, orco);
+    BKE_mesh_vert_coords_apply(mesh, orco);
     if (free) {
       MEM_freeN(orco);
     }
@@ -909,10 +909,10 @@ static void add_orco_mesh(Object *ob, BMEditMesh *em, Mesh *mesh, Mesh *mesh_orc
     free = 1;
 
     if (mesh_orco->totvert == totvert) {
-      orco = BKE_mesh_vertexCos_get(mesh_orco, NULL);
+      orco = BKE_mesh_vert_coords_alloc(mesh_orco, NULL);
     }
     else {
-      orco = BKE_mesh_vertexCos_get(mesh, NULL);
+      orco = BKE_mesh_vert_coords_alloc(mesh, NULL);
     }
   }
   else {
@@ -1208,14 +1208,14 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
 
       if (mti->type == eModifierTypeType_OnlyDeform && !sculpt_dyntopo) {
         if (!deformed_verts) {
-          deformed_verts = BKE_mesh_vertexCos_get(mesh_input, &num_deformed_verts);
+          deformed_verts = BKE_mesh_vert_coords_alloc(mesh_input, &num_deformed_verts);
         }
         else if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
           if (mesh_final == NULL) {
             mesh_final = BKE_mesh_copy_for_eval(mesh_input, true);
             ASSERT_IS_VALID_MESH(mesh_final);
           }
-          BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+          BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
         }
 
         modwrap_deformVerts(md, &mectx, mesh_final, deformed_verts, num_deformed_verts);
@@ -1239,7 +1239,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
       mesh_deform = BKE_mesh_copy_for_eval(mesh_input, true);
 
       if (deformed_verts) {
-        BKE_mesh_apply_vert_coords(mesh_deform, deformed_verts);
+        BKE_mesh_vert_coords_apply(mesh_deform, deformed_verts);
       }
     }
   }
@@ -1322,10 +1322,10 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
           /* 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. */
-          deformed_verts = BKE_mesh_vertexCos_get(mesh_final, &num_deformed_verts);
+          deformed_verts = BKE_mesh_vert_coords_alloc(mesh_final, &num_deformed_verts);
         }
         else {
-          deformed_verts = BKE_mesh_vertexCos_get(mesh_input, &num_deformed_verts);
+          deformed_verts = BKE_mesh_vert_coords_alloc(mesh_input, &num_deformed_verts);
         }
       }
       /* if this is not the last modifier in the stack then recalculate the normals
@@ -1333,7 +1333,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
       else if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
         /* XXX, this covers bug #23673, but we may need normal calc for other types */
         if (mesh_final) {
-          BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+          BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
         }
       }
 
@@ -1352,7 +1352,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
       /* apply vertex coordinates or build a Mesh as necessary */
       if (mesh_final) {
         if (deformed_verts) {
-          BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+          BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
         }
       }
       else {
@@ -1360,7 +1360,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
         ASSERT_IS_VALID_MESH(mesh_final);
 
         if (deformed_verts) {
-          BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+          BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
         }
 
         /* Initialize original indices the first time we evaluate a
@@ -1539,7 +1539,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
     }
   }
   if (deformed_verts) {
-    BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+    BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
     MEM_freeN(deformed_verts);
     deformed_verts = NULL;
   }
@@ -1599,14 +1599,14 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
   }
 }
 
-float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
+float (*editbmesh_vert_coords_alloc(BMEditMesh *em, int *r_vert_len))[3]
 {
   BMIter iter;
   BMVert *eve;
   float(*cos)[3];
   int i;
 
-  *r_numVerts = em->bm->totvert;
+  *r_vert_len = em->bm->totvert;
 
   cos = MEM_malloc_arrayN(em->bm->totvert, 3 * sizeof(float), "vertexcos");
 
@@ -1778,10 +1778,10 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
           /* Deforming a derived mesh, read the vertex locations
            * out of the mesh and deform them. Once done with this
            * run of deformers verts will be written back. */
-          deformed_verts = BKE_mesh_vertexCos_get(mesh_final, &num_deformed_verts);
+          deformed_verts = BKE_mesh_vert_coords_alloc(mesh_final, &num_deformed_verts);
         }
         else {
-          deformed_verts = editbmesh_get_vertex_cos(em_input, &num_deformed_verts);
+          deformed_verts = editbmesh_vert_coords_alloc(em_input, &num_deformed_verts);
         }
       }
       else if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
@@ -1791,7 +1791,7 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
           mesh_copy_autosmooth(mesh_final, mesh_input);
         }
         BLI_assert(deformed_verts != NULL);
-        BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+        BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
       }
 
       if (mti->deformVertsEM) {
@@ -1811,7 +1811,7 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
             BKE_id_free(NULL, mesh_final);
           }
           mesh_final = mesh_tmp;
-          BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+          BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
         }
         else if (mesh_final == mesh_cage) {
           /* 'me' may be changed by this modifier, so we need to copy it. */
@@ -1825,7 +1825,7 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
         mesh_copy_autosmooth(mesh_final, mesh_input);
 
         if (deformed_verts) {
-          BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+          BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
         }
       }
 
@@ -1895,7 +1895,7 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
     if (r_cage && i == cageIndex) {
       if (mesh_final && deformed_verts) {
         mesh_cage = BKE_mesh_copy_for_eval(mesh_final, false);
-        BKE_mesh_apply_vert_coords(mesh_cage, deformed_verts);
+        BKE_mesh_vert_coords_apply(mesh_cage, deformed_verts);
       }
       else if (mesh_final) {
         mesh_cage = mesh_final;
@@ -1927,7 +1927,7 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
         BKE_id_free(NULL, mesh_final);
       }
       mesh_final = mesh_tmp;
-      BKE_mesh_apply_vert_coords(mesh_final, deformed_verts);
+      BKE_mesh_vert_coords_apply(mesh_final, deformed_verts);
     }
   }
   else if (!deformed_verts && mesh_cage) {
index 09bbc6c0d13a5f53552d0cc863dcdc5899472b21..fcbebd24b4a91cf9efcc9a9599476d201897988f 100644 (file)
@@ -293,7 +293,7 @@ int BKE_crazyspace_get_first_deform_matrices_editbmesh(struct Depsgraph *depsgra
         BLI_linklist_free((LinkNode *)datamasks, NULL);
 
         me = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, &data_mask, NULL);
-        deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
+        deformedVerts = editbmesh_vert_coords_alloc(em, &numVerts);
         defmats = MEM_mallocN(sizeof(*defmats) * numVerts, "defmats");
 
         for (a = 0; a < numVerts; a++) {
@@ -383,7 +383,7 @@ int BKE_sculpt_get_first_deform_matrices(struct Depsgraph *depsgraph,
          * state. */
         Mesh *me = object_eval.data;
         me_eval = BKE_mesh_copy_for_eval(me, true);
-        deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
+        deformedVerts = BKE_mesh_vert_coords_alloc(me, &numVerts);
         defmats = MEM_callocN(sizeof(*defmats) * numVerts, "defmats");
 
         for (a = 0; a < numVerts; a++) {
@@ -485,7 +485,7 @@ void BKE_crazyspace_build_sculpt(struct Depsgraph *depsgraph,
     int a, numVerts;
     Mesh *mesh = (Mesh *)object->data;
 
-    *deformcos = BKE_mesh_vertexCos_get(mesh, &numVerts);
+    *deformcos = BKE_mesh_vert_coords_alloc(mesh, &numVerts);
     *deformmats = MEM_callocN(sizeof(*(*deformmats)) * numVerts, "defmats");
 
     for (a = 0; a < numVerts; a++) {
index 5ec0483d63769d2de7557b4edfd5f1096601f5ae..24a9d5dc199762c0e65ef996bcdb928386e1297d 100644 (file)
@@ -4606,18 +4606,13 @@ void BKE_nurb_direction_switch(Nurb *nu)
   }
 }
 
-float (*BKE_curve_nurbs_vertexCos_get(ListBase *lb, int *r_numVerts))[3]
+void BKE_curve_nurbs_vert_coords_get(ListBase *lb, float (*vert_coords)[3], int vert_len)
 {
-  int i, numVerts = *r_numVerts = BKE_nurbList_verts_count(lb);
-  float *co, (*cos)[3] = MEM_malloc_arrayN(numVerts, sizeof(*cos), "cu_vcos");
-  Nurb *nu;
-
-  co = cos[0];
-  for (nu = lb->first; nu; nu = nu->next) {
+  float *co = vert_coords[0];
+  for (Nurb *nu = lb->first; nu; nu = nu->next) {
     if (nu->type == CU_BEZIER) {
       BezTriple *bezt = nu->bezt;
-
-      for (i = 0; i < nu->pntsu; i++, bezt++) {
+      for (int i = 0; i < nu->pntsu; i++, bezt++) {
         copy_v3_v3(co, bezt->vec[0]);
         co += 3;
         copy_v3_v3(co, bezt->vec[1]);
@@ -4628,28 +4623,33 @@ float (*BKE_curve_nurbs_vertexCos_get(ListBase *lb, int *r_numVerts))[3]
     }
     else {
       BPoint *bp = nu->bp;
-
-      for (i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
+      for (int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
         copy_v3_v3(co, bp->vec);
         co += 3;
       }
     }
   }
+  BLI_assert(co == vert_coords[vert_len]);
+}
 
-  return cos;
+float (*BKE_curve_nurbs_vert_coords_alloc(ListBase *lb, int *r_vert_len))[3]
+{
+  const int vert_len = BKE_nurbList_verts_count(lb);
+  float(*vert_coords)[3] = MEM_malloc_arrayN(vert_len, sizeof(*vert_coords), __func__);
+  BKE_curve_nurbs_vert_coords_get(lb, vert_coords, vert_len);
+  *r_vert_len = vert_len;
+  return vert_coords;
 }
 
-void BK_curve_nurbs_vertexCos_apply(ListBase *lb, const float (*vertexCos)[3])
+void BK_curve_nurbs_vert_coords_apply(ListBase *lb, const float (*vert_coords)[3])
 {
-  const float *co = vertexCos[0];
-  Nurb *nu;
-  int i;
+  const float *co = vert_coords[0];
 
-  for (nu = lb->first; nu; nu = nu->next) {
+  for (Nurb *nu = lb->first; nu; nu = nu->next) {
     if (nu->type == CU_BEZIER) {
       BezTriple *bezt = nu->bezt;
 
-      for (i = 0; i < nu->pntsu; i++, bezt++) {
+      for (int i = 0; i < nu->pntsu; i++, bezt++) {
         copy_v3_v3(bezt->vec[0], co);
         co += 3;
         copy_v3_v3(bezt->vec[1], co);
@@ -4661,7 +4661,7 @@ void BK_curve_nurbs_vertexCos_apply(ListBase *lb, const float (*vertexCos)[3])
     else {
       BPoint *bp = nu->bp;
 
-      for (i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
+      for (int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
         copy_v3_v3(bp->vec, co);
         co += 3;
       }
@@ -4671,18 +4671,17 @@ void BK_curve_nurbs_vertexCos_apply(ListBase *lb, const float (*vertexCos)[3])
   }
 }
 
-float (*BKE_curve_nurbs_keyVertexCos_get(ListBase *lb, float *key))[3]
+float (*BKE_curve_nurbs_key_vert_coords_alloc(ListBase *lb, float *key, int *r_vert_len))[3]
 {
-  int i, numVerts = BKE_nurbList_verts_count(lb);
-  float *co, (*cos)[3] = MEM_malloc_arrayN(numVerts, sizeof(*cos), "cu_vcos");
-  Nurb *nu;
+  int vert_len = BKE_nurbList_verts_count(lb);
+  float(*cos)[3] = MEM_malloc_arrayN(vert_len, sizeof(*cos), __func__);
 
-  co = cos[0];
-  for (nu = lb->first; nu; nu = nu->next) {
+  float *co = cos[0];
+  for (Nurb *nu = lb->first; nu; nu = nu->next) {
     if (nu->type == CU_BEZIER) {
       BezTriple *bezt = nu->bezt;
 
-      for (i = 0; i < nu->pntsu; i++, bezt++) {
+      for (int i = 0; i < nu->pntsu; i++, bezt++) {
         copy_v3_v3(co, &key[0]);
         co += 3;
         copy_v3_v3(co, &key[3]);
@@ -4695,18 +4694,18 @@ float (*BKE_curve_nurbs_keyVertexCos_get(ListBase *lb, float *key))[3]
     else {
       BPoint *bp = nu->bp;
 
-      for (i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
+      for (int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
         copy_v3_v3(co, key);
         co += 3;
         key += KEYELEM_FLOAT_LEN_BPOINT;
       }
     }
   }
-
+  *r_vert_len = vert_len;
   return cos;
 }
 
-void BKE_curve_nurbs_keyVertexTilts_apply(ListBase *lb, float *key)
+void BKE_curve_nurbs_key_vert_tilts_apply(ListBase *lb, float *key)
 {
   Nurb *nu;
   int i;
index 83a10344b96fe055a18c30100635e488aaefbb25..d2a62b3c2f8ca874fff82c748f3887c878cf210e 100644 (file)
@@ -892,8 +892,7 @@ static void curve_calc_modifiers_pre(
        * tilts, which is passed through in the modifier stack.
        * this is also the reason curves do not use a virtual
        * shape key modifier yet. */
-      deformedVerts = BKE_curve_nurbs_keyVertexCos_get(nurb, keyVerts);
-      numVerts = BKE_nurbList_verts_count(nurb);
+      deformedVerts = BKE_curve_nurbs_key_vert_coords_alloc(nurb, keyVerts, &numVerts);
     }
   }
 
@@ -909,7 +908,7 @@ static void curve_calc_modifiers_pre(
       }
 
       if (!deformedVerts) {
-        deformedVerts = BKE_curve_nurbs_vertexCos_get(nurb, &numVerts);
+        deformedVerts = BKE_curve_nurbs_vert_coords_alloc(nurb, &numVerts);
       }
 
       mti->deformVerts(md, &mectx, NULL, deformedVerts, numVerts);
@@ -921,11 +920,11 @@ static void curve_calc_modifiers_pre(
   }
 
   if (deformedVerts) {
-    BK_curve_nurbs_vertexCos_apply(nurb, deformedVerts);
+    BK_curve_nurbs_vert_coords_apply(nurb, deformedVerts);
     MEM_freeN(deformedVerts);
   }
   if (keyVerts) { /* these are not passed through modifier stack */
-    BKE_curve_nurbs_keyVertexTilts_apply(nurb, keyVerts);
+    BKE_curve_nurbs_key_vert_tilts_apply(nurb, keyVerts);
   }
 
   if (keyVerts) {
@@ -933,18 +932,18 @@ static void curve_calc_modifiers_pre(
   }
 }
 
-static float (*displist_get_allverts(ListBase *dispbase, int *totvert))[3]
+static float (*displist_vert_coords_alloc(ListBase *dispbase, int *r_vert_len))[3]
 {
   DispList *dl;
   float(*allverts)[3], *fp;
 
-  *totvert = 0;
+  *r_vert_len = 0;
 
   for (dl = dispbase->first; dl; dl = dl->next) {
-    *totvert += (dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr;
+    *r_vert_len += (dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr;
   }
 
-  allverts = MEM_mallocN((*totvert) * sizeof(float) * 3, "displist_get_allverts allverts");
+  allverts = MEM_mallocN((*r_vert_len) * sizeof(float) * 3, "displist_vert_coords_alloc allverts");
   fp = (float *)allverts;
   for (dl = dispbase->first; dl; dl = dl->next) {
     int offs = 3 * ((dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr);
@@ -955,7 +954,7 @@ static float (*displist_get_allverts(ListBase *dispbase, int *totvert))[3]
   return allverts;
 }
 
-static void displist_apply_allverts(ListBase *dispbase, float (*allverts)[3])
+static void displist_vert_coords_apply(ListBase *dispbase, float (*allverts)[3])
 {
   DispList *dl;
   const float *fp;
@@ -1027,7 +1026,7 @@ static void curve_calc_modifiers_post(Depsgraph *depsgraph,
      * we need to create a Mesh for each curve that uses modifiers. */
     if (modified == NULL /* && need_normal */) {
       if (vertCos != NULL) {
-        displist_apply_allverts(dispbase, vertCos);
+        displist_vert_coords_apply(dispbase, vertCos);
       }
 
       if (ELEM(ob->type, OB_CURVE, OB_FONT) && (cu->flag & CU_DEFORM_FILL)) {
@@ -1041,7 +1040,7 @@ static void curve_calc_modifiers_post(Depsgraph *depsgraph,
         (mti->type == eModifierTypeType_DeformOrConstruct && !modified)) {
       if (modified) {
         if (!vertCos) {
-          vertCos = BKE_mesh_vertexCos_get(modified, &totvert);
+          vertCos = BKE_mesh_vert_coords_alloc(modified, &totvert);
         }
         if (need_normal) {
           BKE_mesh_ensure_normals(modified);
@@ -1050,7 +1049,7 @@ static void curve_calc_modifiers_post(Depsgraph *depsgraph,
       }
       else {
         if (!vertCos) {
-          vertCos = displist_get_allverts(dispbase, &totvert);
+          vertCos = displist_vert_coords_alloc(dispbase, &totvert);
         }
         mti->deformVerts(md, &mectx_deform, NULL, vertCos, totvert);
       }
@@ -1071,12 +1070,12 @@ static void curve_calc_modifiers_post(Depsgraph *depsgraph,
           BKE_id_free(NULL, modified);
           modified = temp_mesh;
 
-          BKE_mesh_apply_vert_coords(modified, vertCos);
+          BKE_mesh_vert_coords_apply(modified, vertCos);
         }
       }
       else {
         if (vertCos) {
-          displist_apply_allverts(dispbase, vertCos);
+          displist_vert_coords_apply(dispbase, vertCos);
         }
 
         if (ELEM(ob->type, OB_CURVE, OB_FONT) && (cu->flag & CU_DEFORM_FILL)) {
@@ -1115,13 +1114,13 @@ static void curve_calc_modifiers_post(Depsgraph *depsgraph,
       BKE_id_free(NULL, modified);
       modified = temp_mesh;
 
-      BKE_mesh_apply_vert_coords(modified, vertCos);
+      BKE_mesh_vert_coords_apply(modified, vertCos);
       BKE_mesh_calc_normals_mapping_simple(modified);
 
       MEM_freeN(vertCos);
     }
     else {
-      displist_apply_allverts(dispbase, vertCos);
+      displist_vert_coords_apply(dispbase, vertCos);
       MEM_freeN(vertCos);
       vertCos = NULL;
     }
index 06f297b23e0dd4f66a90a3b07243fa67eab97292..2df3d2f0fe9b45f955b4e5c5f4dcac6afa026a3d 100644 (file)
@@ -517,8 +517,8 @@ static void cage_mapped_verts_callback(void *userData,
   }
 }
 
-float (*BKE_editmesh_vertexCos_get(
-    struct Depsgraph *depsgraph, BMEditMesh *em, Scene *scene, int *r_numVerts))[3]
+float (*BKE_editmesh_vert_coords_alloc(
+    struct Depsgraph *depsgraph, BMEditMesh *em, Scene *scene, int *r_vert_len))[3]
 {
   Mesh *cage;
   BLI_bitmap *visit_bitmap;
@@ -540,8 +540,8 @@ float (*BKE_editmesh_vertexCos_get(
 
   MEM_freeN(visit_bitmap);
 
-  if (r_numVerts) {
-    *r_numVerts = em->bm->totvert;
+  if (r_vert_len) {
+    *r_vert_len = em->bm->totvert;
   }
 
   return cos_cage;
index 1c3f6a56629260109ad9d473fe983d6ad9b5c210..4f4aeab721b30a1befcfda2382f6de2a0b60a0cf 100644 (file)
@@ -209,7 +209,7 @@ void BKE_editmesh_color_ensure(BMEditMesh *em, const char htype)
   }
 }
 
-float (*BKE_editmesh_vertexCos_get_orco(BMEditMesh *em, int *r_numVerts))[3]
+float (*BKE_editmesh_vert_coords_alloc_orco(BMEditMesh *em, int *r_vert_len))[3]
 {
   BMIter iter;
   BMVert *eve;
@@ -222,7 +222,7 @@ float (*BKE_editmesh_vertexCos_get_orco(BMEditMesh *em, int *r_numVerts))[3]
     copy_v3_v3(orco[i], eve->co);
   }
 
-  *r_numVerts = em->bm->totvert;
+  *r_vert_len = em->bm->totvert;
 
   return orco;
 }
index 3000a8abc084b6bb292f6f27d3777ec407c2623a..64ba02db30d152791069e3f0efe9e8cf30304c44 100644 (file)
@@ -139,7 +139,7 @@ void BKE_lattice_resize(Lattice *lt, int uNew, int vNew, int wNew, Object *ltOb)
   BPoint *bp;
   int i, u, v, w;
   float fu, fv, fw, uc, vc, wc, du = 0.0, dv = 0.0, dw = 0.0;
-  float *co, (*vertexCos)[3] = NULL;
+  float *co, (*vert_coords)[3] = NULL;
 
   /* vertex weight groups are just freed all for now */
   if (lt->dvert) {
@@ -159,7 +159,7 @@ void BKE_lattice_resize(Lattice *lt, int uNew, int vNew, int wNew, Object *ltOb)
     }
   }
 
-  vertexCos = MEM_mallocN(sizeof(*vertexCos) * uNew * vNew * wNew, "tmp_vcos");
+  vert_coords = MEM_mallocN(sizeof(*vert_coords) * uNew * vNew * wNew, "tmp_vcos");
 
   calc_lat_fudu(lt->flag, uNew, &fu, &du);
   calc_lat_fudu(lt->flag, vNew, &fv, &dv);
@@ -187,7 +187,7 @@ void BKE_lattice_resize(Lattice *lt, int uNew, int vNew, int wNew, Object *ltOb)
     }
   }
 
-  co = vertexCos[0];
+  co = vert_coords[0];
   for (w = 0, wc = fw; w < wNew; w++, wc += dw) {
     for (v = 0, vc = fv; v < vNew; v++, vc += dv) {
       for (u = 0, uc = fu; u < uNew; u++, co += 3, uc += du) {
@@ -212,7 +212,7 @@ void BKE_lattice_resize(Lattice *lt, int uNew, int vNew, int wNew, Object *ltOb)
 
     copy_m4_m4(mat, ltOb->obmat);
     unit_m4(ltOb->obmat);
-    lattice_deform_verts(ltOb, NULL, NULL, vertexCos, uNew * vNew * wNew, NULL, 1.0f);
+    lattice_deform_verts(ltOb, NULL, NULL, vert_coords, uNew * vNew * wNew, NULL, 1.0f);
     copy_m4_m4(ltOb->obmat, mat);
 
     lt->typeu = typeu;
@@ -238,10 +238,10 @@ void BKE_lattice_resize(Lattice *lt, int uNew, int vNew, int wNew, Object *ltOb)
   bp = lt->def;
 
   for (i = 0; i < lt->pntsu * lt->pntsv * lt->pntsw; i++, bp++) {
-    copy_v3_v3(bp->vec, vertexCos[i]);
+    copy_v3_v3(bp->vec, vert_coords[i]);
   }
 
-  MEM_freeN(vertexCos);
+  MEM_freeN(vert_coords);
 }
 
 void BKE_lattice_init(Lattice *lt)
@@ -747,7 +747,7 @@ static bool calc_curve_deform(
 
 void curve_deform_verts(Object *cuOb,
                         Object *target,
-                        float (*vertexCos)[3],
+                        float (*vert_coords)[3],
                         int numVerts,
                         MDeformVert *dvert,
                         const int defgrp_index,
@@ -786,11 +786,11 @@ void curve_deform_verts(Object *cuOb,
         const float weight = defvert_find_weight(dvert_iter, defgrp_index);
 
         if (weight > 0.0f) {
-          mul_m4_v3(cd.curvespace, vertexCos[a]);
-          copy_v3_v3(vec, vertexCos[a]);
+          mul_m4_v3(cd.curvespace, vert_coords[a]);
+          copy_v3_v3(vec, vert_coords[a]);
           calc_curve_deform(cuOb, vec, defaxis, &cd, NULL);
-          interp_v3_v3v3(vertexCos[a], vertexCos[a], vec, weight);
-          mul_m4_v3(cd.objectspace, vertexCos[a]);
+          interp_v3_v3v3(vert_coords[a], vert_coords[a], vec, weight);
+          mul_m4_v3(cd.objectspace, vert_coords[a]);
         }
       }
     }
@@ -800,8 +800,8 @@ void curve_deform_verts(Object *cuOb,
 
       for (a = 0, dvert_iter = dvert; a < numVerts; a++, dvert_iter++) {
         if (defvert_find_weight(dvert_iter, defgrp_index) > 0.0f) {
-          mul_m4_v3(cd.curvespace, vertexCos[a]);
-          minmax_v3v3_v3(cd.dmin, cd.dmax, vertexCos[a]);
+          mul_m4_v3(cd.curvespace, vert_coords[a]);
+          minmax_v3v3_v3(cd.dmin, cd.dmax, vert_coords[a]);
         }
       }
 
@@ -810,10 +810,10 @@ void curve_deform_verts(Object *cuOb,
 
         if (weight > 0.0f) {
           /* already in 'cd.curvespace', prev for loop */
-          copy_v3_v3(vec, vertexCos[a]);
+          copy_v3_v3(vec, vert_coords[a]);
           calc_curve_deform(cuOb, vec, defaxis, &cd, NULL);
-          interp_v3_v3v3(vertexCos[a], vertexCos[a], vec, weight);
-          mul_m4_v3(cd.objectspace, vertexCos[a]);
+          interp_v3_v3v3(vert_coords[a], vert_coords[a], vec, weight);
+          mul_m4_v3(cd.objectspace, vert_coords[a]);
         }
       }
     }
@@ -821,9 +821,9 @@ void curve_deform_verts(Object *cuOb,
   else {
     if (cu->flag & CU_DEFORM_BOUNDS_OFF) {
       for (a = 0; a < numVerts; a++) {
-        mul_m4_v3(cd.curvespace, vertexCos[a]);
-        calc_curve_deform(cuOb, vertexCos[a], defaxis, &cd, NULL);
-        mul_m4_v3(cd.objectspace, vertexCos[a]);
+        mul_m4_v3(cd.curvespace, vert_coords[a]);
+        calc_curve_deform(cuOb, vert_coords[a], defaxis, &cd, NULL);
+        mul_m4_v3(cd.objectspace, vert_coords[a]);
       }
     }
     else {
@@ -831,14 +831,14 @@ void curve_deform_verts(Object *cuOb,
       INIT_MINMAX(cd.dmin, cd.dmax);
 
       for (a = 0; a < numVerts; a++) {
-        mul_m4_v3(cd.curvespace, vertexCos[a]);
-        minmax_v3v3_v3(cd.dmin, cd.dmax, vertexCos[a]);
+        mul_m4_v3(cd.curvespace, vert_coords[a]);
+        minmax_v3v3_v3(cd.dmin, cd.dmax, vert_coords[a]);
       }
 
       for (a = 0; a < numVerts; a++) {
         /* already in 'cd.curvespace', prev for loop */
-        calc_curve_deform(cuOb, vertexCos[a], defaxis, &cd, NULL);
-        mul_m4_v3(cd.objectspace, vertexCos[a]);
+        calc_curve_deform(cuOb, vert_coords[a], defaxis, &cd, NULL);
+        mul_m4_v3(cd.objectspace, vert_coords[a]);
       }
     }
   }
@@ -881,7 +881,7 @@ void curve_deform_vector(
 
 typedef struct LatticeDeformUserdata {
   LatticeDeformData *lattice_deform_data;
-  float (*vertexCos)[3];
+  float (*vert_coords)[3];
   MDeformVert *dvert;
   int defgrp_index;
   float fac;
@@ -896,18 +896,18 @@ static void lattice_deform_vert_task(void *__restrict userdata,
   if (data->dvert != NULL) {
     const float weight = defvert_find_weight(data->dvert + index, data->defgrp_index);
     if (weight > 0.0f) {
-      calc_latt_deform(data->lattice_deform_data, data->vertexCos[index], weight * data->fac);
+      calc_latt_deform(data->lattice_deform_data, data->vert_coords[index], weight * data->fac);
     }
   }
   else {
-    calc_latt_deform(data->lattice_deform_data, data->vertexCos[index], data->fac);
+    calc_latt_deform(data->lattice_deform_data, data->vert_coords[index], data->fac);
   }
 }
 
 void lattice_deform_verts(Object *laOb,
                           Object *target,
                           Mesh *mesh,
-                          float (*vertexCos)[3],
+                          float (*vert_coords)[3],
                           int numVerts,
                           const char *vgroup,
                           float fac)
@@ -942,11 +942,13 @@ void lattice_deform_verts(Object *laOb,
     }
   }
 
-  LatticeDeformUserdata data = {.lattice_deform_data = lattice_deform_data,
-                                .vertexCos = vertexCos,
-                                .dvert = dvert,
-                                .defgrp_index = defgrp_index,
-                                .fac = fac};
+  LatticeDeformUserdata data = {
+      .lattice_deform_data = lattice_deform_data,
+      .vert_coords = vert_coords,
+      .dvert = dvert,
+      .defgrp_index = defgrp_index,
+      .fac = fac,
+  };
 
   TaskParallelSettings settings;
   BLI_parallel_range_settings_defaults(&settings);
@@ -1055,31 +1057,30 @@ void outside_lattice(Lattice *lt)
   }
 }
 
-float (*BKE_lattice_vertexcos_get(const Lattice *lt, int *r_numVerts))[3]
+float (*BKE_lattice_vert_coords_alloc(const Lattice *lt, int *r_vert_len))[3]
 {
-  int i, numVerts;
-  float(*vertexCos)[3];
+  int vert_len;
+  float(*vert_coords)[3];
 
   if (lt->editlatt) {
     lt = lt->editlatt->latt;
   }
-  numVerts = *r_numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
+  vert_len = *r_vert_len = lt->pntsu * lt->pntsv * lt->pntsw;
 
-  vertexCos = MEM_mallocN(sizeof(*vertexCos) * numVerts, "lt_vcos");
+  vert_coords = MEM_mallocN(sizeof(*vert_coords) * vert_len, __func__);
 
-  for (i = 0; i < numVerts; i++) {
-    copy_v3_v3(vertexCos[i], lt->def[i].vec);
+  for (int i = 0; i < vert_len; i++) {
+    copy_v3_v3(vert_coords[i], lt->def[i].vec);
   }
 
-  return vertexCos;
+  return vert_coords;
 }
 
-void BKE_lattice_vertexcos_apply(Lattice *lt, const float (*vertexCos)[3])
+void BKE_lattice_vert_coords_apply(Lattice *lt, const float (*vert_coords)[3])
 {
-  int i, numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
-
-  for (i = 0; i < numVerts; i++) {
-    copy_v3_v3(lt->def[i].vec, vertexCos[i]);
+  const int vert_len = lt->pntsu * lt->pntsv * lt->pntsw;
+  for (int i = 0; i < vert_len; i++) {
+    copy_v3_v3(lt->def[i].vec, vert_coords[i]);
   }
 }
 
@@ -1091,7 +1092,7 @@ void BKE_lattice_modifiers_calc(struct Depsgraph *depsgraph, Scene *scene, Objec
   Object *ob_orig = DEG_get_original_object(ob);
   VirtualModifierData virtualModifierData;
   ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
-  float(*vertexCos)[3] = NULL;
+  float(*vert_coords)[3] = NULL;
   int numVerts, editmode = (lt->editlatt != NULL);
   const ModifierEvalContext mectx = {depsgraph, ob, 0};
 
@@ -1121,29 +1122,29 @@ void BKE_lattice_modifiers_calc(struct Depsgraph *depsgraph, Scene *scene, Objec
       continue;
     }
 
-    if (!vertexCos) {
-      vertexCos = BKE_lattice_vertexcos_get(ob_orig->data, &numVerts);
+    if (!vert_coords) {
+      vert_coords = BKE_lattice_vert_coords_alloc(ob_orig->data, &numVerts);
     }
-    mti->deformVerts(md, &mectx, NULL, vertexCos, numVerts);
+    mti->deformVerts(md, &mectx, NULL, vert_coords, numVerts);
   }
 
   if (ob->id.tag & LIB_TAG_COPIED_ON_WRITE) {
-    if (vertexCos) {
-      BKE_lattice_vertexcos_apply(ob->data, vertexCos);
-      MEM_freeN(vertexCos);
+    if (vert_coords) {
+      BKE_lattice_vert_coords_apply(ob->data, vert_coords);
+      MEM_freeN(vert_coords);
     }
   }
   else {
     /* Displist won't do anything; this is just for posterity's sake until we remove it. */
-    if (!vertexCos) {
-      vertexCos = BKE_lattice_vertexcos_get(ob_orig->data, &numVerts);
+    if (!vert_coords) {
+      vert_coords = BKE_lattice_vert_coords_alloc(ob_orig->data, &numVerts);
     }
 
     DispList *dl = MEM_callocN(sizeof(*dl), "lt_dl");
     dl->type = DL_VERTS;
     dl->parts = 1;
     dl->nr = numVerts;
-    dl->verts = (float *)vertexCos;
+    dl->verts = (float *)vert_coords;
 
     BLI_addtail(&ob->runtime.curve_cache->disp, dl);
   }
index 0811b3cef3bcab7762312e3066d0e8a9c770e6cc..9c5ae9b8ca617d2c64989317a14d618f801d280c 100644 (file)
@@ -801,7 +801,7 @@ Mesh *BKE_mesh_from_editmesh_with_coords_thin_wrap(BMEditMesh *em,
   me->runtime.is_original = true;
   if (vertexCos) {
     /* We will own this array in the future. */
-    BKE_mesh_apply_vert_coords(me, vertexCos);
+    BKE_mesh_vert_coords_apply(me, vertexCos);
     MEM_freeN(vertexCos);
     me->runtime.is_original = false;
   }
@@ -1301,25 +1301,6 @@ void BKE_mesh_smooth_flag_set(Object *meshOb, int enableSmooth)
   }
 }
 
-/**
- * Return a newly MEM_malloc'd array of all the mesh vertex locations
- * \note \a r_verts_len may be NULL
- */
-float (*BKE_mesh_vertexCos_get(const Mesh *me, int *r_verts_len))[3]
-{
-  int i, verts_len = me->totvert;
-  float(*cos)[3] = MEM_malloc_arrayN(verts_len, sizeof(*cos), "vertexcos1");
-
-  if (r_verts_len) {
-    *r_verts_len = verts_len;
-  }
-  for (i = 0; i < verts_len; i++) {
-    copy_v3_v3(cos[i], me->mvert[i].co);
-  }
-
-  return cos;
-}
-
 /**
  * Find the index of the loop in 'poly' which references vertex,
  * returns -1 if not found
@@ -1665,24 +1646,42 @@ void BKE_mesh_count_selected_items(const Mesh *mesh, int r_count[3])
   /* We could support faces in paint modes. */
 }
 
-void BKE_mesh_apply_vert_coords(Mesh *mesh, const float (*vertCoords)[3])
+void BKE_mesh_vert_coords_get(const Mesh *mesh, float (*vert_coords)[3])
+{
+  const MVert *mv = mesh->mvert;
+  for (int i = 0; i < mesh->totvert; i++, mv++) {
+    copy_v3_v3(vert_coords[i], mv->co);
+  }
+}
+
+float (*BKE_mesh_vert_coords_alloc(const Mesh *mesh, int *r_vert_len))[3]
+{
+  float(*vert_coords)[3] = MEM_mallocN(sizeof(float[3]) * mesh->totvert, __func__);
+  BKE_mesh_vert_coords_get(mesh, vert_coords);
+  if (r_vert_len) {
+    *r_vert_len = mesh->totvert;
+  }
+  return vert_coords;
+}
+
+void BKE_mesh_vert_coords_apply(Mesh *mesh, const float (*vert_coords)[3])
 {
   /* This will just return the pointer if it wasn't a referenced layer. */
   MVert *mv = CustomData_duplicate_referenced_layer(&mesh->vdata, CD_MVERT, mesh->totvert);
   mesh->mvert = mv;
   for (int i = 0; i < mesh->totvert; i++, mv++) {
-    copy_v3_v3(mv->co, vertCoords[i]);
+    copy_v3_v3(mv->co, vert_coords[i]);
   }
   mesh->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
 }
 
-void BKE_mesh_apply_vert_normals(Mesh *mesh, const short (*vertNormals)[3])
+void BKE_mesh_vert_normals_apply(Mesh *mesh, const short (*vert_normals)[3])
 {
   /* This will just return the pointer if it wasn't a referenced layer. */
   MVert *mv = CustomData_duplicate_referenced_layer(&mesh->vdata, CD_MVERT, mesh->totvert);
   mesh->mvert = mv;
   for (int i = 0; i < mesh->totvert; i++, mv++) {
-    copy_v3_v3_short(mv->no, vertNormals[i]);
+    copy_v3_v3_short(mv->no, vert_normals[i]);
   }
   mesh->runtime.cd_dirty_vert &= ~CD_MASK_NORMAL;
 }
index 3a2ba078dce5c2349d11006aa160d5eb0a7e253e..aa51856167d49caa7f0bb3c64d74c760c443a36d 100644 (file)
@@ -1341,11 +1341,11 @@ Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
 
   if (mti->type == eModifierTypeType_OnlyDeform) {
     int numVerts;
-    float(*deformedVerts)[3] = BKE_mesh_vertexCos_get(me, &numVerts);
+    float(*deformedVerts)[3] = BKE_mesh_vert_coords_alloc(me, &numVerts);
 
     BKE_id_copy_ex(NULL, &me->id, (ID **)&result, LIB_ID_COPY_LOCALIZE);
     mti->deformVerts(md_eval, &mectx, result, deformedVerts, numVerts);
-    BKE_mesh_apply_vert_coords(result, deformedVerts);
+    BKE_mesh_vert_coords_apply(result, deformedVerts);
 
     if (build_shapekey_layers) {
       add_shapekey_layers(result, me);
index db158ca8fb23e00d392e63568ceea2cebaef7faf..789502fdbd1e0649bf56cd007b8af8ad64696353 100644 (file)
@@ -291,7 +291,7 @@ void BKE_mesh_remap_find_best_match_from_mesh(const MVert *verts_dst,
   float best_match = FLT_MAX, match;
 
   const int numverts_src = me_src->totvert;
-  float(*vcos_src)[3] = BKE_mesh_vertexCos_get(me_src, NULL);
+  float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, NULL);
 
   mesh_calc_eigen_matrix(NULL, (const float(*)[3])vcos_src, numverts_src, mat_src);
   mesh_calc_eigen_matrix(verts_dst, NULL, numverts_dst, mat_dst);
@@ -548,7 +548,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
     }
     else if (ELEM(mode, MREMAP_MODE_VERT_EDGE_NEAREST, MREMAP_MODE_VERT_EDGEINTERP_NEAREST)) {
       MEdge *edges_src = me_src->medge;
-      float(*vcos_src)[3] = BKE_mesh_vertexCos_get(me_src, NULL);
+      float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, NULL);
 
       BKE_bvhtree_from_mesh_get(&treedata, me_src, BVHTREE_FROM_EDGES, 2);
       nearest.index = -1;
@@ -602,7 +602,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
                   MREMAP_MODE_VERT_POLYINTERP_VNORPROJ)) {
       MPoly *polys_src = me_src->mpoly;
       MLoop *loops_src = me_src->mloop;
-      float(*vcos_src)[3] = BKE_mesh_vertexCos_get(me_src, NULL);
+      float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, NULL);
 
       size_t tmp_buff_size = MREMAP_DEFAULT_BUFSIZE;
       float(*vcos)[3] = MEM_mallocN(sizeof(*vcos) * tmp_buff_size, __func__);
@@ -752,7 +752,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
       const int num_verts_src = me_src->totvert;
       const int num_edges_src = me_src->totedge;
       MEdge *edges_src = me_src->medge;
-      float(*vcos_src)[3] = BKE_mesh_vertexCos_get(me_src, NULL);
+      float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, NULL);
 
       MeshElemMap *vert_to_edge_src_map;
       int *vert_to_edge_src_map_mem;
@@ -901,7 +901,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
       MEdge *edges_src = me_src->medge;
       MPoly *polys_src = me_src->mpoly;
       MLoop *loops_src = me_src->mloop;
-      float(*vcos_src)[3] = BKE_mesh_vertexCos_get(me_src, NULL);
+      float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, NULL);
 
       BKE_bvhtree_from_mesh_get(&treedata, me_src, BVHTREE_FROM_LOOPTRI, 2);
 
@@ -1350,7 +1350,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
     size_t islands_res_buff_size = MREMAP_DEFAULT_BUFSIZE;
 
     if (!use_from_vert) {
-      vcos_src = BKE_mesh_vertexCos_get(me_src, NULL);
+      vcos_src = BKE_mesh_vert_coords_alloc(me_src, NULL);
 
       vcos_interp = MEM_mallocN(sizeof(*vcos_interp) * buff_size_interp, __func__);
       indices_interp = MEM_mallocN(sizeof(*indices_interp) * buff_size_interp, __func__);
index d939267ac5ab512501312ba056daf9a59cd6421f..9947b96105daf7dfa9bce985908e2a81e5dd0562 100644 (file)
@@ -891,7 +891,7 @@ bool multiresModifier_reshapeFromObject(struct Depsgraph *depsgraph,
   Object *src_eval = DEG_get_evaluated_object(depsgraph, src);
   Mesh *src_mesh_eval = mesh_get_eval_final(depsgraph, scene_eval, src_eval, &CD_MASK_BAREMESH);
   int num_deformed_verts;
-  float(*deformed_verts)[3] = BKE_mesh_vertexCos_get(src_mesh_eval, &num_deformed_verts);
+  float(*deformed_verts)[3] = BKE_mesh_vert_coords_alloc(src_mesh_eval, &num_deformed_verts);
   bool result = multires_reshape_from_vertcos(
       depsgraph, dst, &reshape_mmd, deformed_verts, num_deformed_verts, false);
   MEM_freeN(deformed_verts);
@@ -926,7 +926,7 @@ bool multiresModifier_reshapeFromDeformModifier(struct Depsgraph *depsgraph,
    * deformation modifiers will be applied though). */
   Mesh *multires_mesh = BKE_multires_create_mesh(depsgraph, scene_eval, &highest_mmd, object);
   int num_deformed_verts;
-  float(*deformed_verts)[3] = BKE_mesh_vertexCos_get(multires_mesh, &num_deformed_verts);
+  float(*deformed_verts)[3] = BKE_mesh_vert_coords_alloc(multires_mesh, &num_deformed_verts);
   /* Apply deformation modifier on the multires, */
   const ModifierEvalContext modifier_ctx = {
       .depsgraph = depsgraph,
index 4a41ffbfa8c07ac7c5cf6730d3df1a11d8d11f4e..a46bb36c88398846093b770382dcaf13e2bcb0d8 100644 (file)
@@ -1222,10 +1222,10 @@ static void sculpt_update_object(
       BKE_sculptsession_free_deformMats(ss);
 
       ss->orig_cos = (ss->kb) ? BKE_keyblock_convert_to_vertcos(ob, ss->kb) :
-                                BKE_mesh_vertexCos_get(me, NULL);
+                                BKE_mesh_vert_coords_alloc(me, NULL);
 
       BKE_crazyspace_build_sculpt(depsgraph, scene, ob, &ss->deform_imats, &ss->deform_cos);
-      BKE_pbvh_apply_vertCos(ss->pbvh, ss->deform_cos, me->totvert);
+      BKE_pbvh_vert_coords_apply(ss->pbvh, ss->deform_cos, me->totvert);
 
       for (a = 0; a < me->totvert; ++a) {
         invert_m3(ss->deform_imats[a]);
@@ -1242,14 +1242,14 @@ static void sculpt_update_object(
 
   /* if pbvh is deformed, key block is already applied to it */
   if (ss->kb) {
-    bool pbvh_deformed = BKE_pbvh_isDeformed(ss->pbvh);
+    bool pbvh_deformed = BKE_pbvh_is_deformed(ss->pbvh);
     if (!pbvh_deformed || ss->deform_cos == NULL) {
       float(*vertCos)[3] = BKE_keyblock_convert_to_vertcos(ob, ss->kb);
 
       if (vertCos) {
         if (!pbvh_deformed) {
           /* apply shape keys coordinates to PBVH */
-          BKE_pbvh_apply_vertCos(ss->pbvh, vertCos, me->totvert);
+          BKE_pbvh_vert_coords_apply(ss->pbvh, vertCos, me->totvert);
         }
         if (ss->deform_cos == NULL) {
           ss->deform_cos = vertCos;
@@ -1477,8 +1477,8 @@ static PBVH *build_pbvh_from_regular_mesh(Object *ob, Mesh *me_eval_deform)
   const bool is_deformed = check_sculpt_object_deformed(ob, true);
   if (is_deformed && me_eval_deform != NULL) {
     int totvert;
-    float(*v_cos)[3] = BKE_mesh_vertexCos_get(me_eval_deform, &totvert);
-    BKE_pbvh_apply_vertCos(pbvh, v_cos, totvert);
+    float(*v_cos)[3] = BKE_mesh_vert_coords_alloc(me_eval_deform, &totvert);
+    BKE_pbvh_vert_coords_apply(pbvh, v_cos, totvert);
     MEM_freeN(v_cos);
   }
 
index 31484b59127e4babbafc0e2183754a1c2a0915f4..e328ae8952e4733b1a7272dfa2d26d626e1c2af9 100644 (file)
@@ -3490,10 +3490,10 @@ static void do_hair_dynamics(ParticleSimulationData *sim)
   psys->clmd->sim_parms->effector_weights = psys->part->effector_weights;
 
   BKE_id_copy_ex(NULL, &psys->hair_in_mesh->id, (ID **)&psys->hair_out_mesh, LIB_ID_COPY_LOCALIZE);
-  deformedVerts = BKE_mesh_vertexCos_get(psys->hair_out_mesh, NULL);
+  deformedVerts = BKE_mesh_vert_coords_alloc(psys->hair_out_mesh, NULL);
   clothModifier_do(
       psys->clmd, sim->depsgraph, sim->scene, sim->ob, psys->hair_in_mesh, deformedVerts);
-  BKE_mesh_apply_vert_coords(psys->hair_out_mesh, deformedVerts);
+  BKE_mesh_vert_coords_apply(psys->hair_out_mesh, deformedVerts);
 
   MEM_freeN(deformedVerts);
 
index 81e4537964b960b75d9dfbf03f06af307ff5268b..cea68a0c525a6a693897ed4cfecb1494de37aa9c 100644 (file)
@@ -533,7 +533,7 @@ static void pbvh_build(PBVH *bvh, BB *cb, BBC *prim_bbc, int totprim)
  * Do a full rebuild with on Mesh data structure.
  *
  * \note Unlike mpoly/mloop/verts, looptri is **totally owned** by PBVH
- * (which means it may rewrite it if needed, see #BKE_pbvh_apply_vertCos().
+ * (which means it may rewrite it if needed, see #BKE_pbvh_vert_coords_apply().
  */
 void BKE_pbvh_build_mesh(PBVH *bvh,
                          const MPoly *mpoly,
@@ -2306,7 +2306,7 @@ void BKE_pbvh_node_layer_disp_free(PBVHNode *node)
   }
 }
 
-float (*BKE_pbvh_get_vertCos(PBVH *pbvh))[3]
+float (*BKE_pbvh_vert_coords_alloc(PBVH *pbvh))[3]
 {
   float(*vertCos)[3] = NULL;
 
@@ -2324,7 +2324,7 @@ float (*BKE_pbvh_get_vertCos(PBVH *pbvh))[3]
   return vertCos;
 }
 
-void BKE_pbvh_apply_vertCos(PBVH *pbvh, const float (*vertCos)[3], const int totvert)
+void BKE_pbvh_vert_coords_apply(PBVH *pbvh, const float (*vertCos)[3], const int totvert)
 {
   if (totvert != pbvh->totvert) {
     BLI_assert(!"PBVH: Given deforming vcos number does not natch PBVH vertex number!");
@@ -2368,7 +2368,7 @@ void BKE_pbvh_apply_vertCos(PBVH *pbvh, const float (*vertCos)[3], const int tot
   }
 }
 
-bool BKE_pbvh_isDeformed(PBVH *pbvh)
+bool BKE_pbvh_is_deformed(PBVH *pbvh)
 {
   return pbvh->deformed;
 }
index 90bbf996851e77950624eab66821d41fe9a42208..eef108b1f2fcaf0c6d861220095e431a5e38ca7c 100644 (file)
@@ -66,7 +66,7 @@ static int dl_tri_len(const DispList *dl)
   return 0;
 }
 
-/* see: displist_get_allverts */
+/* see: displist_vert_coords_alloc */
 static int curve_render_surface_vert_len_get(const ListBase *lb)
 {
   int vert_len = 0;
index ab1595997e59b51349c2feae5c3f0cbbf43037b1..61f9dc43c0f67cd4ce4a34e224c0c72d82e3ccf2 100644 (file)
@@ -2658,7 +2658,7 @@ static void knifetool_init_bmbvh(KnifeTool_OpData *kcd)
   Object *obedit_eval = (Object *)DEG_get_evaluated_id(kcd->vc.depsgraph, &kcd->em->ob->id);
   BMEditMesh *em_eval = BKE_editmesh_from_object(obedit_eval);
 
-  kcd->cagecos = (const float(*)[3])BKE_editmesh_vertexCos_get(
+  kcd->cagecos = (const float(*)[3])BKE_editmesh_vert_coords_alloc(
       kcd->vc.depsgraph, em_eval, scene_eval, NULL);
 
   kcd->bmbvh = BKE_bmbvh_new_from_editmesh(
index 8818fd71190934c330922bbda5df48ba9b52d8d2..8275a1eb5c487b1648467b951df17f297b09cace 100644 (file)
@@ -714,9 +714,9 @@ static int modifier_apply_obdata(
                RPT_INFO,
                "Applied modifier only changed CV points, not tessellated/bevel vertices");
 
-    vertexCos = BKE_curve_nurbs_vertexCos_get(&curve_eval->nurb, &numVerts);
+    vertexCos = BKE_curve_nurbs_vert_coords_alloc(&curve_eval->nurb, &numVerts);
     mti->deformVerts(md_eval, &mectx, NULL, vertexCos, numVerts);
-    BK_curve_nurbs_vertexCos_apply(&curve->nurb, vertexCos);
+    BK_curve_nurbs_vert_coords_apply(&curve->nurb, vertexCos);
 
     MEM_freeN(vertexCos);
 
index bee39581ac2a2758c1b3ee98450bdae3944ae2e4..08febfcc4702cf3826e65f7db35ba89572dbc033 100644 (file)
@@ -4349,7 +4349,7 @@ static void sculpt_update_keyblock(Object *ob)
     vertCos = ss->orig_cos;
   }
   else {
-    vertCos = BKE_pbvh_get_vertCos(ss->pbvh);
+    vertCos = BKE_pbvh_vert_coords_alloc(ss->pbvh);
   }
 
   if (vertCos) {
index 3a3487227a3329ed254b4dcc47e04b8d191f3c60..cb8afd5d7fa8708f70abeac7cbb779f2bfe119f0 100644 (file)
@@ -189,7 +189,7 @@ static bool sculpt_undo_restore_coords(bContext *C, Depsgraph *depsgraph, Sculpt
 
       /* pbvh uses it's own mvert array, so coords should be */
       /* propagated to pbvh here */
-      BKE_pbvh_apply_vertCos(ss->pbvh, vertCos, ss->kb->totelem);
+      BKE_pbvh_vert_coords_apply(ss->pbvh, vertCos, ss->kb->totelem);
 
       MEM_freeN(vertCos);
     }
index 1a6d172d2f9e3ce651df22206e5b16780cae3369..cc91e345c8faf728b5a0e80207b25ca299cbc3a1 100644 (file)
@@ -114,7 +114,7 @@ static void deformVerts(ModifierData *md,
     }
   }
 
-  BKE_mesh_apply_vert_coords(mesh_src, vertexCos);
+  BKE_mesh_vert_coords_apply(mesh_src, vertexCos);
 
   clothModifier_do(clmd, ctx->depsgraph, scene, ctx->object, mesh_src, vertexCos);
 
index 1bbc25643a10197b76943135fe650adf8b705019..3d43c6de88e59752790287e022721ff48ceb8cf0 100644 (file)
@@ -120,7 +120,7 @@ static void deformVerts(ModifierData *md,
     float current_time = 0;
     unsigned int mvert_num = 0;
 
-    BKE_mesh_apply_vert_coords(mesh_src, vertexCos);
+    BKE_mesh_vert_coords_apply(mesh_src, vertexCos);
     BKE_mesh_calc_normals(mesh_src);
 
     current_time = DEG_get_ctime(ctx->depsgraph);
index be1580f0d70319d5d14e5eab9729a7824601f202..a234f468e45991389c98c074c69852e04de30cd6 100644 (file)
@@ -635,12 +635,12 @@ static void correctivesmooth_modifier_do(ModifierData *md,
     if (csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND) {
       /* caller needs to do sanity check here */
       csmd->bind_coords_num = numVerts;
-      rest_coords = (const float(*)[3])csmd->bind_coords;
+      rest_coords = csmd->bind_coords;
     }
     else {
       int me_numVerts;
-      rest_coords = (const float(*)[3])((em) ? BKE_editmesh_vertexCos_get_orco(em, &me_numVerts) :
-                                               BKE_mesh_vertexCos_get(ob->data, &me_numVerts));
+      rest_coords = em ? BKE_editmesh_vert_coords_alloc_orco(em, &me_numVerts) :
+                         BKE_mesh_vert_coords_alloc(ob->data, &me_numVerts);
 
       BLI_assert((unsigned int)me_numVerts == numVerts);
       is_rest_coords_alloc = true;
index 3083d89d55567aae7126613ab59d15ec14702030..587aa108fd1d194db4c03af315465d9ff66d00c1 100644 (file)
@@ -290,7 +290,7 @@ static Mesh *fluidsim_read_obj(const char *filename, const MPoly *mp_example)
   gzclose(gzf);
 
   BKE_mesh_calc_edges(mesh, false, false);
-  BKE_mesh_apply_vert_normals(mesh, (short(*)[3])normals);
+  BKE_mesh_vert_normals_apply(mesh, (short(*)[3])normals);
   MEM_freeN(normals);
 
   // CDDM_calc_normals(result);
index da261b4f835bae4ba3a73e5041e580099c28b22e..a582e1799834f88389a79fd1891d18650fe77b9f 100644 (file)
@@ -401,7 +401,7 @@ static void meshdeformModifier_do(ModifierData *md,
   }
 
   /* setup deformation data */
-  cagecos = BKE_mesh_vertexCos_get(cagemesh, NULL);
+  cagecos = BKE_mesh_vert_coords_alloc(cagemesh, NULL);
   bindcagecos = (float(*)[3])mmd->bindcagecos;
 
   /* We allocate 1 element extra to make it possible to
index 021e61bd46d0a689997131699d79af727fadc141..a7c7c207cd61c0ea7ef6c4eda93a781f307be0da 100644 (file)
@@ -152,7 +152,7 @@ static void deformVerts(ModifierData *md,
 
   /* make new mesh */
   psmd->mesh_final = BKE_mesh_copy_for_eval(mesh_src, false);
-  BKE_mesh_apply_vert_coords(psmd->mesh_final, vertexCos);
+  BKE_mesh_vert_coords_apply(psmd->mesh_final, vertexCos);
   BKE_mesh_calc_normals(psmd->mesh_final);
 
   BKE_mesh_tessface_ensure(psmd->mesh_final);
index dcc6371e024c37e8c07ea04155de4dc3b16c46d6..840914aa313559f610b83024c372767de37d2900 100644 (file)
@@ -130,7 +130,7 @@ static void deformVerts(ModifierData *md,
     float *vec;
     MVert *x, *v;
 
-    BKE_mesh_apply_vert_coords(surmd->mesh, vertexCos);
+    BKE_mesh_vert_coords_apply(surmd->mesh, vertexCos);
     BKE_mesh_calc_normals(surmd->mesh);
 
     numverts = surmd->mesh->totvert;
index 998a2b1cd658778d69365e2f80f588d59b3f051e..e7acbd3e32e4719d9763a691f33b5b0806171b34 100644 (file)
@@ -198,7 +198,7 @@ Mesh *MOD_deform_mesh_eval_get(Object *ob,
     /* TODO(sybren): after modifier conversion of DM to Mesh is done, check whether
      * we really need vertexCos here. */
     if (vertexCos) {
-      BKE_mesh_apply_vert_coords(mesh, vertexCos);
+      BKE_mesh_vert_coords_apply(mesh, vertexCos);
       mesh->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
     }
 
index f9eb92cd132b51d8c65213bd81bde350a757f1d8..5f1eae0297a806a64a4ccc09b1d09a613537b362 100644 (file)
@@ -204,7 +204,7 @@ static Mesh *uvprojectModifier_do(UVProjectModifierData *umd,
   mloop_uv = CustomData_duplicate_referenced_layer_named(
       &mesh->ldata, CD_MLOOPUV, uvname, numLoops);
 
-  coords = BKE_mesh_vertexCos_get(mesh, &numVerts);
+  coords = BKE_mesh_vert_coords_alloc(mesh, &numVerts);
 
   /* convert coords to world space */
   for (i = 0, co = coords; i < numVerts; ++i, ++co) {
index 86d1b310d0c73f37c6cec61379fb2ce36a1e027f..95b15b4a924402f4d61b71c3be9ce35fb2983fc7 100644 (file)
@@ -492,7 +492,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
 
   /* Get our vertex coordinates. */
   if (numIdx != numVerts) {
-    float(*tv_cos)[3] = BKE_mesh_vertexCos_get(mesh, NULL);
+    float(*tv_cos)[3] = BKE_mesh_vert_coords_alloc(mesh, NULL);
     v_cos = MEM_malloc_arrayN(numIdx, sizeof(float[3]), "WeightVGProximity Modifier, v_cos");
     for (i = 0; i < numIdx; i++) {
       copy_v3_v3(v_cos[i], tv_cos[indices[i]]);
@@ -500,7 +500,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
     MEM_freeN(tv_cos);
   }
   else {
-    v_cos = BKE_mesh_vertexCos_get(mesh, NULL);
+    v_cos = BKE_mesh_vert_coords_alloc(mesh, NULL);
   }
 
   /* Compute wanted distances. */