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

1 files changed, 40 insertions, 29 deletions

diff --git a/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c b/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c
index d98660d8939..f40a287adf6 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c
+++ b/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c
@@ -168,8 +168,9 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, const wmEvent *even
 
   ED_view3d_viewcontext_init(C, &vc, depsgraph);
   me = BKE_mesh_from_object(vc.obact);
+  const MDeformVert *dvert = BKE_mesh_deform_verts(me);
 
-  if (me && me->dvert && vc.v3d && vc.rv3d && (me->vertex_group_active_index != 0)) {
+  if (me && dvert && vc.v3d && vc.rv3d && (me->vertex_group_active_index != 0)) {
     const bool use_vert_sel = (me->editflag & ME_EDIT_PAINT_VERT_SEL) != 0;
     int v_idx_best = -1;
     uint index;
@@ -200,7 +201,7 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, const wmEvent *even
       ToolSettings *ts = vc.scene->toolsettings;
       Brush *brush = BKE_paint_brush(&ts->wpaint->paint);
       const int vgroup_active = me->vertex_group_active_index - 1;
-      float vgroup_weight = BKE_defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
+      float vgroup_weight = BKE_defvert_find_weight(&dvert[v_idx_best], vgroup_active);
       const int defbase_tot = BLI_listbase_count(&me->vertex_group_names);
       bool use_lock_relative = ts->wpaint_lock_relative;
       bool *defbase_locked = NULL, *defbase_unlocked = NULL;
@@ -232,7 +233,7 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, const wmEvent *even
 
           bool is_normalized = ts->auto_normalize || use_lock_relative;
           vgroup_weight = BKE_defvert_multipaint_collective_weight(
-              &me->dvert[v_idx_best], defbase_tot, defbase_sel, defbase_tot_sel, is_normalized);
+              &dvert[v_idx_best], defbase_tot, defbase_sel, defbase_tot_sel, is_normalized);
         }
 
         MEM_freeN(defbase_sel);
@@ -243,7 +244,7 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, const wmEvent *even
             defbase_tot, defbase_locked, defbase_unlocked, defbase_locked, defbase_unlocked);
 
         vgroup_weight = BKE_defvert_lock_relative_weight(
-            vgroup_weight, &me->dvert[v_idx_best], defbase_tot, defbase_locked, defbase_unlocked);
+            vgroup_weight, &dvert[v_idx_best], defbase_tot, defbase_locked, defbase_unlocked);
       }
 
       MEM_SAFE_FREE(defbase_locked);
@@ -316,8 +317,11 @@ static const EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C,
 
       ED_view3d_viewcontext_init(C, &vc, depsgraph);
       me = BKE_mesh_from_object(vc.obact);
+      const MPoly *polys = BKE_mesh_polygons(me);
+      const MLoop *loops = BKE_mesh_loops(me);
+      const MDeformVert *dverts = BKE_mesh_deform_verts(me);
 
