Mesh: Remove redundant custom data pointers

For copy-on-write, we want to share attribute arrays between meshes
where possible. Mutable pointers like `Mesh.mvert` make that difficult
by making ownership vague. They also make code more complex by adding
redundancy.

The simplest solution is just removing them and retrieving layers from
`CustomData` as needed. Similar changes have already been applied to
curves and point clouds (e9f82d3dc7ee, 410a6efb747f). Removing use of
the pointers generally makes code more obvious and more reusable.

Mesh data is now accessed with a C++ API (`Mesh::edges()` or
`Mesh::edges_for_write()`), and a C API (`BKE_mesh_edges(mesh)`).

The CoW changes this commit makes possible are described in T95845
and T95842, and started in D14139 and D14140. The change also simplifies
the ongoing mesh struct-of-array refactors from T95965.

**RNA/Python Access Performance**
Theoretically, accessing mesh elements with the RNA API may become
slower, since the layer needs to be found on every random access.
However, overhead is already high enough that this doesn't make a
noticible differenc, and performance is actually improved in some
cases. Random access can be up to 10% faster, but other situations
might be a bit slower. Generally using `foreach_get/set` are the best
way to improve performance. See the differential revision for more
discussion about Python performance.

Cycles has been updated to use raw pointers and the internal Blender
mesh types, mostly because there is no sense in having this overhead
when it's already compiled with Blender. In my tests this roughly
halves the Cycles mesh creation time (0.19s to 0.10s for a 1 million
face grid).

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

6 files changed, 128 insertions, 95 deletions

diff --git a/source/blender/editors/object/object_bake.c b/source/blender/editors/object/object_bake.c
index 3170ce2c620..8d505bbca3e 100644
--- a/source/blender/editors/object/object_bake.c
+++ b/source/blender/editors/object/object_bake.c
@@ -155,7 +155,7 @@ static bool multiresbake_check(bContext *C, wmOperator *op)
       break;
     }
 
