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

4 files changed, 57 insertions, 65 deletions

diff --git a/source/blender/io/collada/ArmatureExporter.cpp b/source/blender/io/collada/ArmatureExporter.cpp
index 87dd2fbd816..3cc98917116 100644
--- a/source/blender/io/collada/ArmatureExporter.cpp
+++ b/source/blender/io/collada/ArmatureExporter.cpp
@@ -76,7 +76,7 @@ bool ArmatureExporter::add_instance_controller(Object *ob)
   ins.setUrl(COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, controller_id));
 
   Mesh *me = (Mesh *)ob->data;
-  if (!me->dvert) {
+  if (BKE_mesh_deform_verts(me) == nullptr) {
     return false;
   }
 
diff --git a/source/blender/io/collada/ControllerExporter.cpp b/source/blender/io/collada/ControllerExporter.cpp
index 38ad0e42d0f..6bf8d904a41 100644
--- a/source/blender/io/collada/ControllerExporter.cpp
+++ b/source/blender/io/collada/ControllerExporter.cpp
@@ -63,7 +63,7 @@ bool ControllerExporter::add_instance_controller(Object *ob)
   ins.setUrl(COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, controller_id));
 
   Mesh *me = (Mesh *)ob->data;
-  if (!me->dvert) {
+  if (BKE_mesh_deform_verts(me) == nullptr) {
     return false;
   }
 
@@ -160,7 +160,7 @@ void ControllerExporter::export_skin_controller(Object *ob, Object *ob_arm)
   bool use_instantiation = this->export_settings.get_use_object_instantiation();
   Mesh *me;
 
-  if (((Mesh *)ob->data)->dvert == nullptr) {
+  if (BKE_mesh_deform_verts((Mesh *)ob->data) == nullptr) {
     return;
   }
 
@@ -203,9 +203,10 @@ void ControllerExporter::export_skin_controller(Object *ob, Object *ob_arm)
       }
     }
 