-      if (me && me->dvert && vc.v3d && vc.rv3d && me->vertex_group_names.first) {
+      if (me && dverts && vc.v3d && vc.rv3d && me->vertex_group_names.first) {
         const int defbase_tot = BLI_listbase_count(&me->vertex_group_names);
         const bool use_vert_sel = (me->editflag & ME_EDIT_PAINT_VERT_SEL) != 0;
         int *groups = MEM_callocN(defbase_tot * sizeof(int), "groups");
@@ -334,17 +338,17 @@ static const EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C,
 
         if (use_vert_sel) {
           if (ED_mesh_pick_vert(C, vc.obact, mval, ED_MESH_PICK_DEFAULT_VERT_DIST, true, &index)) {
-            MDeformVert *dvert = &me->dvert[index];
+            const MDeformVert *dvert = &dverts[index];
             found |= weight_paint_sample_enum_itemf__helper(dvert, defbase_tot, groups);
           }
         }
         else {
           if (ED_mesh_pick_face(C, vc.obact, mval, ED_MESH_PICK_DEFAULT_FACE_DIST, &index)) {
-            const MPoly *mp = &me->mpoly[index];
+            const MPoly *mp = &polys[index];
             uint fidx = mp->totloop - 1;
 
             do {
-              MDeformVert *dvert = &me->dvert[me->mloop[mp->loopstart + fidx].v];
+              const MDeformVert *dvert = &dverts[loops[mp->loopstart + fidx].v];
               found |= weight_paint_sample_enum_itemf__helper(dvert, defbase_tot, groups);
             } while (fidx--);
           }
@@ -441,7 +445,12 @@ static bool weight_paint_set(Object *ob, float paintweight)
   /* mutually exclusive, could be made into a */
   const short paint_selmode = ME_EDIT_PAINT_SEL_MODE(me);
 
-  if (me->totpoly == 0 || me->dvert == NULL || !me->mpoly) {
+  const MVert *verts = BKE_mesh_vertices(me);
+  const MPoly *polys = BKE_mesh_polygons(me);
+  const MLoop *loops = BKE_mesh_loops(me);
+  MDeformVert *dvert = BKE_mesh_deform_verts_for_write(me);
+
+  if (me->totpoly == 0 || dvert == NULL) {
     return false;
   }
 
@@ -453,9 +462,9 @@ static bool weight_paint_set(Object *ob, float paintweight)
   }
 
   struct WPaintPrev wpp;
-  wpaint_prev_create(&wpp, me->dvert, me->totvert);
+  wpaint_prev_create(&wpp, dvert, me->totvert);
 
-  for (index = 0, mp = me->mpoly; index < me->totpoly; index++, mp++) {
+  for (index = 0, mp = polys; index < me->totpoly; index++, mp++) {
     uint fidx = mp->totloop - 1;
 
     if ((paint_selmode == SCE_SELECT_FACE) && !(mp->flag & ME_FACE_SEL)) {
@@ -463,14 +472,14 @@ static bool weight_paint_set(Object *ob, float paintweight)
     }
 
     do {
-      uint vidx = me->mloop[mp->loopstart + fidx].v;
+      uint vidx = loops[mp->loopstart + fidx].v;
 
-      if (!me->dvert[vidx].flag) {
-        if ((paint_selmode == SCE_SELECT_VERTEX) && !(me->mvert[vidx].flag & SELECT)) {
+      if (!dvert[vidx].flag) {
+        if ((paint_selmode == SCE_SELECT_VERTEX) && !(verts[vidx].flag & SELECT)) {
           continue;
         }
 
-        dw = BKE_defvert_ensure_index(&me->dvert[vidx], vgroup_active);
+        dw = BKE_defvert_ensure_index(&dvert[vidx], vgroup_active);
         if (dw) {
           dw_prev = BKE_defvert_ensure_index(wpp.wpaint_prev + vidx, vgroup_active);
           dw_prev->weight = dw->weight; /* set the undo weight */
@@ -482,11 +491,11 @@ static bool weight_paint_set(Object *ob, float paintweight)
             if (j >= 0) {
               /* copy, not paint again */
               if (vgroup_mirror != -1) {
-                dw = BKE_defvert_ensure_index(me->dvert + j, vgroup_mirror);
+                dw = BKE_defvert_ensure_index(dvert + j, vgroup_mirror);
                 dw_prev = BKE_defvert_ensure_index(wpp.wpaint_prev + j, vgroup_mirror);
               }
               else {
-                dw = BKE_defvert_ensure_index(me->dvert + j, vgroup_active);
+                dw = BKE_defvert_ensure_index(dvert + j, vgroup_active);
                 dw_prev = BKE_defvert_ensure_index(wpp.wpaint_prev + j, vgroup_active);
               }
               dw_prev->weight = dw->weight; /* set the undo weight */
@@ -494,14 +503,14 @@ static bool weight_paint_set(Object *ob, float paintweight)
             }
           }
         }
-        me->dvert[vidx].flag = 1;
+        dvert[vidx].flag = 1;
       }
 
     } while (fidx--);
   }
 
   {
-    MDeformVert *dv = me->dvert;
+    MDeformVert *dv = dvert;
     for (index = me->totvert; index != 0; index--, dv++) {
       dv->flag = 0;
     }
@@ -574,6 +583,7 @@ typedef struct WPGradient_userData {
   struct ARegion *region;
   Scene *scene;
   Mesh *me;
+  MDeformVert *dvert;
   Brush *brush;
   const float *sco_start; /* [2] */
   const float *sco_end;   /* [2] */
@@ -593,7 +603,6 @@ typedef struct WPGradient_userData {
 
 static void gradientVert_update(WPGradient_userData *grad_data, int index)
 {
-  Mesh *me = grad_data->me;
   WPGradient_vertStore *vs = &grad_data->vert_cache->elem[index];
 
   /* Optionally restrict to assigned vertices only. */
@@ -617,7 +626,7 @@ static void gradientVert_update(WPGradient_userData *grad_data, int index)
   alpha = BKE_brush_curve_strength_clamped(grad_data->brush, alpha, 1.0f);
 
   if (alpha != 0.0f) {
-    MDeformVert *dv = &me->dvert[index];
+    MDeformVert *dv = &grad_data->dvert[index];
     MDeformWeight *dw = BKE_defvert_ensure_index(dv, grad_data->def_nr);
     // dw->weight = alpha; // testing
     int tool = grad_data->brush->blend;
@@ -631,7 +640,7 @@ static void gradientVert_update(WPGradient_userData *grad_data, int index)
     vs->flag |= VGRAD_STORE_IS_MODIFIED;
   }
   else {
-    MDeformVert *dv = &me->dvert[index];
+    MDeformVert *dv = &grad_data->dvert[index];
     if (vs->flag & VGRAD_STORE_DW_EXIST) {
       /* normally we NULL check, but in this case we know it exists */
       MDeformWeight *dw = BKE_defvert_find_index(dv, grad_data->def_nr);
@@ -669,10 +678,9 @@ static void gradientVertInit__mapFunc(void *userData,
                                       const float UNUSED(no[3]))
 {
   WPGradient_userData *grad_data = userData;
-  Mesh *me = grad_data->me;
   WPGradient_vertStore *vs = &grad_data->vert_cache->elem[index];
 
-  if (grad_data->use_select && !(me->mvert[index].flag & SELECT)) {
+  if (grad_data->use_select && !(grad_data->dvert[index].flag & SELECT)) {
     copy_v2_fl(vs->sco, FLT_MAX);
     return;
   }
@@ -693,7 +701,7 @@ static void gradientVertInit__mapFunc(void *userData,
     return;
   }
 
-  MDeformVert *dv = &me->dvert[index];
+  MDeformVert *dv = &grad_data->dvert[index];
   const MDeformWeight *dw = BKE_defvert_find_index(dv, grad_data->def_nr);
   if (dw) {
     vs->weight_orig = dw->weight;
@@ -727,8 +735,9 @@ static int paint_weight_gradient_modal(bContext *C, wmOperator *op, const wmEven
     if (vert_cache != NULL) {
       Mesh *me = ob->data;
       if (vert_cache->wpp.wpaint_prev) {
-        BKE_defvert_array_free_elems(me->dvert, me->totvert);
-        BKE_defvert_array_copy(me->dvert, vert_cache->wpp.wpaint_prev, me->totvert);
+        MDeformVert *dvert = BKE_mesh_deform_verts_for_write(me);
+        BKE_defvert_array_free_elems(dvert, me->totvert);
+        BKE_defvert_array_copy(dvert, vert_cache->wpp.wpaint_prev, me->totvert);
         wpaint_prev_destroy(&vert_cache->wpp);
       }
       MEM_freeN(vert_cache);
@@ -753,6 +762,7 @@ static int paint_weight_gradient_exec(bContext *C, wmOperator *op)
   Scene *scene = CTX_data_scene(C);
   Object *ob = CTX_data_active_object(C);
   Mesh *me = ob->data;
+  MDeformVert *dverts = BKE_mesh_deform_verts_for_write(me);
   int x_start = RNA_int_get(op->ptr, "xstart");
   int y_start = RNA_int_get(op->ptr, "ystart");
   int x_end = RNA_int_get(op->ptr, "xend");
@@ -774,7 +784,7 @@ static int paint_weight_gradient_exec(bContext *C, wmOperator *op)
       data.is_init = true;
 
       wpaint_prev_create(
-          &((WPGradient_vertStoreBase *)gesture->user_data.data)->wpp, me->dvert, me->totvert);
+          &((WPGradient_vertStoreBase *)gesture->user_data.data)->wpp, dverts, me->totvert);
 
       /* On initialization only, convert face -> vert sel. */
       if (me->editflag & ME_EDIT_PAINT_FACE_SEL) {
@@ -797,6 +807,7 @@ static int paint_weight_gradient_exec(bContext *C, wmOperator *op)
   data.region = region;
   data.scene = scene;
   data.me = ob->data;
+  data.dvert = dverts;
   data.sco_start = sco_start;
   data.sco_end = sco_end;
   data.sco_line_div = 1.0f / len_v2v2(sco_start, sco_end);
@@ -851,7 +862,7 @@ static int paint_weight_gradient_exec(bContext *C, wmOperator *op)
     const int vgroup_num = BLI_listbase_count(&me->vertex_group_names);
     bool *vgroup_validmap = BKE_object_defgroup_validmap_get(ob, vgroup_num);
     if (vgroup_validmap != NULL) {
-      MDeformVert *dvert = me->dvert;
+      MDeformVert *dvert = dverts;
       for (int i = 0; i < me->totvert; i++) {
         if ((data.vert_cache->elem[i].flag & VGRAD_STORE_IS_MODIFIED) != 0) {
           BKE_defvert_normalize_lock_single(&dvert[i], vgroup_validmap, vgroup_num, data.def_nr);