-    if (!me->mloopuv) {
+    if (!CustomData_has_layer(&me->ldata, CD_MLOOPUV)) {
       BKE_report(op->reports, RPT_ERROR, "Mesh should be unwrapped before multires data baking");
 
       ok = false;
diff --git a/source/blender/editors/object/object_bake_api.c b/source/blender/editors/object/object_bake_api.c
index 708f1d02656..2e07214a5b3 100644
--- a/source/blender/editors/object/object_bake_api.c
+++ b/source/blender/editors/object/object_bake_api.c
@@ -971,7 +971,8 @@ static bool bake_targets_init_vertex_colors(Main *bmain,
   return true;
 }
 
-static int find_original_loop(const Mesh *me_orig,
+static int find_original_loop(const MPoly *orig_polys,
+                              const MLoop *orig_loops,
                               const int *vert_origindex,
                               const int *poly_origindex,
                               const int poly_eval,
@@ -987,8 +988,8 @@ static int find_original_loop(const Mesh *me_orig,
   }
 
   /* Find matching loop with original vertex in original polygon. */
-  MPoly *mpoly_orig = me_orig->mpoly + poly_orig;
-  MLoop *mloop_orig = me_orig->mloop + mpoly_orig->loopstart;
+  const MPoly *mpoly_orig = orig_polys + poly_orig;
+  const MLoop *mloop_orig = orig_loops + mpoly_orig->loopstart;
   for (int j = 0; j < mpoly_orig->totloop; ++j, ++mloop_orig) {
     if (mloop_orig->v == vert_orig) {
       return mpoly_orig->loopstart + j;
@@ -1025,23 +1026,31 @@ static void bake_targets_populate_pixels_color_attributes(BakeTargets *targets,
   const int tottri = poly_to_tri_count(me_eval->totpoly, me_eval->totloop);
   MLoopTri *looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__);
 
-  BKE_mesh_recalc_looptri(
-      me_eval->mloop, me_eval->mpoly, me_eval->mvert, me_eval->totloop, me_eval->totpoly, looptri);
+  const MLoop *loops = BKE_mesh_loops(me_eval);
+  BKE_mesh_recalc_looptri(loops,
+                          BKE_mesh_polygons(me_eval),
+                          BKE_mesh_vertices(me_eval),
+                          me_eval->totloop,
+                          me_eval->totpoly,
+                          looptri);
 
   /* For mapping back to original mesh in case there are modifiers. */
   const int *vert_origindex = CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX);
   const int *poly_origindex = CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX);
+  const MPoly *orig_polys = BKE_mesh_polygons(me);
+  const MLoop *orig_loops = BKE_mesh_loops(me);
 
   for (int i = 0; i < tottri; i++) {
     const MLoopTri *lt = &looptri[i];
 
     for (int j = 0; j < 3; j++) {
       unsigned int l = lt->tri[j];
-      unsigned int v = me_eval->mloop[l].v;
+      unsigned int v = loops[l].v;
 
       /* Map back to original loop if there are modifiers. */
       if (vert_origindex != NULL && poly_origindex != NULL) {
-        l = find_original_loop(me, vert_origindex, poly_origindex, lt->poly, v);
+        l = find_original_loop(
+            orig_polys, orig_loops, vert_origindex, poly_origindex, lt->poly, v);
         if (l == ORIGINDEX_NONE || l >= me->totloop) {
           continue;
         }
@@ -1135,7 +1144,7 @@ static bool bake_targets_output_vertex_colors(BakeTargets *targets, Object *ob)
     int *num_loops_for_vertex = MEM_callocN(sizeof(int) * me->totvert, "num_loops_for_vertex");
     memset(mcol, 0, sizeof(MPropCol) * me->totvert);
 
-    MLoop *mloop = me->mloop;
+    const MLoop *mloop = BKE_mesh_loops(me);
     for (int i = 0; i < totloop; i++, mloop++) {
       const int v = mloop->v;
       bake_result_add_to_rgba(mcol[v].color, &result[i * channels_num], channels_num);
diff --git a/source/blender/editors/object/object_modifier.cc b/source/blender/editors/object/object_modifier.cc
index 58ddde75844..5e642a00727 100644
--- a/source/blender/editors/object/object_modifier.cc
+++ b/source/blender/editors/object/object_modifier.cc
@@ -94,6 +94,8 @@
 
 #include "object_intern.h"
 
+using blender::Span;
+
 static void modifier_skin_customdata_delete(struct Object *ob);
 
 /* ------------------------------------------------------------------- */
@@ -587,14 +589,14 @@ bool ED_object_modifier_convert_psys_to_mesh(ReportList *UNUSED(reports),
   me->totvert = verts_num;
   me->totedge = edges_num;
 
-  me->mvert = (MVert *)CustomData_add_layer(
-      &me->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, verts_num);
-  me->medge = (MEdge *)CustomData_add_layer(
-      &me->edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, edges_num);
-  me->mface = (MFace *)CustomData_add_layer(&me->fdata, CD_MFACE, CD_SET_DEFAULT, nullptr, 0);
+  CustomData_add_layer(&me->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, verts_num);
+  CustomData_add_layer(&me->edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, edges_num);
+  CustomData_add_layer(&me->fdata, CD_MFACE, CD_SET_DEFAULT, nullptr, 0);
 
-  MVert *mvert = me->mvert;
-  MEdge *medge = me->medge;
+  blender::MutableSpan<MVert> verts = me->vertices_for_write();
+  blender::MutableSpan<MEdge> edges = me->edges_for_write();
+  MVert *mvert = verts.data();
+  MEdge *medge = edges.data();
 
   /* copy coordinates */
   cache = psys_eval->pathcache;
@@ -2591,8 +2593,8 @@ void OBJECT_OT_skin_radii_equalize(wmOperatorType *ot)
 }
 
 static void skin_armature_bone_create(Object *skin_ob,
-                                      MVert *mvert,
-                                      MEdge *medge,
+                                      const MVert *mvert,
+                                      const MEdge *medge,
                                       bArmature *arm,
                                       BLI_bitmap *edges_visited,
                                       const MeshElemMap *emap,
@@ -2637,12 +2639,15 @@ static void skin_armature_bone_create(Object *skin_ob,
 static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain, Object *skin_ob)
 {
   Mesh *me = static_cast<Mesh *>(skin_ob->data);
+  const Span<MVert> me_verts = me->vertices();
+  const Span<MEdge> me_edges = me->edges();
 
   Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
   Object *ob_eval = DEG_get_evaluated_object(depsgraph, skin_ob);
 
-  Mesh *me_eval_deform = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
-  MVert *mvert = me_eval_deform->mvert;
+  const Mesh *me_eval_deform = mesh_get_eval_deform(
+      depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
+  const Span<MVert> verts_eval = me_eval_deform->vertices();
 
   /* add vertex weights to original mesh */
   CustomData_add_layer(&me->vdata, CD_MDEFORMVERT, CD_SET_DEFAULT, nullptr, me->totvert);
@@ -2660,7 +2665,7 @@ static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain,
       CustomData_get_layer(&me->vdata, CD_MVERT_SKIN));
   int *emap_mem;
   MeshElemMap *emap;
-  BKE_mesh_vert_edge_map_create(&emap, &emap_mem, me->medge, me->totvert, me->totedge);
+  BKE_mesh_vert_edge_map_create(&emap, &emap_mem, me_edges.data(), me->totvert, me->totedge);
 
   BLI_bitmap *edges_visited = BLI_BITMAP_NEW(me->totedge, "edge_visited");
 
@@ -2676,15 +2681,16 @@ static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain,
       if (emap[v].count > 1) {
         bone = ED_armature_ebone_add(arm, "Bone");
 
-        copy_v3_v3(bone->head, me->mvert[v].co);
-        copy_v3_v3(bone->tail, me->mvert[v].co);
+        copy_v3_v3(bone->head, me_verts[v].co);
+        copy_v3_v3(bone->tail, me_verts[v].co);
 
         bone->head[1] = 1.0f;
         bone->rad_head = bone->rad_tail = 0.25;
       }
 
       if (emap[v].count >= 1) {
-        skin_armature_bone_create(skin_ob, mvert, me->medge, arm, edges_visited, emap, bone, v);
+        skin_armature_bone_create(
+            skin_ob, verts_eval.data(), me_edges.data(), arm, edges_visited, emap, bone, v);
       }
     }
   }
diff --git a/source/blender/editors/object/object_remesh.cc b/source/blender/editors/object/object_remesh.cc
index 812d9bbbc08..56cccd984b6 100644
--- a/source/blender/editors/object/object_remesh.cc
+++ b/source/blender/editors/object/object_remesh.cc
@@ -73,6 +73,9 @@
 
 #include "object_intern.h" /* own include */
 
+using blender::IndexRange;
+using blender::Span;
+
 /* TODO(sebpa): unstable, can lead to unrecoverable errors. */
 // #define USE_MESH_CURVATURE
 
@@ -128,7 +131,8 @@ static int voxel_remesh_exec(bContext *C, wmOperator *op)
   }
 
   /* Output mesh will be all smooth or all flat shading. */
-  const bool smooth_normals = mesh->mpoly[0].flag & ME_SMOOTH;
+  const Span<MPoly> polygons = mesh->polygons();
+  const bool smooth_normals = polygons.first().flag & ME_SMOOTH;
 
   float isovalue = 0.0f;
   if (mesh->flag & ME_REMESH_REPROJECT_VOLUME) {
@@ -678,9 +682,11 @@ static bool mesh_is_manifold_consistent(Mesh *mesh)
    * check that the direction of the faces are consistent and doesn't suddenly
    * flip
    */
+  const Span<MVert> verts = mesh->vertices();
+  const Span<MEdge> edges = mesh->edges();
+  const Span<MLoop> loops = mesh->loops();
 
   bool is_manifold_consistent = true;
-  const MLoop *mloop = mesh->mloop;
   char *edge_faces = (char *)MEM_callocN(mesh->totedge * sizeof(char), "remesh_manifold_check");
   int *edge_vert = (int *)MEM_malloc_arrayN(
       mesh->totedge, sizeof(uint), "remesh_consistent_check");
@@ -689,18 +695,17 @@ static bool mesh_is_manifold_consistent(Mesh *mesh)
     edge_vert[i] = -1;
   }
 
-  for (uint loop_idx = 0; loop_idx < mesh->totloop; loop_idx++) {
-    const MLoop *loop = &mloop[loop_idx];
-    edge_faces[loop->e] += 1;
-    if (edge_faces[loop->e] > 2) {
+  for (const MLoop &loop : loops) {
+    edge_faces[loop.e] += 1;
+    if (edge_faces[loop.e] > 2) {
       is_manifold_consistent = false;
       break;
     }
 
-    if (edge_vert[loop->e] == -1) {
-      edge_vert[loop->e] = loop->v;
+    if (edge_vert[loop.e] == -1) {
+      edge_vert[loop.e] = loop.v;
     }
-    else if (edge_vert[loop->e] == loop->v) {
+    else if (edge_vert[loop.e] == loop.v) {
       /* Mesh has flips in the surface so it is non consistent */
       is_manifold_consistent = false;
       break;
@@ -708,16 +713,16 @@ static bool mesh_is_manifold_consistent(Mesh *mesh)
   }
 
   if (is_manifold_consistent) {
-    for (uint i = 0; i < mesh->totedge; i++) {
+    for (const int i : edges.index_range()) {
       /* Check for wire edges. */
       if (edge_faces[i] == 0) {
         is_manifold_consistent = false;
         break;
       }
       /* Check for zero length edges */
-      MVert *v1 = &mesh->mvert[mesh->medge[i].v1];
-      MVert *v2 = &mesh->mvert[mesh->medge[i].v2];
-      if (compare_v3v3(v1->co, v2->co, 1e-4f)) {
+      const MVert &v1 = verts[edges[i].v1];
+      const MVert &v2 = verts[edges[i].v2];
+      if (compare_v3v3(v1.co, v2.co, 1e-4f)) {
         is_manifold_consistent = false;
         break;
       }
diff --git a/source/blender/editors/object/object_shapekey.c b/source/blender/editors/object/object_shapekey.c
index 0e3945bff15..0328f6a6230 100644
--- a/source/blender/editors/object/object_shapekey.c
+++ b/source/blender/editors/object/object_shapekey.c
@@ -114,14 +114,13 @@ static bool object_shape_key_mirror(
 
     if (ob->type == OB_MESH) {
       Mesh *me = ob->data;
-      MVert *mv;
       int i1, i2;
       float *fp1, *fp2;
       float tvec[3];
 
       ED_mesh_mirror_spatial_table_begin(ob, NULL, NULL);
 
-      for (i1 = 0, mv = me->mvert; i1 < me->totvert; i1++, mv++) {
+      for (i1 = 0; i1 < me->totvert; i1++) {
         i2 = mesh_get_x_mirror_vert(ob, NULL, i1, use_topology);
         if (i2 == i1) {
           fp1 = ((float *)kb->data) + i1 * 3;
diff --git a/source/blender/editors/object/object_vgroup.cc b/source/blender/editors/object/object_vgroup.cc
index 7727dbeadfd..310d73daa76 100644
--- a/source/blender/editors/object/object_vgroup.cc
+++ b/source/blender/editors/object/object_vgroup.cc
@@ -67,6 +67,9 @@
 
 #include "object_intern.h"
 
+using blender::MutableSpan;
+using blender::Span;
+
 static bool vertex_group_supported_poll_ex(bContext *C, const Object *ob);
 
 /* -------------------------------------------------------------------- */
@@ -196,9 +199,9 @@ bool ED_vgroup_parray_alloc(ID *id,
 
           return true;
         }
-        if (me->dvert) {
-          MVert *mvert = me->mvert;
-          MDeformVert *dvert = me->dvert;
+        if (!me->deform_verts().is_empty()) {
+          const Span<MVert> verts = me->vertices();
+          MutableSpan<MDeformVert> dverts = me->deform_verts_for_write();
 
           *dvert_tot = me->totvert;
           *dvert_arr = static_cast<MDeformVert **>(
@@ -206,12 +209,12 @@ bool ED_vgroup_parray_alloc(ID *id,
 
           if (use_vert_sel) {
             for (int i = 0; i < me->totvert; i++) {
-              (*dvert_arr)[i] = (mvert[i].flag & SELECT) ? &dvert[i] : nullptr;
+              (*dvert_arr)[i] = (verts[i].flag & SELECT) ? &dverts[i] : nullptr;
             }
           }
           else {
             for (int i = 0; i < me->totvert; i++) {
-              (*dvert_arr)[i] = me->dvert + i;
+              (*dvert_arr)[i] = &dverts[i];
             }
           }
 
@@ -548,9 +551,10 @@ static void ED_mesh_defvert_mirror_update_ob(Object *ob, int def_nr, int vidx)
 
   vidx_mirr = mesh_get_x_mirror_vert(ob, nullptr, vidx, use_topology);
 
+  MutableSpan<MDeformVert> dverts = me->deform_verts_for_write();
   if ((vidx_mirr) >= 0 && (vidx_mirr != vidx)) {
-    MDeformVert *dvert_src = &me->dvert[vidx];
-    MDeformVert *dvert_dst = &me->dvert[vidx_mirr];
+    MDeformVert *dvert_src = &dverts[vidx];
+    MDeformVert *dvert_dst = &dverts[vidx_mirr];
     mesh_defvert_mirror_update_internal(ob, dvert_dst, dvert_src, def_nr);
   }
 }
@@ -659,15 +663,15 @@ static void vgroup_copy_active_to_sel(Object *ob, eVGroupSelect subset_type)
     }
   }
   else {
-    MDeformVert *dv;
+    const Span<MVert> verts = me->vertices();
     int v_act;
 
     dvert_act = ED_mesh_active_dvert_get_ob(ob, &v_act);
     if (dvert_act) {
-      dv = me->dvert;
-      for (i = 0; i < me->totvert; i++, dv++) {
-        if ((me->mvert[i].flag & SELECT) && dv != dvert_act) {
-          BKE_defvert_copy_subset(dv, dvert_act, vgroup_validmap, vgroup_tot);
+      MutableSpan<MDeformVert> dverts = me->deform_verts_for_write();
+      for (i = 0; i < me->totvert; i++) {
+        if ((verts[i].flag & SELECT) && &dverts[i] != dvert_act) {
+          BKE_defvert_copy_subset(&dverts[i], dvert_act, vgroup_validmap, vgroup_tot);
           if (me->symmetry & ME_SYMMETRY_X) {
             ED_mesh_defvert_mirror_update_ob(ob, -1, i);
           }
@@ -927,7 +931,7 @@ void ED_vgroup_vert_remove(Object *ob, bDeformGroup *dg, int vertnum)
 
 static float get_vert_def_nr(Object *ob, const int def_nr, const int vertnum)
 {
-  MDeformVert *dv = nullptr;
+  const MDeformVert *dv = nullptr;
 
   /* get the deform vertices corresponding to the vertnum */
   if (ob->type == OB_MESH) {
@@ -942,18 +946,19 @@ static float get_vert_def_nr(Object *ob, const int def_nr, const int vertnum)
         BMVert *eve;
         BM_mesh_elem_table_ensure(em->bm, BM_VERT);
         eve = BM_vert_at_index(em->bm, vertnum);
-        dv = static_cast<MDeformVert *>(BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset));
+        dv = static_cast<const MDeformVert *>(BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset));
       }
       else {
         return 0.0f;
       }
     }
     else {
-      if (me->dvert) {
+      const Span<MDeformVert> dverts = me->deform_verts();
+      if (!dverts.is_empty()) {
         if (vertnum >= me->totvert) {
           return 0.0f;
         }
-        dv = &me->dvert[vertnum];
+        dv = &dverts[vertnum];
       }
     }
   }
@@ -1044,19 +1049,18 @@ static void vgroup_select_verts(Object *ob, int select)
       }
     }
     else {
-      if (me->dvert) {
+      const Span<MDeformVert> dverts = me->deform_verts();
+      if (!dverts.is_empty()) {
         const bool *hide_vert = (const bool *)CustomData_get_layer_named(
             &me->vdata, CD_PROP_BOOL, ".hide_vert");
         MVert *mv;
-        MDeformVert *dv;
         int i;
 
-        mv = me->mvert;
-        dv = me->dvert;
+        mv = me->vertices_for_write().data();
 
-        for (i = 0; i < me->totvert; i++, mv++, dv++) {
+        for (i = 0; i < me->totvert; i++, mv++) {
           if (hide_vert != nullptr && !hide_vert[i]) {
-            if (BKE_defvert_find_index(dv, def_nr)) {
+            if (BKE_defvert_find_index(&dverts[i], def_nr)) {
               if (select) {
                 mv->flag |= SELECT;
               }
@@ -1214,7 +1218,8 @@ static bool vgroup_normalize(Object *ob)
  * count is an int passed by reference so it can be assigned the value of the length here. */
 static blender::Vector<int> getSurroundingVerts(Mesh *me, int vert)
 {
-  MPoly *mp = me->mpoly;
+  const MPoly *mp = me->polygons().data();
+  const MLoop *loops = me->loops().data();
   int i = me->totpoly;
 
   blender::Vector<int> verts;
@@ -1222,7 +1227,7 @@ static blender::Vector<int> getSurroundingVerts(Mesh *me, int vert)
   while (i--) {
     int j = mp->totloop;
     int first_l = mp->totloop - 1;
-    MLoop *ml = &me->mloop[mp->loopstart];
+    const MLoop *ml = &loops[mp->loopstart];
     while (j--) {
       /* XXX This assume a vert can only be once in a poly, even though
        *     it seems logical to me, not totally sure of that. */
@@ -1236,7 +1241,7 @@ static blender::Vector<int> getSurroundingVerts(Mesh *me, int vert)
         else if (!j) {
           /* We are on the last corner. */
           a = (ml - 1)->v;
-          b = me->mloop[mp->loopstart].v;
+          b = loops[mp->loopstart].v;
         }
         else {
           a = (ml - 1)->v;
@@ -1348,8 +1353,8 @@ static void moveCloserToDistanceFromPlane(Depsgraph *depsgraph,
   Mesh *me_deform;
   MDeformWeight *dw, *dw_eval;
   MVert m;
-  MDeformVert *dvert = me->dvert + index;
-  MDeformVert *dvert_eval = mesh_eval->dvert + index;
+  MDeformVert *dvert = me->deform_verts_for_write().data() + index;
+  MDeformVert *dvert_eval = mesh_eval->deform_verts_for_write().data() + index;
   int totweight = dvert->totweight;
   float oldw = 0;
   float oldPos[3] = {0};
@@ -1372,7 +1377,8 @@ static void moveCloserToDistanceFromPlane(Depsgraph *depsgraph,
   do {
     wasChange = false;
     me_deform = mesh_get_eval_deform(depsgraph, scene_eval, object_eval, &CD_MASK_BAREMESH);
-    m = me_deform->mvert[index];
+    const Span<MVert> verts = me_deform->vertices();
+    m = verts[index];
     copy_v3_v3(oldPos, m.co);
     distToStart = dot_v3v3(norm, oldPos) + d;
 
@@ -1414,7 +1420,7 @@ static void moveCloserToDistanceFromPlane(Depsgraph *depsgraph,
         }
         dw_eval->weight = dw->weight;
         me_deform = mesh_get_eval_deform(depsgraph, scene_eval, object_eval, &CD_MASK_BAREMESH);
-        m = me_deform->mvert[index];
+        m = verts[index];
         getVerticalAndHorizontalChange(
             norm, d, coord, oldPos, distToStart, m.co, changes, dists, i);
         dw->weight = oldw;
@@ -1519,7 +1525,7 @@ static void vgroup_fix(
   int i;
 
   Mesh *me = static_cast<Mesh *>(ob->data);
-  MVert *mvert = me->mvert;
+  MVert *mvert = me->vertices_for_write().data();
   if (!(me->editflag & ME_EDIT_PAINT_VERT_SEL)) {
     return;
   }
@@ -1534,9 +1540,10 @@ static void vgroup_fix(
 
         Mesh *me_deform = mesh_get_eval_deform(
             depsgraph, scene_eval, object_eval, &CD_MASK_BAREMESH);
+        const Span<MVert> verts_deform = me_deform->vertices();
         k = count;
         while (k--) {
-          p[k] = me_deform->mvert[verts[k]];
+          p[k] = verts_deform[verts[k]];
         }
 
         if (count >= 3) {
@@ -1544,7 +1551,7 @@ static void vgroup_fix(
           float coord[3];
           float norm[3];
           getSingleCoordinate(p, count, coord);
-          m = me_deform->mvert[i];
+          m = verts_deform[i];
           sub_v3_v3v3(norm, m.co, coord);
           mag = normalize_v3(norm);
           if (mag) { /* zeros fix */
@@ -1929,7 +1936,7 @@ static void vgroup_smooth_subset(Object *ob,
     emap_mem = nullptr;
   }
   else {
-    BKE_mesh_vert_edge_map_create(&emap, &emap_mem, me->medge, me->totvert, me->totedge);
+    BKE_mesh_vert_edge_map_create(&emap, &emap_mem, me->edges().data(), me->totvert, me->totedge);
   }
 
   weight_accum_prev = static_cast<float *>(
@@ -1968,11 +1975,13 @@ static void vgroup_smooth_subset(Object *ob,
     }
   }
   else {
+    const Span<MVert> verts = me->vertices();
+    const blender::Span<MEdge> edges = me->edges();
     for (int i = 0; i < dvert_tot; i++) {
-      const MVert *v = &me->mvert[i];
+      const MVert *v = &verts[i];
       if (IS_ME_VERT_WRITE(v)) {
         for (int j = 0; j < emap[i].count; j++) {
-          const MEdge *e = &me->medge[emap[i].indices[j]];
+          const MEdge *e = &edges[emap[i].indices[j]];
           const int i_other = (e->v1 == i) ? e->v2 : e->v1;
           if (IS_ME_VERT_READ(i_other)) {
             STACK_PUSH(verts_used, i);
@@ -2041,12 +2050,13 @@ static void vgroup_smooth_subset(Object *ob,
         }
         else {
           int j;
+          const blender::Span<MEdge> edges = me->edges();
 
           /* checked already */
-          BLI_assert(IS_ME_VERT_WRITE(&me->mvert[i]));
+          BLI_assert(IS_ME_VERT_WRITE(&me->vertices()[i]));
 
           for (j = 0; j < emap[i].count; j++) {
-            MEdge *e = &me->medge[emap[i].indices[j]];
+            const MEdge *e = &edges[emap[i].indices[j]];
             const int i_other = (e->v1 == i ? e->v2 : e->v1);
             if (IS_ME_VERT_READ(i_other)) {
               WEIGHT_ACCUMULATE;
@@ -2366,7 +2376,7 @@ void ED_vgroup_mirror(Object *ob,
                   def_nr)
 
   BMVert *eve, *eve_mirr;
-  MDeformVert *dvert, *dvert_mirr;
+  MDeformVert *dvert_mirr;
   char sel, sel_mirr;
   int *flip_map = nullptr, flip_map_len;
   const int def_nr = BKE_object_defgroup_active_index_get(ob) - 1;
@@ -2424,7 +2434,8 @@ void ED_vgroup_mirror(Object *ob,
                 sel_mirr = BM_elem_flag_test(eve_mirr, BM_ELEM_SELECT);
 
                 if ((sel || sel_mirr) && (eve != eve_mirr)) {
-                  dvert = static_cast<MDeformVert *>(BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset));
+                  MDeformVert *dvert = static_cast<MDeformVert *>(
+                      BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset));
                   dvert_mirr = static_cast<MDeformVert *>(
                       BM_ELEM_CD_GET_VOID_P(eve_mirr, cd_dvert_offset));
 
@@ -2447,11 +2458,11 @@ void ED_vgroup_mirror(Object *ob,
     }
     else {
       /* object mode / weight paint */
-      MVert *mv, *mv_mirr;
+      const MVert *mv, *mv_mirr;
       int vidx, vidx_mirr;
       const bool use_vert_sel = (me->editflag & ME_EDIT_PAINT_VERT_SEL) != 0;
 
-      if (me->dvert == nullptr) {
+      if (me->deform_verts().is_empty()) {
         goto cleanup;
       }
 
@@ -2460,12 +2471,14 @@ void ED_vgroup_mirror(Object *ob,
       }
 
       BLI_bitmap *vert_tag = BLI_BITMAP_NEW(me->totvert, __func__);
+      const MVert *verts = me->vertices().data();
+      MutableSpan<MDeformVert> dverts = me->deform_verts_for_write();
 
-      for (vidx = 0, mv = me->mvert; vidx < me->totvert; vidx++, mv++) {
+      for (vidx = 0, mv = verts; vidx < me->totvert; vidx++, mv++) {
         if (!BLI_BITMAP_TEST(vert_tag, vidx)) {
           if ((vidx_mirr = mesh_get_x_mirror_vert(ob, nullptr, vidx, use_topology)) != -1) {
             if (vidx != vidx_mirr) {
-              mv_mirr = &me->mvert[vidx_mirr];
+              mv_mirr = &verts[vidx_mirr];
               if (!BLI_BITMAP_TEST(vert_tag, vidx_mirr)) {
 
                 if (use_vert_sel) {
@@ -2474,8 +2487,8 @@ void ED_vgroup_mirror(Object *ob,
                 }
 
                 if (sel || sel_mirr) {
-                  dvert = &me->dvert[vidx];
-                  dvert_mirr = &me->dvert[vidx_mirr];
+                  MDeformVert *dvert = &dverts[vidx];
+                  dvert_mirr = &dvert[vidx_mirr];
 
                   VGROUP_MIRR_OP;
                   totmirr++;
@@ -2528,7 +2541,7 @@ void ED_vgroup_mirror(Object *ob,
             sel_mirr = bp_mirr->f1 & SELECT;
 
             if (sel || sel_mirr) {
-              dvert = &lt->dvert[i1];
+              MDeformVert *dvert = &lt->dvert[i1];
               dvert_mirr = &lt->dvert[i2];
 
               VGROUP_MIRR_OP;
@@ -2612,14 +2625,12 @@ static void vgroup_assign_verts(Object *ob, const float weight)
       }
     }
     else {
-      if (!me->dvert) {
-        BKE_object_defgroup_data_create(&me->id);
-      }
+      const Span<MVert> verts = me->vertices();
+      MutableSpan<MDeformVert> dverts = me->deform_verts_for_write();
+      MDeformVert *dv = dverts.data();
 
-      MVert *mv = me->mvert;
-      MDeformVert *dv = me->dvert;
-
-      for (int i = 0; i < me->totvert; i++, mv++, dv++) {
+      for (int i = 0; i < me->totvert; i++, dv++) {
+        const MVert *mv = &verts[i];
         if (mv->flag & SELECT) {
           MDeformWeight *dw;
           dw = BKE_defvert_ensure_index(dv, def_nr);
@@ -2733,7 +2744,7 @@ static bool vertex_group_mesh_with_dvert_poll(bContext *C)
   }
 
   Mesh *me = static_cast<Mesh *>(ob->data);
-  if (me->dvert == nullptr) {
+  if (me->deform_verts().is_empty()) {
     CTX_wm_operator_poll_msg_set(C, "The active mesh object has no vertex group data");
     return false;
   }
@@ -4345,9 +4356,12 @@ static void vgroup_copy_active_to_sel_single(Object *ob, const int def_nr)
       return;
     }
 
-    dv = me->dvert;
+    const Span<MVert> verts = me->vertices();
+    MutableSpan<MDeformVert> dverts = me->deform_verts_for_write();
+
+    dv = dverts.data();
     for (i = 0; i < me->totvert; i++, dv++) {
-      if ((me->mvert[i].flag & SELECT) && (dv != dvert_act)) {
+      if ((verts[i].flag & SELECT) && (dv != dvert_act)) {
 
         BKE_defvert_copy_index(dv, def_nr, dvert_act, def_nr);