+    const MDeformVert *dvert = BKE_mesh_deform_verts(me);
     int oob_counter = 0;
     for (i = 0; i < me->totvert; i++) {
-      MDeformVert *vert = &me->dvert[i];
+      const MDeformVert *vert = &dvert[i];
       std::map<int, float> jw;
 
       /* We're normalizing the weights later */
diff --git a/source/blender/io/collada/GeometryExporter.cpp b/source/blender/io/collada/GeometryExporter.cpp
index 1a3a68923e3..f8123432f4e 100644
--- a/source/blender/io/collada/GeometryExporter.cpp
+++ b/source/blender/io/collada/GeometryExporter.cpp
@@ -27,6 +27,8 @@
 #include "collada_internal.h"
 #include "collada_utils.h"
 
+using blender::Span;
+
 void GeometryExporter::exportGeom()
 {
   Scene *sce = blender_context.get_scene();
@@ -117,11 +119,12 @@ void GeometryExporter::operator()(Object *ob)
   if (this->export_settings.get_include_shapekeys()) {
     Key *key = BKE_key_from_object(ob);
     if (key) {
+      blender::MutableSpan<MVert> verts = me->vertices_for_write();
       KeyBlock *kb = (KeyBlock *)key->block.first;
       /* skip the basis */
       kb = kb->next;
       for (; kb; kb = kb->next) {
-        BKE_keyblock_convert_to_mesh(kb, me->mvert, me->totvert);
+        BKE_keyblock_convert_to_mesh(kb, verts.data(), me->totvert);
         export_key_mesh(ob, me, kb);
       }
     }
@@ -197,8 +200,7 @@ void GeometryExporter::export_key_mesh(Object *ob, Mesh *me, KeyBlock *kb)
 
 void GeometryExporter::createLooseEdgeList(Object *ob, Mesh *me, std::string &geom_id)
 {
-
-  MEdge *medges = me->medge;
+  const Span<MEdge> edges = me->edges();
   int totedges = me->totedge;
   int edges_in_linelist = 0;
   std::vector<unsigned int> edge_list;
@@ -207,7 +209,7 @@ void GeometryExporter::createLooseEdgeList(Object *ob, Mesh *me, std::string &ge
   /* Find all loose edges in Mesh
    * and save vertex indices in edge_list */
   for (index = 0; index < totedges; index++) {
-    MEdge *edge = &medges[index];
+    const MEdge *edge = &edges[index];
 
     if (edge->flag & ME_LOOSEEDGE) {
       edges_in_linelist += 1;
@@ -285,19 +287,17 @@ static bool collect_vertex_counts_per_poly(Mesh *me,
                                            int material_index,
                                            std::vector<unsigned long> &vcount_list)
 {
+  const Span<MPoly> polys = me->polygons();
   const blender::bke::AttributeAccessor attributes = blender::bke::mesh_attributes(*me);
   const blender::VArray<int> material_indices = attributes.lookup_or_default<int>(
       "material_index", ATTR_DOMAIN_FACE, 0);
-  MPoly *mpolys = me->mpoly;
-  int totpolys = me->totpoly;
   bool is_triangulated = true;
 
-  int i;
   /* Expecting that the material index is always 0 if the mesh has no materials assigned */
-  for (i = 0; i < totpolys; i++) {
+  for (const int i : polys.index_range()) {
     if (material_indices[i] == material_index) {
-      MPoly *p = &mpolys[i];
-      int vertex_count = p->totloop;
+      const MPoly &poly = polys[i];
+      const int vertex_count = poly.totloop;
       vcount_list.push_back(vertex_count);
       if (vertex_count != 3) {
         is_triangulated = false;
@@ -322,10 +322,8 @@ void GeometryExporter::create_mesh_primitive_list(short material_index,
                                                   std::string &geom_id,
                                                   std::vector<BCPolygonNormalsIndices> &norind)
 {
-
-  MPoly *mpolys = me->mpoly;
-  MLoop *mloops = me->mloop;
-  int totpolys = me->totpoly;
+  const Span<MPoly> polys = me->polygons();
+  const Span<MLoop> loops = me->loops();
 
   std::vector<unsigned long> vcount_list;
 
@@ -407,12 +405,12 @@ void GeometryExporter::create_mesh_primitive_list(short material_index,
 
   /* <p> */
   int texindex = 0;
-  for (int i = 0; i < totpolys; i++) {
-    MPoly *p = &mpolys[i];
+  for (const int i : polys.index_range()) {
+    const MPoly *p = &polys[i];
     int loop_count = p->totloop;
 
     if (material_indices[i] == material_index) {
-      MLoop *l = &mloops[p->loopstart];
+      const MLoop *l = &loops[p->loopstart];
       BCPolygonNormalsIndices normal_indices = norind[i];
 
       for (int j = 0; j < loop_count; j++) {
@@ -436,18 +434,13 @@ void GeometryExporter::create_mesh_primitive_list(short material_index,
 
 void GeometryExporter::createVertsSource(std::string geom_id, Mesh *me)
 {
-#if 0
-  int totverts = dm->getNumVerts(dm);
-  MVert *verts = dm->getVertArray(dm);
-#endif
-  int totverts = me->totvert;
-  MVert *verts = me->mvert;
+  const Span<MVert> verts = me->vertices();
 
   COLLADASW::FloatSourceF source(mSW);
   source.setId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::POSITION));
   source.setArrayId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::POSITION) +
                     ARRAY_ID_SUFFIX);
-  source.setAccessorCount(totverts);
+  source.setAccessorCount(verts.size());
   source.setAccessorStride(3);
 
   COLLADASW::SourceBase::ParameterNameList &param = source.getParameterNameList();
@@ -458,8 +451,7 @@ void GeometryExporter::createVertsSource(std::string geom_id, Mesh *me)
    * count = ""> */
   source.prepareToAppendValues();
   /* appends data to <float_array> */
-  int i = 0;
-  for (i = 0; i < totverts; i++) {
+  for (const int i : verts.index_range()) {
     Vector co;
     if (export_settings.get_apply_global_orientation()) {
       bc_add_global_transform(co, verts[i].co, export_settings.get_global_transform());
@@ -508,11 +500,11 @@ void GeometryExporter::createVertexColorSource(std::string geom_id, Mesh *me)
 
     source.prepareToAppendValues();
 
-    MPoly *mpoly;
-    int i;
-    for (i = 0, mpoly = me->mpoly; i < me->totpoly; i++, mpoly++) {
-      const MLoopCol *mlc = mloopcol + mpoly->loopstart;
-      for (int j = 0; j < mpoly->totloop; j++, mlc++) {
+    const Span<MPoly> polys = me->polygons();
+    for (const int i : polys.index_range()) {
+      const MPoly &poly = polys[i];
+      const MLoopCol *mlc = mloopcol + poly.loopstart;
+      for (int j = 0; j < poly.totloop; j++, mlc++) {
         source.appendValues(mlc->r / 255.0f, mlc->g / 255.0f, mlc->b / 255.0f, mlc->a / 255.0f);
       }
     }
@@ -537,10 +529,8 @@ std::string GeometryExporter::makeTexcoordSourceId(std::string &geom_id,
 
 void GeometryExporter::createTexcoordsSource(std::string geom_id, Mesh *me)
 {
-
-  int totpoly = me->totpoly;
   int totuv = me->totloop;
-  MPoly *mpolys = me->mpoly;
+  const Span<MPoly> polys = me->polygons();
 
   int num_layers = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
 
@@ -566,8 +556,8 @@ void GeometryExporter::createTexcoordsSource(std::string geom_id, Mesh *me)
 
       source.prepareToAppendValues();
 
-      for (int index = 0; index < totpoly; index++) {
-        MPoly *mpoly = mpolys + index;
+      for (const int i : polys.index_range()) {
+        const MPoly *mpoly = &polys[i];
         MLoopUV *mloop = mloops + mpoly->loopstart;
         for (int j = 0; j < mpoly->totloop; j++) {
           source.appendValues(mloop[j].uv[0], mloop[j].uv[1]);
@@ -625,9 +615,10 @@ void GeometryExporter::create_normals(std::vector<Normal> &normals,
   std::map<Normal, unsigned int> shared_normal_indices;
   int last_normal_index = -1;
 
-  MVert *verts = me->mvert;
+  const Span<MVert> verts = me->vertices();
   const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(me);
-  MLoop *mloops = me->mloop;
+  const Span<MPoly> polys = me->polygons();
+  const Span<MLoop> loops = me->loops();
   const float(*lnors)[3] = nullptr;
   bool use_custom_normals = false;
 
@@ -637,15 +628,15 @@ void GeometryExporter::create_normals(std::vector<Normal> &normals,
     use_custom_normals = true;
   }
 
-  for (int poly_index = 0; poly_index < me->totpoly; poly_index++) {
-    MPoly *mpoly = &me->mpoly[poly_index];
+  for (const int poly_index : polys.index_range()) {
+    const MPoly *mpoly = &polys[poly_index];
     bool use_vertex_normals = use_custom_normals || mpoly->flag & ME_SMOOTH;
 
     if (!use_vertex_normals) {
       /* For flat faces use face normal as vertex normal: */
 
       float vector[3];
-      BKE_mesh_calc_poly_normal(mpoly, mloops + mpoly->loopstart, verts, vector);
+      BKE_mesh_calc_poly_normal(mpoly, &loops[mpoly->loopstart], verts.data(), vector);
 
       Normal n = {vector[0], vector[1], vector[2]};
       normals.push_back(n);
@@ -662,7 +653,7 @@ void GeometryExporter::create_normals(std::vector<Normal> &normals,
           normalize_v3_v3(normalized, lnors[loop_idx]);
         }
         else {
-          copy_v3_v3(normalized, vert_normals[mloops[loop_index].v]);
+          copy_v3_v3(normalized, vert_normals[loops[loop_index].v]);
           normalize_v3(normalized);
         }
         Normal n = {normalized[0], normalized[1], normalized[2]};
diff --git a/source/blender/io/collada/MeshImporter.cpp b/source/blender/io/collada/MeshImporter.cpp
index fab53908d5a..8aa1685030f 100644
--- a/source/blender/io/collada/MeshImporter.cpp
+++ b/source/blender/io/collada/MeshImporter.cpp
@@ -33,6 +33,8 @@
 #include "MeshImporter.h"
 #include "collada_utils.h"
 
+using blender::MutableSpan;
+
 /* get node name, or fall back to original id if not present (name is optional) */
 template<class T> static std::string bc_get_dae_name(T *node)
 {
@@ -341,14 +343,10 @@ void MeshImporter::read_vertices(COLLADAFW::Mesh *mesh, Mesh *me)
   }
 
   me->totvert = pos.getFloatValues()->getCount() / stride;
-  me->mvert = (MVert *)CustomData_add_layer(
-      &me->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, me->totvert);
-
-  MVert *mvert;
-  int i;
-
-  for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
-    get_vector(mvert->co, pos, i, stride);
+  CustomData_add_layer(&me->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, me->totvert);
+  MutableSpan<MVert> verts = me->vertices_for_write();
+  for (const int i : verts.index_range()) {
+    get_vector(verts[i].co, pos, i, stride);
   }
 }
 
@@ -449,10 +447,8 @@ void MeshImporter::allocate_poly_data(COLLADAFW::Mesh *collada_mesh, Mesh *me)
   if (total_poly_count > 0) {
     me->totpoly = total_poly_count;
     me->totloop = total_loop_count;
-    me->mpoly = (MPoly *)CustomData_add_layer(
-        &me->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, me->totpoly);
-    me->mloop = (MLoop *)CustomData_add_layer(
-        &me->ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, me->totloop);
+    CustomData_add_layer(&me->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, me->totpoly);
+    CustomData_add_layer(&me->ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, me->totloop);
 
     unsigned int totuvset = collada_mesh->getUVCoords().getInputInfosArray().getCount();
     for (int i = 0; i < totuvset; i++) {
@@ -472,7 +468,7 @@ void MeshImporter::allocate_poly_data(COLLADAFW::Mesh *collada_mesh, Mesh *me)
             &me->ldata, CD_MLOOPUV, CD_SET_DEFAULT, nullptr, me->totloop, uvname.c_str());
       }
       /* activate the first uv map */
-      me->mloopuv = (MLoopUV *)CustomData_get_layer_n(&me->ldata, CD_MLOOPUV, 0);
+      CustomData_set_layer_active(&me->ldata, CD_MLOOPUV, 0);
     }
 
     int totcolset = collada_mesh->getColors().getInputInfosArray().getCount();
@@ -484,7 +480,7 @@ void MeshImporter::allocate_poly_data(COLLADAFW::Mesh *collada_mesh, Mesh *me)
         CustomData_add_layer_named(
             &me->ldata, CD_PROP_BYTE_COLOR, CD_SET_DEFAULT, nullptr, me->totloop, colname.c_str());
       }
-      me->mloopcol = (MLoopCol *)CustomData_get_layer_n(&me->ldata, CD_PROP_BYTE_COLOR, 0);
+      CustomData_set_layer_active(&me->ldata, CD_PROP_BYTE_COLOR, 0);
     }
   }
 }
@@ -556,10 +552,11 @@ void MeshImporter::mesh_add_edges(Mesh *mesh, int len)
 
   CustomData_free(&mesh->edata, mesh->totedge);
   mesh->edata = edata;
-  BKE_mesh_update_customdata_pointers(mesh, false); /* new edges don't change tessellation */
+
+  MutableSpan<MEdge> edges = mesh->edges_for_write();
 
   /* set default flags */
-  medge = &mesh->medge[mesh->totedge];
+  medge = &edges[mesh->totedge];
   for (int i = 0; i < len; i++, medge++) {
     medge->flag = ME_EDGEDRAW | ME_EDGERENDER | SELECT;
   }
@@ -576,7 +573,8 @@ void MeshImporter::read_lines(COLLADAFW::Mesh *mesh, Mesh *me)
     /* unsigned int total_edge_count = loose_edge_count + face_edge_count; */ /* UNUSED */
 
     mesh_add_edges(me, loose_edge_count);
-    MEdge *med = me->medge + face_edge_count;
+    MutableSpan<MEdge> edges = me->edges_for_write();
+    MEdge *med = edges.data() + face_edge_count;
 
     COLLADAFW::MeshPrimitiveArray &prim_arr = mesh->getMeshPrimitives();
 
@@ -609,8 +607,10 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh, Mesh *me)
   UVDataWrapper uvs(collada_mesh->getUVCoords());
   VCOLDataWrapper vcol(collada_mesh->getColors());
 
-  MPoly *mpoly = me->mpoly;
-  MLoop *mloop = me->mloop;
+  MutableSpan<MPoly> polys = me->polygons_for_write();
+  MutableSpan<MLoop> loops = me->loops_for_write();
+  MPoly *mpoly = polys.data();
+  MLoop *mloop = loops.data();
   int loop_index = 0;
 
   MaterialIdPrimitiveArrayMap mat_prim_map;