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, 173 insertions, 38 deletions

diff --git a/source/blender/makesrna/intern/rna_mesh.c b/source/blender/makesrna/intern/rna_mesh.c
index 6979b65cfc9..f63d91d5943 100644
--- a/source/blender/makesrna/intern/rna_mesh.c
+++ b/source/blender/makesrna/intern/rna_mesh.c
@@ -348,7 +348,7 @@ static int rna_MeshVertex_index_get(PointerRNA *ptr)
 {
   const Mesh *mesh = rna_mesh(ptr);
   const MVert *vert = (MVert *)ptr->data;
-  const int index = (int)(vert - mesh->mvert);
+  const int index = (int)(vert - BKE_mesh_vertices(mesh));
   BLI_assert(index >= 0);
   BLI_assert(index < mesh->totvert);
   return index;
@@ -358,7 +358,7 @@ static int rna_MeshEdge_index_get(PointerRNA *ptr)
 {
   const Mesh *mesh = rna_mesh(ptr);
   const MEdge *edge = (MEdge *)ptr->data;
-  const int index = (int)(edge - mesh->medge);
+  const int index = (int)(edge - BKE_mesh_edges(mesh));
   BLI_assert(index >= 0);
   BLI_assert(index < mesh->totedge);
   return index;
@@ -368,7 +368,7 @@ static int rna_MeshPolygon_index_get(PointerRNA *ptr)
 {
   const Mesh *mesh = rna_mesh(ptr);
   const MPoly *mpoly = (MPoly *)ptr->data;
-  const int index = (int)(mpoly - mesh->mpoly);
+  const int index = (int)(mpoly - BKE_mesh_polygons(mesh));
   BLI_assert(index >= 0);
   BLI_assert(index < mesh->totpoly);
   return index;
@@ -378,7 +378,7 @@ static int rna_MeshLoop_index_get(PointerRNA *ptr)
 {
   const Mesh *mesh = rna_mesh(ptr);
   const MLoop *mloop = (MLoop *)ptr->data;
-  const int index = (int)(mloop - mesh->mloop);
+  const int index = (int)(mloop - BKE_mesh_loops(mesh));
   BLI_assert(index >= 0);
   BLI_assert(index < mesh->totloop);
   return index;
@@ -532,8 +532,9 @@ static void rna_MeshPolygon_normal_get(PointerRNA *ptr, float *values)
 {
   Mesh *me = rna_mesh(ptr);
   MPoly *mp = (MPoly *)ptr->data;
-
-  BKE_mesh_calc_poly_normal(mp, me->mloop + mp->loopstart, me->mvert, values);
+  const MVert *verts = BKE_mesh_vertices(me);
+  const MLoop *loops = BKE_mesh_loops(me);
+  BKE_mesh_calc_poly_normal(mp, loops + mp->loopstart, verts, values);
 }
 
 static bool rna_MeshPolygon_hide_get(PointerRNA *ptr)
@@ -582,23 +583,25 @@ static void rna_MeshPolygon_center_get(PointerRNA *ptr, float *values)
 {
   Mesh *me = rna_mesh(ptr);
   MPoly *mp = (MPoly *)ptr->data;
-
-  BKE_mesh_calc_poly_center(mp, me->mloop + mp->loopstart, me->mvert, values);
+  const MVert *verts = BKE_mesh_vertices(me);
+  const MLoop *loops = BKE_mesh_loops(me);
+  BKE_mesh_calc_poly_center(mp, loops + mp->loopstart, verts, values);
 }
 
 static float rna_MeshPolygon_area_get(PointerRNA *ptr)
 {
   Mesh *me = (Mesh *)ptr->owner_id;
   MPoly *mp = (MPoly *)ptr->data;
-
-  return BKE_mesh_calc_poly_area(mp, me->mloop + mp->loopstart, me->mvert);
+  const MVert *verts = BKE_mesh_vertices(me);
+  const MLoop *loops = BKE_mesh_loops(me);
+  return BKE_mesh_calc_poly_area(mp, loops + mp->loopstart, verts);
 }
 
 static void rna_MeshPolygon_flip(ID *id, MPoly *mp)
 {
   Mesh *me = (Mesh *)id;
-
-  BKE_mesh_polygon_flip(mp, me->mloop, &me->ldata);
+  MLoop *loops = BKE_mesh_loops_for_write(me);
+  BKE_mesh_polygon_flip(mp, loops, &me->ldata);
   BKE_mesh_tessface_clear(me);
   BKE_mesh_runtime_clear_geometry(me);
   BKE_mesh_normals_tag_dirty(me);
@@ -607,21 +610,24 @@ static void rna_MeshPolygon_flip(ID *id, MPoly *mp)
 static void rna_MeshLoopTriangle_verts_get(PointerRNA *ptr, int *values)
 {
   Mesh *me = rna_mesh(ptr);
+  const MLoop *loops = BKE_mesh_loops(me);
   MLoopTri *lt = (MLoopTri *)ptr->data;
-  values[0] = me->mloop[lt->tri[0]].v;
-  values[1] = me->mloop[lt->tri[1]].v;
-  values[2] = me->mloop[lt->tri[2]].v;
+  values[0] = loops[lt->tri[0]].v;
+  values[1] = loops[lt->tri[1]].v;
+  values[2] = loops[lt->tri[2]].v;
 }
 
 static void rna_MeshLoopTriangle_normal_get(PointerRNA *ptr, float *values)
 {
   Mesh *me = rna_mesh(ptr);
   MLoopTri *lt = (MLoopTri *)ptr->data;
-  unsigned int v1 = me->mloop[lt->tri[0]].v;
-  unsigned int v2 = me->mloop[lt->tri[1]].v;
-  unsigned int v3 = me->mloop[lt->tri[2]].v;
+  const MVert *verts = BKE_mesh_vertices(me);
+  const MLoop *loops = BKE_mesh_loops(me);
+  unsigned int v1 = loops[lt->tri[0]].v;
+  unsigned int v2 = loops[lt->tri[1]].v;
+  unsigned int v3 = loops[lt->tri[2]].v;
 
-  normal_tri_v3(values, me->mvert[v1].co, me->mvert[v2].co, me->mvert[v3].co);
+  normal_tri_v3(values, verts[v1].co, verts[v2].co, verts[v3].co);
 }
 
 static void rna_MeshLoopTriangle_split_normals_get(PointerRNA *ptr, float *values)
@@ -646,11 +652,12 @@ static float rna_MeshLoopTriangle_area_get(PointerRNA *ptr)
 {
   Mesh *me = rna_mesh(ptr);
   MLoopTri *lt = (MLoopTri *)ptr->data;
-  unsigned int v1 = me->mloop[lt->tri[0]].v;
-  unsigned int v2 = me->mloop[lt->tri[1]].v;
-  unsigned int v3 = me->mloop[lt->tri[2]].v;
-
-  return area_tri_v3(me->mvert[v1].co, me->mvert[v2].co, me->mvert[v3].co);
+  const MVert *verts = BKE_mesh_vertices(me);
+  const MLoop *loops = BKE_mesh_loops(me);
+  unsigned int v1 = loops[lt->tri[0]].v;
+  unsigned int v2 = loops[lt->tri[1]].v;
+  unsigned int v3 = loops[lt->tri[2]].v;
+  return area_tri_v3(verts[v1].co, verts[v2].co, verts[v3].co);
 }
 
 static void rna_MeshLoopColor_color_get(PointerRNA *ptr, float *values)
@@ -700,10 +707,10 @@ static void rna_Mesh_texspace_loc_get(PointerRNA *ptr, float values[3])
 static void rna_MeshVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   Mesh *me = rna_mesh(ptr);
-
-  if (me->dvert) {
+  MDeformVert *dverts = (MDeformVert *)BKE_mesh_deform_verts(me);
+  if (dverts) {
     const int index = rna_MeshVertex_index_get(ptr);
-    MDeformVert *dvert = &me->dvert[index];
+    MDeformVert *dvert = &dverts[index];
 
     rna_iterator_array_begin(
         iter, (void *)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
@@ -768,7 +775,7 @@ static void rna_CustomDataLayer_active_set(
     CustomData_set_layer_active(data, type, n);
   }
 
-  BKE_mesh_update_customdata_pointers(me, true);
+  BKE_mesh_tessface_clear(me);
 }
 
 static void rna_CustomDataLayer_clone_set(PointerRNA *ptr, CustomData *data, int value, int type)
@@ -1258,7 +1265,8 @@ static void rna_MeshPoly_vertices_get(PointerRNA *ptr, int *values)
 {
   Mesh *me = rna_mesh(ptr);
   MPoly *mp = (MPoly *)ptr->data;
-  MLoop *ml = &me->mloop[mp->loopstart];
+  const MLoop *loops = BKE_mesh_loops(me);
+  const MLoop *ml = &loops[mp->loopstart];
   unsigned int i;
   for (i = mp->totloop; i > 0; i--, values++, ml++) {
     *values = ml->v;
@@ -1268,8 +1276,10 @@ static void rna_MeshPoly_vertices_get(PointerRNA *ptr, int *values)
 static void rna_MeshPoly_vertices_set(PointerRNA *ptr, const int *values)
 {
   Mesh *me = rna_mesh(ptr);
-  MPoly *mp = (MPoly *)ptr->data;
-  MLoop *ml = &me->mloop[mp->loopstart];
+  const MPoly *mp = (const MPoly *)ptr->data;
+  MLoop *loops = BKE_mesh_loops_for_write(me);
+
+  MLoop *ml = &loops[mp->loopstart];
   unsigned int i;
   for (i = mp->totloop; i > 0; i--, values++, ml++) {
     ml->v = *values;
@@ -1325,7 +1335,8 @@ static bool rna_MeshLoopTriangle_use_smooth_get(PointerRNA *ptr)
 {
   const Mesh *me = rna_mesh(ptr);
   const MLoopTri *ltri = (MLoopTri *)ptr->data;
-  return me->mpoly[ltri->poly].flag & ME_SMOOTH;
+  const MPoly *polys = BKE_mesh_polygons(me);
+  return polys[ltri->poly].flag & ME_SMOOTH;
 }
 
 /* path construction */
@@ -1334,10 +1345,10 @@ static char *rna_VertexGroupElement_path(const PointerRNA *ptr)
 {
   const Mesh *me = rna_mesh(ptr); /* XXX not always! */
   const MDeformWeight *dw = (MDeformWeight *)ptr->data;
-  const MDeformVert *dvert;
+  const MDeformVert *dvert = BKE_mesh_deform_verts(me);
   int a, b;
 
-  for (a = 0, dvert = me->dvert; a < me->totvert; a++, dvert++) {
+  for (a = 0; a < me->totvert; a++, dvert++) {
     for (b = 0; b < dvert->totweight; b++) {
       if (dw == &dvert->dw[b]) {
         return BLI_sprintfN("vertices[%d].groups[%d]", a, b);
@@ -1437,6 +1448,98 @@ static char *rna_LoopCustomData_data_path(const PointerRNA *ptr, const char *col
   return NULL;
 }
 
+static void rna_Mesh_vertices_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  rna_iterator_array_begin(
+      iter, BKE_mesh_vertices_for_write(mesh), sizeof(MVert), mesh->totvert, false, NULL);
+}
+static int rna_Mesh_vertices_length(PointerRNA *ptr)
+{
+  const Mesh *mesh = rna_mesh(ptr);
+  return mesh->totvert;
+}
+int rna_Mesh_vertices_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  if (index < 0 || index >= mesh->totvert) {
+    return false;
+  }
+  r_ptr->owner_id = &mesh->id;
+  r_ptr->type = &RNA_MeshVertex;
+  r_ptr->data = &BKE_mesh_vertices_for_write(mesh)[index];
+  return true;
+}
+
+static void rna_Mesh_edges_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  rna_iterator_array_begin(
+      iter, BKE_mesh_edges_for_write(mesh), sizeof(MEdge), mesh->totedge, false, NULL);
+}
+static int rna_Mesh_edges_length(PointerRNA *ptr)
+{
+  const Mesh *mesh = rna_mesh(ptr);
+  return mesh->totedge;
+}
+int rna_Mesh_edges_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  if (index < 0 || index >= mesh->totedge) {
+    return false;
+  }
+  r_ptr->owner_id = &mesh->id;
+  r_ptr->type = &RNA_MeshEdge;
+  r_ptr->data = &BKE_mesh_edges_for_write(mesh)[index];
+  return true;
+}
+
+static void rna_Mesh_polygons_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  rna_iterator_array_begin(
+      iter, BKE_mesh_polygons_for_write(mesh), sizeof(MPoly), mesh->totpoly, false, NULL);
+}
+static int rna_Mesh_polygons_length(PointerRNA *ptr)
+{
+  const Mesh *mesh = rna_mesh(ptr);
+  return mesh->totpoly;
+}
+int rna_Mesh_polygons_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  if (index < 0 || index >= mesh->totpoly) {
+    return false;
+  }
+  r_ptr->owner_id = &mesh->id;
+  r_ptr->type = &RNA_MeshPolygon;
+  r_ptr->data = &BKE_mesh_polygons_for_write(mesh)[index];
+  return true;
+}
+
+static void rna_Mesh_loops_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  rna_iterator_array_begin(
+      iter, BKE_mesh_loops_for_write(mesh), sizeof(MLoop), mesh->totloop, false, NULL);
+}
+static int rna_Mesh_loops_length(PointerRNA *ptr)
+{
+  const Mesh *mesh = rna_mesh(ptr);
+  return mesh->totloop;
+}
+int rna_Mesh_loops_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
+{
+  Mesh *mesh = rna_mesh(ptr);
+  if (index < 0 || index >= mesh->totloop) {
+    return false;
+  }
+  r_ptr->owner_id = &mesh->id;
+  r_ptr->type = &RNA_MeshLoop;
+  r_ptr->data = &BKE_mesh_loops_for_write(mesh)[index];
+  return true;
+}
+
 static void rna_Mesh_vertex_normals_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   const Mesh *mesh = rna_mesh(ptr);
@@ -3267,28 +3370,60 @@ static void rna_def_mesh(BlenderRNA *brna)
   RNA_def_struct_ui_icon(srna, ICON_MESH_DATA);
 
   prop = RNA_def_property(srna, "vertices", PROP_COLLECTION, PROP_NONE);
-  RNA_def_property_collection_sdna(prop, NULL, "mvert", "totvert");
+  RNA_def_property_collection_funcs(prop,
+                                    "rna_Mesh_vertices_begin",
+                                    "rna_iterator_array_next",
+                                    "rna_iterator_array_end",
+                                    "rna_iterator_array_get",
+                                    "rna_Mesh_vertices_length",
+                                    "rna_Mesh_vertices_lookup_int",
+                                    NULL,
+                                    NULL);
   RNA_def_property_struct_type(prop, "MeshVertex");
   RNA_def_property_override_flag(prop, PROPOVERRIDE_IGNORE);
   RNA_def_property_ui_text(prop, "Vertices", "Vertices of the mesh");
   rna_def_mesh_vertices(brna, prop);
 
   prop = RNA_def_property(srna, "edges", PROP_COLLECTION, PROP_NONE);
-  RNA_def_property_collection_sdna(prop, NULL, "medge", "totedge");
+  RNA_def_property_collection_funcs(prop,
+                                    "rna_Mesh_edges_begin",
+                                    "rna_iterator_array_next",
+                                    "rna_iterator_array_end",
+                                    "rna_iterator_array_get",
+                                    "rna_Mesh_edges_length",
+                                    "rna_Mesh_edges_lookup_int",
+                                    NULL,
+                                    NULL);
   RNA_def_property_struct_type(prop, "MeshEdge");
   RNA_def_property_override_flag(prop, PROPOVERRIDE_IGNORE);
   RNA_def_property_ui_text(prop, "Edges", "Edges of the mesh");
   rna_def_mesh_edges(brna, prop);
 
   prop = RNA_def_property(srna, "loops", PROP_COLLECTION, PROP_NONE);
-  RNA_def_property_collection_sdna(prop, NULL, "mloop", "totloop");
+  RNA_def_property_collection_funcs(prop,
+                                    "rna_Mesh_loops_begin",
+                                    "rna_iterator_array_next",
+                                    "rna_iterator_array_end",
+                                    "rna_iterator_array_get",
+                                    "rna_Mesh_loops_length",
+                                    "rna_Mesh_loops_lookup_int",
+                                    NULL,
+                                    NULL);
   RNA_def_property_struct_type(prop, "MeshLoop");
   RNA_def_property_override_flag(prop, PROPOVERRIDE_IGNORE);
   RNA_def_property_ui_text(prop, "Loops", "Loops of the mesh (polygon corners)");
   rna_def_mesh_loops(brna, prop);
 
   prop = RNA_def_property(srna, "polygons", PROP_COLLECTION, PROP_NONE);
-  RNA_def_property_collection_sdna(prop, NULL, "mpoly", "totpoly");
+  RNA_def_property_collection_funcs(prop,
+                                    "rna_Mesh_polygons_begin",
+                                    "rna_iterator_array_next",
+                                    "rna_iterator_array_end",
+                                    "rna_iterator_array_get",
+                                    "rna_Mesh_polygons_length",
+                                    "rna_Mesh_polygons_lookup_int",
+                                    NULL,
+                                    NULL);
   RNA_def_property_struct_type(prop, "MeshPolygon");
   RNA_def_property_override_flag(prop, PROPOVERRIDE_IGNORE);
   RNA_def_property_ui_text(prop, "Polygons", "Polygons of the mesh");