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, 81 insertions, 52 deletions

diff --git a/source/blender/geometry/intern/add_curves_on_mesh.cc b/source/blender/geometry/intern/add_curves_on_mesh.cc
index 7f269578f5d..7490694bf12 100644
--- a/source/blender/geometry/intern/add_curves_on_mesh.cc
+++ b/source/blender/geometry/intern/add_curves_on_mesh.cc
@@ -4,6 +4,7 @@
 #include "BLI_task.hh"
 
 #include "BKE_attribute_math.hh"
+#include "BKE_mesh.h"
 #include "BKE_mesh_sample.hh"
 
 #include "GEO_add_curves_on_mesh.hh"
@@ -244,6 +245,8 @@ AddCurvesOnMeshOutputs add_curves_on_mesh(CurvesGeometry &curves,
   Vector<float2> used_uvs;
 
   /* Find faces that the passed in uvs belong to. */
+  const Span<MVert> surface_verts = inputs.surface->vertices();
+  const Span<MLoop> surface_loops = inputs.surface->loops();
   for (const int i : inputs.uvs.index_range()) {
     const float2 &uv = inputs.uvs[i];
     const ReverseUVSampler::Result result = inputs.reverse_uv_sampler->sample(uv);
@@ -256,9 +259,9 @@ AddCurvesOnMeshOutputs add_curves_on_mesh(CurvesGeometry &curves,
     looptris.append(&looptri);
     const float3 root_position_su = attribute_math::mix3<float3>(
         result.bary_weights,
-        inputs.surface->mvert[inputs.surface->mloop[looptri.tri[0]].v].co,
-        inputs.surface->mvert[inputs.surface->mloop[looptri.tri[1]].v].co,
-        inputs.surface->mvert[inputs.surface->mloop[looptri.tri[2]].v].co);
+        surface_verts[surface_loops[looptri.tri[0]].v].co,
+        surface_verts[surface_loops[looptri.tri[1]].v].co,
+        surface_verts[surface_loops[looptri.tri[2]].v].co);
     root_positions_cu.append(inputs.transforms->surface_to_curves * root_position_su);
     used_uvs.append(uv);
   }
diff --git a/source/blender/geometry/intern/mesh_merge_by_distance.cc b/source/blender/geometry/intern/mesh_merge_by_distance.cc
index d3a5a194555..ad39f686dd4 100644
--- a/source/blender/geometry/intern/mesh_merge_by_distance.cc
+++ b/source/blender/geometry/intern/mesh_merge_by_distance.cc
@@ -1164,26 +1164,26 @@ static void weld_mesh_context_create(const Mesh &mesh,
                                      const int vert_kill_len,
                                      WeldMesh *r_weld_mesh)
 {
-  Span<MEdge> medge{mesh.medge, mesh.totedge};
-  Span<MPoly> mpoly{mesh.mpoly, mesh.totpoly};
-  Span<MLoop> mloop{mesh.mloop, mesh.totloop};
   const int mvert_len = mesh.totvert;
+  const Span<MEdge> edges = mesh.edges();
+  const Span<MPoly> polys = mesh.polygons();
+  const Span<MLoop> loops = mesh.loops();
 
   Vector<WeldVert> wvert = weld_vert_ctx_alloc_and_setup(vert_dest_map, vert_kill_len);
   r_weld_mesh->vert_kill_len = vert_kill_len;
 
-  Array<int> edge_dest_map(medge.size());
-  Array<int> edge_ctx_map(medge.size());
-  Vector<WeldEdge> wedge = weld_edge_ctx_alloc(medge, vert_dest_map, edge_dest_map, edge_ctx_map);
+  Array<int> edge_dest_map(edges.size());
+  Array<int> edge_ctx_map(edges.size());
+  Vector<WeldEdge> wedge = weld_edge_ctx_alloc(edges, vert_dest_map, edge_dest_map, edge_ctx_map);
 
   Array<WeldGroup> v_links(mvert_len, {0, 0});
   weld_edge_ctx_setup(v_links, edge_dest_map, wedge, &r_weld_mesh->edge_kill_len);
 
-  weld_poly_loop_ctx_alloc(mpoly, mloop, vert_dest_map, edge_dest_map, r_weld_mesh);
+  weld_poly_loop_ctx_alloc(polys, loops, vert_dest_map, edge_dest_map, r_weld_mesh);
 
-  weld_poly_loop_ctx_setup(mloop,
+  weld_poly_loop_ctx_setup(loops,
 #ifdef USE_WELD_DEBUG
-                           mpoly,
+                           polys,
 
 #endif
                            mvert_len,
@@ -1198,7 +1198,7 @@ static void weld_mesh_context_create(const Mesh &mesh,
                          r_weld_mesh->vert_groups_buffer,
                          r_weld_mesh->vert_groups);
 
-  weld_edge_groups_setup(medge.size(),
+  weld_edge_groups_setup(edges.size(),
                          r_weld_mesh->edge_kill_len,
                          wedge,
                          edge_ctx_map,
@@ -1360,23 +1360,24 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
                                 MutableSpan<int> vert_dest_map,
                                 const int removed_vertex_count)
 {
-  Span<MPoly> mpoly{mesh.mpoly, mesh.totpoly};
-  Span<MLoop> mloop{mesh.mloop, mesh.totloop};
+  const Span<MPoly> src_polys = mesh.polygons();
+  const Span<MLoop> src_loops = mesh.loops();
   const int totvert = mesh.totvert;
   const int totedge = mesh.totedge;
-  const int totloop = mesh.totloop;
-  const int totpoly = mesh.totpoly;
 
   WeldMesh weld_mesh;
   weld_mesh_context_create(mesh, vert_dest_map, removed_vertex_count, &weld_mesh);
 
   const int result_nverts = totvert - weld_mesh.vert_kill_len;
   const int result_nedges = totedge - weld_mesh.edge_kill_len;
-  const int result_nloops = totloop - weld_mesh.loop_kill_len;
-  const int result_npolys = totpoly - weld_mesh.poly_kill_len + weld_mesh.wpoly_new_len;
+  const int result_nloops = src_loops.size() - weld_mesh.loop_kill_len;
+  const int result_npolys = src_polys.size() - weld_mesh.poly_kill_len + weld_mesh.wpoly_new_len;
 
   Mesh *result = BKE_mesh_new_nomain_from_template(
       &mesh, result_nverts, result_nedges, 0, result_nloops, result_npolys);
+  MutableSpan<MEdge> dst_edges = result->edges_for_write();
+  MutableSpan<MPoly> dst_polys = result->polygons_for_write();
+  MutableSpan<MLoop> dst_loops = result->loops_for_write();
 
   /* Vertices. */
 
@@ -1431,7 +1432,7 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
     }
     if (count) {
       CustomData_copy_data(&mesh.edata, &result->edata, source_index, dest_index, count);
-      MEdge *me = &result->medge[dest_index];
+      MEdge *me = &dst_edges[dest_index];
       dest_index += count;
       for (; count--; me++) {
         me->v1 = vert_final[me->v1];
@@ -1448,7 +1449,7 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
                       &weld_mesh.edge_groups_buffer[wegrp->group.ofs],
                       wegrp->group.len,
                       dest_index);
-      MEdge *me = &result->medge[dest_index];
+      MEdge *me = &dst_edges[dest_index];
       me->v1 = vert_final[wegrp->v1];
       me->v2 = vert_final[wegrp->v2];
       /* "For now, assume that all merged edges are loose. This flag will be cleared in the
@@ -1464,13 +1465,13 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
 
   /* Polys/Loops. */
 
-  MPoly *r_mp = &result->mpoly[0];
-  MLoop *r_ml = &result->mloop[0];
+  MPoly *r_mp = dst_polys.data();
+  MLoop *r_ml = dst_loops.data();
   int r_i = 0;
   int loop_cur = 0;
   Array<int, 64> group_buffer(weld_mesh.max_poly_len);
-  for (const int i : mpoly.index_range()) {
-    const MPoly &mp = mpoly[i];
+  for (const int i : src_polys.index_range()) {
+    const MPoly &mp = src_polys[i];
     const int loop_start = loop_cur;
     const int poly_ctx = weld_mesh.poly_map[i];
     if (poly_ctx == OUT_OF_CONTEXT) {
@@ -1486,7 +1487,7 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
       const WeldPoly &wp = weld_mesh.wpoly[poly_ctx];
       WeldLoopOfPolyIter iter;
       if (!weld_iter_loop_of_poly_begin(
-              iter, wp, weld_mesh.wloop, mloop, weld_mesh.loop_map, group_buffer.data())) {
+              iter, wp, weld_mesh.wloop, src_loops, weld_mesh.loop_map, group_buffer.data())) {
         continue;
       }
 
@@ -1503,9 +1504,9 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
         r_ml++;
         loop_cur++;
         if (iter.type) {
-          result->medge[e].flag &= ~ME_LOOSEEDGE;
+          dst_edges[e].flag &= ~ME_LOOSEEDGE;
         }
-        BLI_assert((result->medge[e].flag & ME_LOOSEEDGE) == 0);
+        BLI_assert((dst_edges[e].flag & ME_LOOSEEDGE) == 0);
       }
     }
 
@@ -1522,7 +1523,7 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
     const int loop_start = loop_cur;
     WeldLoopOfPolyIter iter;
     if (!weld_iter_loop_of_poly_begin(
-            iter, wp, weld_mesh.wloop, mloop, weld_mesh.loop_map, group_buffer.data())) {
+            iter, wp, weld_mesh.wloop, src_loops, weld_mesh.loop_map, group_buffer.data())) {
       continue;
     }
 
@@ -1538,9 +1539,9 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
       r_ml++;
       loop_cur++;
       if (iter.type) {
-        result->medge[e].flag &= ~ME_LOOSEEDGE;
+        dst_edges[e].flag &= ~ME_LOOSEEDGE;
       }
-      BLI_assert((result->medge[e].flag & ME_LOOSEEDGE) == 0);
+      BLI_assert((dst_edges[e].flag & ME_LOOSEEDGE) == 0);
     }
 
     r_mp->loopstart = loop_start;
@@ -1569,8 +1570,9 @@ std::optional<Mesh *> mesh_merge_by_distance_all(const Mesh &mesh,
 
   KDTree_3d *tree = BLI_kdtree_3d_new(selection.size());
 
+  const Span<MVert> verts = mesh.vertices();
   for (const int i : selection) {
-    BLI_kdtree_3d_insert(tree, i, mesh.mvert[i].co);
+    BLI_kdtree_3d_insert(tree, i, verts[i].co);
   }
 
   BLI_kdtree_3d_balance(tree);
@@ -1595,8 +1597,8 @@ std::optional<Mesh *> mesh_merge_by_distance_connected(const Mesh &mesh,
                                                        const float merge_distance,
                                                        const bool only_loose_edges)
 {
-  Span<MVert> verts{mesh.mvert, mesh.totvert};
-  Span<MEdge> edges{mesh.medge, mesh.totedge};
+  const Span<MVert> verts = mesh.vertices();
+  const Span<MEdge> edges = mesh.edges();
 
   int vert_kill_len = 0;
 
diff --git a/source/blender/geometry/intern/mesh_primitive_cuboid.cc b/source/blender/geometry/intern/mesh_primitive_cuboid.cc
index 486d8adbf39..1e734a82e43 100644
--- a/source/blender/geometry/intern/mesh_primitive_cuboid.cc
+++ b/source/blender/geometry/intern/mesh_primitive_cuboid.cc
@@ -405,10 +405,13 @@ Mesh *create_cuboid_mesh(const float3 &size,
 
   Mesh *mesh = BKE_mesh_new_nomain(
       config.vertex_count, 0, 0, config.loop_count, config.poly_count);
+  MutableSpan<MVert> verts = mesh->vertices_for_write();
+  MutableSpan<MPoly> polys = mesh->polygons_for_write();
+  MutableSpan<MLoop> loops = mesh->loops_for_write();
 
-  calculate_vertices(config, {mesh->mvert, mesh->totvert});
+  calculate_vertices(config, verts);
 
-  calculate_polys(config, {mesh->mpoly, mesh->totpoly}, {mesh->mloop, mesh->totloop});
+  calculate_polys(config, polys, loops);
   BKE_mesh_calc_edges(mesh, false, false);
 
   if (uv_id) {
diff --git a/source/blender/geometry/intern/mesh_to_curve_convert.cc b/source/blender/geometry/intern/mesh_to_curve_convert.cc
index 350dfe73d57..1951c960d0d 100644
--- a/source/blender/geometry/intern/mesh_to_curve_convert.cc
+++ b/source/blender/geometry/intern/mesh_to_curve_convert.cc
@@ -12,6 +12,7 @@
 #include "BKE_attribute_math.hh"
 #include "BKE_curves.hh"
 #include "BKE_geometry_set.hh"
+#include "BKE_mesh.h"
 
 #include "GEO_mesh_to_curve.hh"
 
@@ -213,8 +214,9 @@ static CurveFromEdgesOutput edges_to_curve_point_indices(Span<MVert> verts,
 static Vector<std::pair<int, int>> get_selected_edges(const Mesh &mesh, const IndexMask selection)
 {
   Vector<std::pair<int, int>> selected_edges;
+  const Span<MEdge> edges = mesh.edges();
   for (const int i : selection) {
-    selected_edges.append({mesh.medge[i].v1, mesh.medge[i].v2});
+    selected_edges.append({edges[i].v1, edges[i].v2});
   }
   return selected_edges;
 }
@@ -222,8 +224,8 @@ static Vector<std::pair<int, int>> get_selected_edges(const Mesh &mesh, const In
 bke::CurvesGeometry mesh_to_curve_convert(const Mesh &mesh, const IndexMask selection)
 {
   Vector<std::pair<int, int>> selected_edges = get_selected_edges(mesh, selection);
-  CurveFromEdgesOutput output = edges_to_curve_point_indices({mesh.mvert, mesh.totvert},
-                                                             selected_edges);
+  const Span<MVert> verts = mesh.vertices();
+  CurveFromEdgesOutput output = edges_to_curve_point_indices(verts, selected_edges);
 
   return create_curve_from_vert_indices(
       mesh, output.vert_indices, output.curve_offsets, output.cyclic_curves);
diff --git a/source/blender/geometry/intern/mesh_to_volume.cc b/source/blender/geometry/intern/mesh_to_volume.cc
index ae98b048a6c..39078b1c511 100644
--- a/source/blender/geometry/intern/mesh_to_volume.cc
+++ b/source/blender/geometry/intern/mesh_to_volume.cc
@@ -1,5 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
 
+#include "BKE_mesh.h"
 #include "BKE_mesh_runtime.h"
 #include "BKE_volume.h"
 
@@ -29,7 +30,7 @@ class OpenVDBMeshAdapter {
 };
 
 OpenVDBMeshAdapter::OpenVDBMeshAdapter(const Mesh &mesh, float4x4 transform)
-    : vertices_(mesh.mvert, mesh.totvert), loops_(mesh.mloop, mesh.totloop), transform_(transform)
+    : vertices_(mesh.vertices()), loops_(mesh.loops()), transform_(transform)
 {
   /* This only updates a cache and can be considered to be logically const. */
   const MLoopTri *looptris = BKE_mesh_runtime_looptri_ensure(&mesh);
diff --git a/source/blender/geometry/intern/realize_instances.cc b/source/blender/geometry/intern/realize_instances.cc
index 25ff705385c..8d1c43866eb 100644
--- a/source/blender/geometry/intern/realize_instances.cc
+++ b/source/blender/geometry/intern/realize_instances.cc
@@ -97,6 +97,11 @@ struct MeshElementStartIndices {
 
 struct MeshRealizeInfo {
   const Mesh *mesh = nullptr;
+  Span<MVert> verts;
+  Span<MEdge> edges;
+  Span<MPoly> polys;
+  Span<MLoop> loops;
+
   /** Maps old material indices to new material indices. */
   Array<int> material_index_map;
   /** Matches the order in #AllMeshesInfo.attributes. */
@@ -859,6 +864,10 @@ static AllMeshesInfo preprocess_meshes(const GeometrySet &geometry_set,
     MeshRealizeInfo &mesh_info = info.realize_info[mesh_index];
     const Mesh *mesh = info.order[mesh_index];
     mesh_info.mesh = mesh;
+    mesh_info.verts = mesh->vertices();
+    mesh_info.edges = mesh->edges();
+    mesh_info.polys = mesh->polygons();
+    mesh_info.loops = mesh->loops();
 
     /* Create material index mapping. */
     mesh_info.material_index_map.reinitialize(std::max<int>(mesh->totcol, 1));
@@ -900,30 +909,31 @@ static AllMeshesInfo preprocess_meshes(const GeometrySet &geometry_set,
 static void execute_realize_mesh_task(const RealizeInstancesOptions &options,
                                       const RealizeMeshTask &task,
                                       const OrderedAttributes &ordered_attributes,
-                                      Mesh &dst_mesh,
                                       MutableSpan<GSpanAttributeWriter> dst_attribute_writers,
+                                      MutableSpan<MVert> all_dst_verts,
+                                      MutableSpan<MEdge> all_dst_edges,
+                                      MutableSpan<MPoly> all_dst_polys,
+                                      MutableSpan<MLoop> all_dst_loops,
                                       MutableSpan<int> all_dst_vertex_ids,
                                       MutableSpan<int> all_dst_material_indices)
 {
   const MeshRealizeInfo &mesh_info = *task.mesh_info;
   const Mesh &mesh = *mesh_info.mesh;
 
-  const Span<MVert> src_verts{mesh.mvert, mesh.totvert};
-  const Span<MEdge> src_edges{mesh.medge, mesh.totedge};
-  const Span<MLoop> src_loops{mesh.mloop, mesh.totloop};
-  const Span<MPoly> src_polys{mesh.mpoly, mesh.totpoly};
+  const Span<MVert> src_verts = mesh_info.verts;
+  const Span<MEdge> src_edges = mesh_info.edges;
+  const Span<MPoly> src_polys = mesh_info.polys;
+  const Span<MLoop> src_loops = mesh_info.loops;
 
   const IndexRange dst_vert_range(task.start_indices.vertex, src_verts.size());
   const IndexRange dst_edge_range(task.start_indices.edge, src_edges.size());
   const IndexRange dst_poly_range(task.start_indices.poly, src_polys.size());
   const IndexRange dst_loop_range(task.start_indices.loop, src_loops.size());
 
-  MutableSpan dst_verts = MutableSpan(dst_mesh.mvert, dst_mesh.totvert).slice(dst_vert_range);
-  MutableSpan dst_edges = MutableSpan(dst_mesh.medge, dst_mesh.totedge).slice(dst_edge_range);
-  MutableSpan dst_polys = MutableSpan(dst_mesh.mpoly, dst_mesh.totpoly).slice(dst_poly_range);
-  MutableSpan dst_loops = MutableSpan(dst_mesh.mloop, dst_mesh.totloop).slice(dst_loop_range);
-
-  const Span<int> material_index_map = mesh_info.material_index_map;
+  MutableSpan<MVert> dst_verts = all_dst_verts.slice(dst_vert_range);
+  MutableSpan<MEdge> dst_edges = all_dst_edges.slice(dst_edge_range);
+  MutableSpan<MPoly> dst_polys = all_dst_polys.slice(dst_poly_range);
+  MutableSpan<MLoop> dst_loops = all_dst_loops.slice(dst_loop_range);
 
   threading::parallel_for(src_verts.index_range(), 1024, [&](const IndexRange vert_range) {
     for (const int i : vert_range) {
@@ -960,6 +970,7 @@ static void execute_realize_mesh_task(const RealizeInstancesOptions &options,
     }
   });
   if (!all_dst_material_indices.is_empty()) {
+    const Span<int> material_index_map = mesh_info.material_index_map;
     MutableSpan<int> dst_material_indices = all_dst_material_indices.slice(dst_poly_range);
     if (mesh.totcol == 0) {
       /* The material index map contains the index of the null material in the result. */
@@ -1035,6 +1046,10 @@ static void execute_realize_mesh_tasks(const RealizeInstancesOptions &options,
   MeshComponent &dst_component = r_realized_geometry.get_component_for_write<MeshComponent>();
   dst_component.replace(dst_mesh);
   bke::MutableAttributeAccessor dst_attributes = bke::mesh_attributes_for_write(*dst_mesh);
+  MutableSpan<MVert> dst_verts = dst_mesh->vertices_for_write();
+  MutableSpan<MEdge> dst_edges = dst_mesh->edges_for_write();
+  MutableSpan<MPoly> dst_polys = dst_mesh->polygons_for_write();
+  MutableSpan<MLoop> dst_loops = dst_mesh->loops_for_write();
 
   /* Copy settings from the first input geometry set with a mesh. */
   const RealizeMeshTask &first_task = tasks.first();
@@ -1079,8 +1094,11 @@ static void execute_realize_mesh_tasks(const RealizeInstancesOptions &options,
       execute_realize_mesh_task(options,
                                 task,
                                 ordered_attributes,
-                                *dst_mesh,
                                 dst_attribute_writers,
+                                dst_verts,
+                                dst_edges,
+                                dst_polys,
+                                dst_loops,
                                 vertex_ids.span,
                                 material_indices.span);
     }