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

14 files changed, 227 insertions, 223 deletions

diff --git a/source/blender/io/alembic/exporter/abc_writer_hair.cc b/source/blender/io/alembic/exporter/abc_writer_hair.cc
index 99c609b0235..b06b973f764 100644
--- a/source/blender/io/alembic/exporter/abc_writer_hair.cc
+++ b/source/blender/io/alembic/exporter/abc_writer_hair.cc
@@ -120,9 +120,9 @@ void ABCHairWriter::write_hair_sample(const HierarchyContext &context,
   float inv_mat[4][4];
   invert_m4_m4_safe(inv_mat, context.object->obmat);
 
-  MTFace *mtface = mesh->mtface;
-  MFace *mface = mesh->mface;
-  MVert *mverts = mesh->mvert;
+  MTFace *mtface = (MTFace *)CustomData_get_layer(&mesh->fdata, CD_MTFACE);
+  MFace *mface = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
+  const MVert *mverts = BKE_mesh_vertices(mesh);
   const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(mesh);
 
   if ((!mtface || !mface) && !uv_warning_shown_) {
@@ -243,8 +243,9 @@ void ABCHairWriter::write_hair_child_sample(const HierarchyContext &context,
   float inv_mat[4][4];
   invert_m4_m4_safe(inv_mat, context.object->obmat);
 
-  MTFace *mtface = mesh->mtface;
-  MVert *mverts = mesh->mvert;
+  MFace *mface = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
+  MTFace *mtface = (MTFace *)CustomData_get_layer(&mesh->fdata, CD_MTFACE);
+  const MVert *mverts = BKE_mesh_vertices(mesh);
   const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(mesh);
 
   ParticleSystem *psys = context.particle_system;
@@ -269,7 +270,7 @@ void ABCHairWriter::write_hair_child_sample(const HierarchyContext &context,
         continue;
       }
 
-      MFace *face = &mesh->mface[num];
+      MFace *face = &mface[num];
       MTFace *tface = mtface + num;
 
       float r_uv[2], tmpnor[3], mapfw[4], vec[3];
diff --git a/source/blender/io/alembic/exporter/abc_writer_mesh.cc b/source/blender/io/alembic/exporter/abc_writer_mesh.cc
index 83f970d3965..acfa4c1ea08 100644
--- a/source/blender/io/alembic/exporter/abc_writer_mesh.cc
+++ b/source/blender/io/alembic/exporter/abc_writer_mesh.cc
@@ -176,8 +176,8 @@ void ABCGenericMeshWriter::do_write(HierarchyContext &context)
 
   m_custom_data_config.pack_uvs = args_.export_params->packuv;
   m_custom_data_config.mesh = mesh;
-  m_custom_data_config.mpoly = mesh->mpoly;
-  m_custom_data_config.mloop = mesh->mloop;
+  m_custom_data_config.mpoly = mesh->polygons_for_write().data();
+  m_custom_data_config.mloop = mesh->loops_for_write().data();
   m_custom_data_config.totpoly = mesh->totpoly;
   m_custom_data_config.totloop = mesh->totloop;
   m_custom_data_config.totvert = mesh->totvert;
@@ -436,8 +436,7 @@ static void get_vertices(struct Mesh *mesh, std::vector<Imath::V3f> &points)
   points.clear();
   points.resize(mesh->totvert);
 
-  MVert *verts = mesh->mvert;
-
+  const Span<MVert> verts = mesh->vertices();
   for (int i = 0, e = mesh->totvert; i < e; i++) {
     copy_yup_from_zup(points[i].getValue(), verts[i].co);
   }
@@ -448,25 +447,23 @@ static void get_topology(struct Mesh *mesh,
                          std::vector<int32_t> &loop_counts,
                          bool &r_has_flat_shaded_poly)
 {
-  const int num_poly = mesh->totpoly;
-  const int num_loops = mesh->totloop;
-  MLoop *mloop = mesh->mloop;
-  MPoly *mpoly = mesh->mpoly;
+  const Span<MPoly> polys = mesh->polygons();
+  const Span<MLoop> loops = mesh->loops();
   r_has_flat_shaded_poly = false;
 
   poly_verts.clear();
   loop_counts.clear();
-  poly_verts.reserve(num_loops);
-  loop_counts.reserve(num_poly);
+  poly_verts.reserve(loops.size());
+  loop_counts.reserve(polys.size());
 
   /* NOTE: data needs to be written in the reverse order. */
-  for (int i = 0; i < num_poly; i++) {
-    MPoly &poly = mpoly[i];
+  for (const int i : polys.index_range()) {
+    const MPoly &poly = polys[i];
     loop_counts.push_back(poly.totloop);
 
     r_has_flat_shaded_poly |= (poly.flag & ME_SMOOTH) == 0;
 
-    MLoop *loop = mloop + poly.loopstart + (poly.totloop - 1);
+    const MLoop *loop = &loops[poly.loopstart + (poly.totloop - 1)];
 
     for (int j = 0; j < poly.totloop; j++, loop--) {
       poly_verts.push_back(loop->v);
@@ -485,14 +482,14 @@ static void get_edge_creases(struct Mesh *mesh,
   lengths.clear();
   sharpnesses.clear();
 
-  MEdge *edge = mesh->medge;
+  const Span<MEdge> edges = mesh->edges();
 
-  for (int i = 0, e = mesh->totedge; i < e; i++) {
-    const float sharpness = static_cast<float>(edge[i].crease) * factor;
+  for (const int i : edges.index_range()) {
+    const float sharpness = static_cast<float>(edges[i].crease) * factor;
 
     if (sharpness != 0.0f) {
-      indices.push_back(edge[i].v1);
-      indices.push_back(edge[i].v2);
+      indices.push_back(edges[i].v1);
+      indices.push_back(edges[i].v2);
       sharpnesses.push_back(sharpness);
     }
   }
@@ -544,8 +541,10 @@ static void get_loop_normals(struct Mesh *mesh,
 
   /* NOTE: data needs to be written in the reverse order. */
   int abc_index = 0;
-  MPoly *mp = mesh->mpoly;
-  for (int i = 0, e = mesh->totpoly; i < e; i++, mp++) {
+  const Span<MPoly> polys = mesh->polygons();
+
+  for (const int i : polys.index_range()) {
+    const MPoly *mp = &polys[i];
     for (int j = mp->totloop - 1; j >= 0; j--, abc_index++) {
       int blender_index = mp->loopstart + j;
       copy_yup_from_zup(normals[abc_index].getValue(), lnors[blender_index]);
diff --git a/source/blender/io/alembic/intern/abc_reader_mesh.cc b/source/blender/io/alembic/intern/abc_reader_mesh.cc
index a4b6c32ef64..cb87ee78fcd 100644
--- a/source/blender/io/alembic/intern/abc_reader_mesh.cc
+++ b/source/blender/io/alembic/intern/abc_reader_mesh.cc
@@ -157,8 +157,9 @@ static void read_mverts(CDStreamConfig &config, const AbcMeshData &mesh_data)
 
 void read_mverts(Mesh &mesh, const P3fArraySamplePtr positions, const N3fArraySamplePtr normals)
 {
+  MutableSpan<MVert> verts = mesh.vertices_for_write();
   for (int i = 0; i < positions->size(); i++) {
-    MVert &mvert = mesh.mvert[i];
+    MVert &mvert = verts[i];
     Imath::V3f pos_in = (*positions)[i];
 
     copy_zup_from_yup(mvert.co, pos_in.getValue());
@@ -274,7 +275,7 @@ static void process_loop_normals(CDStreamConfig &config, const N3fArraySamplePtr
   float(*lnors)[3] = static_cast<float(*)[3]>(
       MEM_malloc_arrayN(loop_count, sizeof(float[3]), "ABC::FaceNormals"));
 
-  MPoly *mpoly = mesh->mpoly;
+  MPoly *mpoly = mesh->polygons_for_write().data();
   const N3fArraySample &loop_normals = *loop_normals_ptr;
   int abc_index = 0;
   for (int i = 0, e = mesh->totpoly; i < e; i++, mpoly++) {
@@ -519,13 +520,10 @@ static void read_mesh_sample(const std::string &iobject_full_name,
 CDStreamConfig get_config(Mesh *mesh, const bool use_vertex_interpolation)
 {
   CDStreamConfig config;
-
-  BLI_assert(mesh->mvert || mesh->totvert == 0);
-
   config.mesh = mesh;
-  config.mvert = mesh->mvert;
-  config.mloop = mesh->mloop;
-  config.mpoly = mesh->mpoly;
+  config.mvert = mesh->vertices_for_write().data();
+  config.mloop = mesh->loops_for_write().data();
+  config.mpoly = mesh->polygons_for_write().data();
   config.totvert = mesh->totvert;
   config.totloop = mesh->totloop;
   config.totpoly = mesh->totpoly;
@@ -925,12 +923,10 @@ static void read_edge_creases(Mesh *mesh,
     return;
   }
 
-  MEdge *edges = mesh->medge;
-  const int totedge = mesh->totedge;
-
-  EdgeHash *edge_hash = BLI_edgehash_new_ex(__func__, mesh->totedge);
+  MutableSpan<MEdge> edges = mesh->edges_for_write();
+  EdgeHash *edge_hash = BLI_edgehash_new_ex(__func__, edges.size());
 
-  for (int i = 0; i < totedge; i++) {
+  for (const int i : edges.index_range()) {
     MEdge *edge = &edges[i];
     BLI_edgehash_insert(edge_hash, edge->v1, edge->v2, edge);
   }
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;
diff --git a/source/blender/io/stl/importer/stl_import_mesh.cc b/source/blender/io/stl/importer/stl_import_mesh.cc
index 178b5b9347f..d85185ede6e 100644
--- a/source/blender/io/stl/importer/stl_import_mesh.cc
+++ b/source/blender/io/stl/importer/stl_import_mesh.cc
@@ -76,27 +76,26 @@ Mesh *STLMeshHelper::to_mesh(Main *bmain, char *mesh_name)
   id_us_min(&mesh->id);
 
   mesh->totvert = verts_.size();
-  mesh->mvert = static_cast<MVert *>(
-      CustomData_add_layer(&mesh->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, mesh->totvert));
+  CustomData_add_layer(&mesh->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, mesh->totvert);
+  MutableSpan<MVert> verts = mesh->vertices_for_write();
   for (int i = 0; i < mesh->totvert; i++) {
-    copy_v3_v3(mesh->mvert[i].co, verts_[i]);
+    copy_v3_v3(verts[i].co, verts_[i]);
   }
 
   mesh->totpoly = tris_.size();
   mesh->totloop = tris_.size() * 3;
-  mesh->mpoly = static_cast<MPoly *>(
-      CustomData_add_layer(&mesh->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, mesh->totpoly));
-  mesh->mloop = static_cast<MLoop *>(
-      CustomData_add_layer(&mesh->ldata, CD_MLOOP, CD_CONSTRUCT, nullptr, mesh->totloop));
-
+  CustomData_add_layer(&mesh->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, mesh->totpoly);
+  CustomData_add_layer(&mesh->ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, mesh->totloop);
+  MutableSpan<MPoly> polys = mesh->polygons_for_write();
+  MutableSpan<MLoop> loops = mesh->loops_for_write();
   threading::parallel_for(tris_.index_range(), 2048, [&](IndexRange tris_range) {
     for (const int i : tris_range) {
-      mesh->mpoly[i].loopstart = 3 * i;
-      mesh->mpoly[i].totloop = 3;
+      polys[i].loopstart = 3 * i;
+      polys[i].totloop = 3;
 
-      mesh->mloop[3 * i].v = tris_[i].v1;
-      mesh->mloop[3 * i + 1].v = tris_[i].v2;
-      mesh->mloop[3 * i + 2].v = tris_[i].v3;
+      loops[3 * i].v = tris_[i].v1;
+      loops[3 * i + 1].v = tris_[i].v2;
+      loops[3 * i + 2].v = tris_[i].v3;
     }
   });
 
diff --git a/source/blender/io/usd/intern/usd_reader_mesh.cc b/source/blender/io/usd/intern/usd_reader_mesh.cc
index 4155f6ac40f..86e3aeece5d 100644
--- a/source/blender/io/usd/intern/usd_reader_mesh.cc
+++ b/source/blender/io/usd/intern/usd_reader_mesh.cc
@@ -312,15 +312,15 @@ bool USDMeshReader::topology_changed(const Mesh *existing_mesh, const double mot
 
 void USDMeshReader::read_mpolys(Mesh *mesh)
 {
-  MPoly *mpolys = mesh->mpoly;
-  MLoop *mloops = mesh->mloop;
+  MutableSpan<MPoly> polys = mesh->polygons_for_write();
+  MutableSpan<MLoop> loops = mesh->loops_for_write();
 
   int loop_index = 0;
 
   for (int i = 0; i < face_counts_.size(); i++) {
     const int face_size = face_counts_[i];
 
-    MPoly &poly = mpolys[i];
+    MPoly &poly = polys[i];
     poly.loopstart = loop_index;
     poly.totloop = face_size;
 
@@ -331,12 +331,12 @@ void USDMeshReader::read_mpolys(Mesh *mesh)
     if (is_left_handed_) {
       int loop_end_index = loop_index + (face_size - 1);
       for (int f = 0; f < face_size; ++f, ++loop_index) {
-        mloops[loop_index].v = face_indices_[loop_end_index - f];
+        loops[loop_index].v = face_indices_[loop_end_index - f];
       }
     }
     else {
       for (int f = 0; f < face_size; ++f, ++loop_index) {
-        mloops[loop_index].v = face_indices_[loop_index];
+        loops[loop_index].v = face_indices_[loop_index];
       }
     }
   }
@@ -400,6 +400,7 @@ void USDMeshReader::read_uvs(Mesh *mesh, const double motionSampleTime, const bo
     }
   }
 
+  const Span<MLoop> loops = mesh->loops();
   for (int i = 0; i < face_counts_.size(); i++) {
     const int face_size = face_counts_[i];
 
@@ -435,7 +436,7 @@ void USDMeshReader::read_uvs(Mesh *mesh, const double motionSampleTime, const bo
 
         /* For Vertex interpolation, use the vertex index. */
         int usd_uv_index = sample.interpolation == pxr::UsdGeomTokens->vertex ?
-                               mesh->mloop[loop_index].v :
+                               loops[loop_index].v :
                                loop_index;
 
         if (usd_uv_index >= sample.uvs.size()) {
@@ -515,24 +516,23 @@ void USDMeshReader::read_colors(Mesh *mesh, const double motionSampleTime)
 
   MLoopCol *colors = static_cast<MLoopCol *>(cd_ptr);
 
-  mesh->mloopcol = colors;
-
-  MPoly *poly = mesh->mpoly;
-
-  for (int i = 0, e = mesh->totpoly; i < e; ++i, ++poly) {
-    for (int j = 0; j < poly->totloop; ++j) {
-      int loop_index = poly->loopstart + j;
+  const Span<MPoly> polys = mesh->polygons();
+  const Span<MLoop> loops = mesh->loops();
+  for (const int i : polys.index_range()) {
+    const MPoly &poly = polys[i];
+    for (int j = 0; j < poly.totloop; ++j) {
+      int loop_index = poly.loopstart + j;
 
       /* Default for constant varying interpolation. */
       int usd_index = 0;
 
       if (interp == pxr::UsdGeomTokens->vertex) {
-        usd_index = mesh->mloop[loop_index].v;
+        usd_index = loops[loop_index].v;
       }
       else if (interp == pxr::UsdGeomTokens->faceVarying) {
-        usd_index = poly->loopstart;
+        usd_index = poly.loopstart;
         if (is_left_handed_) {
-          usd_index += poly->totloop - 1 - j;
+          usd_index += poly.totloop - 1 - j;
         }
         else {
           usd_index += j;
@@ -630,15 +630,15 @@ void USDMeshReader::process_normals_face_varying(Mesh *mesh)
   float(*lnors)[3] = static_cast<float(*)[3]>(
       MEM_malloc_arrayN(loop_count, sizeof(float[3]), "USD::FaceNormals"));
 
-  MPoly *mpoly = mesh->mpoly;
-
-  for (int i = 0, e = mesh->totpoly; i < e; ++i, ++mpoly) {
-    for (int j = 0; j < mpoly->totloop; j++) {
-      int blender_index = mpoly->loopstart + j;
+  const Span<MPoly> polys = mesh->polygons();
+  for (const int i : polys.index_range()) {
+    const MPoly &poly = polys[i];
+    for (int j = 0; j < poly.totloop; j++) {
+      int blender_index = poly.loopstart + j;
 
-      int usd_index = mpoly->loopstart;
+      int usd_index = poly.loopstart;
       if (is_left_handed_) {
-        usd_index += mpoly->totloop - 1 - j;
+        usd_index += poly.totloop - 1 - j;
       }
       else {
         usd_index += j;
@@ -671,12 +671,11 @@ void USDMeshReader::process_normals_uniform(Mesh *mesh)
   float(*lnors)[3] = static_cast<float(*)[3]>(
       MEM_malloc_arrayN(mesh->totloop, sizeof(float[3]), "USD::FaceNormals"));
 
-  MPoly *mpoly = mesh->mpoly;
-
-  for (int i = 0, e = mesh->totpoly; i < e; ++i, ++mpoly) {
-
-    for (int j = 0; j < mpoly->totloop; j++) {
-      int loop_index = mpoly->loopstart + j;
+  const Span<MPoly> polys = mesh->polygons();
+  for (const int i : polys.index_range()) {
+    const MPoly &poly = polys[i];
+    for (int j = 0; j < poly.totloop; j++) {
+      int loop_index = poly.loopstart + j;
       lnors[loop_index][0] = normals_[i][0];
       lnors[loop_index][1] = normals_[i][1];
       lnors[loop_index][2] = normals_[i][2];
@@ -699,8 +698,9 @@ void USDMeshReader::read_mesh_sample(ImportSettings *settings,
    * in code that expect this data to be there. */
 
   if (new_mesh || (settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) {
+    MutableSpan<MVert> verts = mesh->vertices_for_write();
     for (int i = 0; i < positions_.size(); i++) {
-      MVert &mvert = mesh->mvert[i];
+      MVert &mvert = verts[i];
       mvert.co[0] = positions_[i][0];
       mvert.co[1] = positions_[i][1];
       mvert.co[2] = positions_[i][2];
@@ -903,8 +903,7 @@ Mesh *USDMeshReader::read_mesh(Mesh *existing_mesh,
         existing_mesh, positions_.size(), 0, 0, face_indices_.size(), face_counts_.size());
 
     for (pxr::TfToken token : uv_tokens) {
-      void *cd_ptr = add_customdata_cb(active_mesh, token.GetText(), CD_MLOOPUV);
-      active_mesh->mloopuv = static_cast<MLoopUV *>(cd_ptr);
+      add_customdata_cb(active_mesh, token.GetText(), CD_MLOOPUV);
     }
   }
 
@@ -914,8 +913,8 @@ Mesh *USDMeshReader::read_mesh(Mesh *existing_mesh,
     /* Here we assume that the number of materials doesn't change, i.e. that
      * the material slots that were created when the object was loaded from
      * USD are still valid now. */
-    size_t num_polys = active_mesh->totpoly;
-    if (num_polys > 0 && import_params_.import_materials) {
+    MutableSpan<MPoly> polys = active_mesh->polygons_for_write();
+    if (!polys.is_empty() && import_params_.import_materials) {
       std::map<pxr::SdfPath, int> mat_map;
       bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*active_mesh);
       bke::SpanAttributeWriter<int> material_indices =
diff --git a/source/blender/io/usd/intern/usd_reader_mesh.h b/source/blender/io/usd/intern/usd_reader_mesh.h
index 9a3b0565668..181fd5ebf79 100644
--- a/source/blender/io/usd/intern/usd_reader_mesh.h
+++ b/source/blender/io/usd/intern/usd_reader_mesh.h
@@ -10,8 +10,6 @@
 
 #include "pxr/usd/usdGeom/mesh.h"
 
-struct MPoly;
-
 namespace blender::io::usd {
 
 class USDMeshReader : public USDGeomReader {
diff --git a/source/blender/io/usd/intern/usd_writer_mesh.cc b/source/blender/io/usd/intern/usd_writer_mesh.cc
index ade75fdb365..f6250eebd5d 100644
--- a/source/blender/io/usd/intern/usd_writer_mesh.cc
+++ b/source/blender/io/usd/intern/usd_writer_mesh.cc
@@ -246,8 +246,8 @@ static void get_vertices(const Mesh *mesh, USDMeshData &usd_mesh_data)
 {
   usd_mesh_data.points.reserve(mesh->totvert);
 
-  const MVert *verts = mesh->mvert;
-  for (int i = 0; i < mesh->totvert; ++i) {
+  const Span<MVert> verts = mesh->vertices();
+  for (const int i : verts.index_range()) {
     usd_mesh_data.points.push_back(pxr::GfVec3f(verts[i].co));
   }
 }
@@ -269,13 +269,14 @@ static void get_loops_polys(const Mesh *mesh, USDMeshData &usd_mesh_data)
   usd_mesh_data.face_vertex_counts.reserve(mesh->totpoly);
   usd_mesh_data.face_indices.reserve(mesh->totloop);
 
-  MLoop *mloop = mesh->mloop;
-  MPoly *mpoly = mesh->mpoly;
-  for (int i = 0; i < mesh->totpoly; ++i, ++mpoly) {
-    MLoop *loop = mloop + mpoly->loopstart;
-    usd_mesh_data.face_vertex_counts.push_back(mpoly->totloop);
-    for (int j = 0; j < mpoly->totloop; ++j, ++loop) {
-      usd_mesh_data.face_indices.push_back(loop->v);
+  const Span<MPoly> polys = mesh->polygons();
+  const Span<MLoop> loops = mesh->loops();
+
+  for (const int i : polys.index_range()) {
+    const MPoly &poly = polys[i];
+    usd_mesh_data.face_vertex_counts.push_back(poly.totloop);
+    for (const MLoop &loop : loops.slice(poly.loopstart, poly.totloop)) {
+      usd_mesh_data.face_indices.push_back(loop.v);
     }
   }
 }
@@ -284,22 +285,23 @@ static void get_edge_creases(const Mesh *mesh, USDMeshData &usd_mesh_data)
 {
   const float factor = 1.0f / 255.0f;
 
-  MEdge *edge = mesh->medge;
+  const Span<MEdge> edges = mesh->edges();
   float sharpness;
-  for (int edge_idx = 0, totedge = mesh->totedge; edge_idx < totedge; ++edge_idx, ++edge) {
-    if (edge->crease == 0) {
+  for (const int i : edges.index_range()) {
+    const MEdge &edge = edges[i];
+    if (edge.crease == 0) {
       continue;
     }
 
-    if (edge->crease == 255) {
+    if (edge.crease == 255) {
       sharpness = pxr::UsdGeomMesh::SHARPNESS_INFINITE;
     }
     else {
-      sharpness = static_cast<float>(edge->crease) * factor;
+      sharpness = static_cast<float>(edge.crease) * factor;
     }
 
-    usd_mesh_data.crease_vertex_indices.push_back(edge->v1);
-    usd_mesh_data.crease_vertex_indices.push_back(edge->v2);
+    usd_mesh_data.crease_vertex_indices.push_back(edge.v1);
+    usd_mesh_data.crease_vertex_indices.push_back(edge.v2);
     usd_mesh_data.crease_lengths.push_back(2);
     usd_mesh_data.crease_sharpnesses.push_back(sharpness);
   }
@@ -397,6 +399,8 @@ void USDGenericMeshWriter::write_normals(const Mesh *mesh, pxr::UsdGeomMesh usd_
 {
   pxr::UsdTimeCode timecode = get_export_time_code();
   const float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&mesh->ldata, CD_NORMAL));
+  const Span<MPoly> polys = mesh->polygons();
+  const Span<MLoop> loops = mesh->loops();
 
   pxr::VtVec3fArray loop_normals;
   loop_normals.reserve(mesh->totloop);
@@ -411,21 +415,20 @@ void USDGenericMeshWriter::write_normals(const Mesh *mesh, pxr::UsdGeomMesh usd_
     /* Compute the loop normals based on the 'smooth' flag. */
     const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(mesh);
     const float(*face_normals)[3] = BKE_mesh_poly_normals_ensure(mesh);
-    MPoly *mpoly = mesh->mpoly;
-    for (int poly_idx = 0, totpoly = mesh->totpoly; poly_idx < totpoly; ++poly_idx, ++mpoly) {
-      MLoop *mloop = mesh->mloop + mpoly->loopstart;
+    for (const int i : polys.index_range()) {
+      const MPoly &poly = polys[i];
 
-      if ((mpoly->flag & ME_SMOOTH) == 0) {
+      if ((poly.flag & ME_SMOOTH) == 0) {
         /* Flat shaded, use common normal for all verts. */
-        pxr::GfVec3f pxr_normal(face_normals[poly_idx]);
-        for (int loop_idx = 0; loop_idx < mpoly->totloop; ++loop_idx) {
+        pxr::GfVec3f pxr_normal(face_normals[i]);
+        for (int loop_idx = 0; loop_idx < poly.totloop; ++loop_idx) {
           loop_normals.push_back(pxr_normal);
         }
       }
       else {
         /* Smooth shaded, use individual vert normals. */
-        for (int loop_idx = 0; loop_idx < mpoly->totloop; ++loop_idx, ++mloop) {
-          loop_normals.push_back(pxr::GfVec3f(vert_normals[mloop->v]));
+        for (const MLoop &loop : loops.slice(poly.loopstart, poly.totloop)) {
+          loop_normals.push_back(pxr::GfVec3f(vert_normals[loop.v]));
         }
       }
     }
diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
index a888c6d11a2..272afe4a843 100644
--- a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
+++ b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
@@ -188,12 +188,15 @@ void OBJMesh::ensure_mesh_edges() const
 
 void OBJMesh::calc_smooth_groups(const bool use_bitflags)
 {
-  poly_smooth_groups_ = BKE_mesh_calc_smoothgroups(export_mesh_eval_->medge,
-                                                   export_mesh_eval_->totedge,
-                                                   export_mesh_eval_->mpoly,
-                                                   export_mesh_eval_->totpoly,
-                                                   export_mesh_eval_->mloop,
-                                                   export_mesh_eval_->totloop,
+  const Span<MEdge> edges = export_mesh_eval_->edges();
+  const Span<MPoly> polys = export_mesh_eval_->polygons();
+  const Span<MLoop> loops = export_mesh_eval_->loops();
+  poly_smooth_groups_ = BKE_mesh_calc_smoothgroups(edges.data(),
+                                                   edges.size(),
+                                                   polys.data(),
+                                                   polys.size(),
+                                                   loops.data(),
+                                                   loops.size(),
                                                    &tot_smooth_groups_,
                                                    use_bitflags);
 }
@@ -239,7 +242,8 @@ const Material *OBJMesh::get_object_material(const int16_t mat_nr) const
 
 bool OBJMesh::is_ith_poly_smooth(const int poly_index) const
 {
-  return export_mesh_eval_->mpoly[poly_index].flag & ME_SMOOTH;
+  const Span<MPoly> polygons = export_mesh_eval_->polygons();
+  return polygons[poly_index].flag & ME_SMOOTH;
 }
 
 const char *OBJMesh::get_object_name() const
@@ -264,7 +268,8 @@ const char *OBJMesh::get_object_material_name(const int16_t mat_nr) const
 float3 OBJMesh::calc_vertex_coords(const int vert_index, const float scaling_factor) const
 {
   float3 r_coords;
-  copy_v3_v3(r_coords, export_mesh_eval_->mvert[vert_index].co);
+  const Span<MVert> verts = export_mesh_eval_->vertices();
+  copy_v3_v3(r_coords, verts[vert_index].co);
   mul_m4_v3(world_and_axes_transform_, r_coords);
   mul_v3_fl(r_coords, scaling_factor);
   return r_coords;
@@ -272,8 +277,10 @@ float3 OBJMesh::calc_vertex_coords(const int vert_index, const float scaling_fac
 
 Vector<int> OBJMesh::calc_poly_vertex_indices(const int poly_index) const
 {
-  const MPoly &mpoly = export_mesh_eval_->mpoly[poly_index];
-  const MLoop *mloop = &export_mesh_eval_->mloop[mpoly.loopstart];
+  const Span<MPoly> polys = export_mesh_eval_->polygons();
+  const Span<MLoop> loops = export_mesh_eval_->loops();
+  const MPoly &mpoly = polys[poly_index];
+  const MLoop *mloop = &loops[mpoly.loopstart];
   const int totloop = mpoly.totloop;
   Vector<int> r_poly_vertex_indices(totloop);
   for (int loop_index = 0; loop_index < totloop; loop_index++) {
@@ -284,9 +291,8 @@ Vector<int> OBJMesh::calc_poly_vertex_indices(const int poly_index) const
 
 void OBJMesh::store_uv_coords_and_indices()
 {
-  const MPoly *mpoly = export_mesh_eval_->mpoly;
-  const MLoop *mloop = export_mesh_eval_->mloop;
-  const int totpoly = export_mesh_eval_->totpoly;
+  const Span<MPoly> polys = export_mesh_eval_->polygons();
+  const Span<MLoop> loops = export_mesh_eval_->loops();
   const int totvert = export_mesh_eval_->totvert;
   const MLoopUV *mloopuv = static_cast<const MLoopUV *>(
       CustomData_get_layer(&export_mesh_eval_->ldata, CD_MLOOPUV));
@@ -297,9 +303,9 @@ void OBJMesh::store_uv_coords_and_indices()
   const float limit[2] = {STD_UV_CONNECT_LIMIT, STD_UV_CONNECT_LIMIT};
 
   UvVertMap *uv_vert_map = BKE_mesh_uv_vert_map_create(
-      mpoly, nullptr, mloop, mloopuv, totpoly, totvert, limit, false, false);
+      polys.data(), nullptr, loops.data(), mloopuv, polys.size(), totvert, limit, false, false);
 
-  uv_indices_.resize(totpoly);
+  uv_indices_.resize(polys.size());
   /* At least total vertices of a mesh will be present in its texture map. So
    * reserve minimum space early. */
   uv_coords_.reserve(totvert);
@@ -311,11 +317,11 @@ void OBJMesh::store_uv_coords_and_indices()
       if (uv_vert->separate) {
         tot_uv_vertices_ += 1;
       }
-      const int vertices_in_poly = mpoly[uv_vert->poly_index].totloop;
+      const int vertices_in_poly = polys[uv_vert->poly_index].totloop;
 
       /* Store UV vertex coordinates. */
       uv_coords_.resize(tot_uv_vertices_);
-      const int loopstart = mpoly[uv_vert->poly_index].loopstart;
+      const int loopstart = polys[uv_vert->poly_index].loopstart;
       Span<float> vert_uv_coords(mloopuv[loopstart + uv_vert->loop_of_poly_index].uv, 2);
       uv_coords_[tot_uv_vertices_ - 1] = float2(vert_uv_coords[0], vert_uv_coords[1]);
 
@@ -341,10 +347,11 @@ Span<int> OBJMesh::calc_poly_uv_indices(const int poly_index) const
 float3 OBJMesh::calc_poly_normal(const int poly_index) const
 {
   float3 r_poly_normal;
-  const MPoly &poly = export_mesh_eval_->mpoly[poly_index];
-  const MLoop &mloop = export_mesh_eval_->mloop[poly.loopstart];
-  const MVert &mvert = *(export_mesh_eval_->mvert);
-  BKE_mesh_calc_poly_normal(&poly, &mloop, &mvert, r_poly_normal);
+  const Span<MVert> verts = export_mesh_eval_->vertices();
+  const Span<MPoly> polys = export_mesh_eval_->polygons();
+  const Span<MLoop> loops = export_mesh_eval_->loops();
+  const MPoly &poly = polys[poly_index];
+  BKE_mesh_calc_poly_normal(&poly, &loops[poly.loopstart], verts.data(), r_poly_normal);
   mul_m3_v3(world_and_axes_normal_transform_, r_poly_normal);
   normalize_v3(r_poly_normal);
   return r_poly_normal;
@@ -368,6 +375,8 @@ static float3 round_float3_to_n_digits(const float3 &v, int round_digits)
 
 void OBJMesh::store_normal_coords_and_indices()
 {
+  const Span<MPoly> polys = export_mesh_eval_->polygons();
+
   /* We'll round normal components to 4 digits.
    * This will cover up some minor differences
    * between floating point calculations on different platforms.
@@ -383,7 +392,7 @@ void OBJMesh::store_normal_coords_and_indices()
   const float(*lnors)[3] = static_cast<const float(*)[3]>(
       CustomData_get_layer(&export_mesh_eval_->ldata, CD_NORMAL));
   for (int poly_index = 0; poly_index < export_mesh_eval_->totpoly; ++poly_index) {
-    const MPoly &mpoly = export_mesh_eval_->mpoly[poly_index];
+    const MPoly &mpoly = polys[poly_index];
     bool need_per_loop_normals = lnors != nullptr || (mpoly.flag & ME_SMOOTH);
     if (need_per_loop_normals) {
       for (int loop_of_poly = 0; loop_of_poly < mpoly.totloop; ++loop_of_poly) {
@@ -427,7 +436,8 @@ Vector<int> OBJMesh::calc_poly_normal_indices(const int poly_index) const
   if (loop_to_normal_index_.is_empty()) {
     return {};
   }
-  const MPoly &mpoly = export_mesh_eval_->mpoly[poly_index];
+  const Span<MPoly> polys = export_mesh_eval_->polygons();
+  const MPoly &mpoly = polys[poly_index];
   const int totloop = mpoly.totloop;
   Vector<int> r_poly_normal_indices(totloop);
   for (int poly_loop_index = 0; poly_loop_index < totloop; poly_loop_index++) {
@@ -450,23 +460,23 @@ int16_t OBJMesh::get_poly_deform_group_index(const int poly_index,
 {
   BLI_assert(poly_index < export_mesh_eval_->totpoly);
   BLI_assert(group_weights.size() == BKE_object_defgroup_count(&export_object_eval_));
-
-  const MDeformVert *dvert_layer = static_cast<const MDeformVert *>(
-      CustomData_get_layer(&export_mesh_eval_->vdata, CD_MDEFORMVERT));
-  if (!dvert_layer) {
+  const Span<MPoly> polys = export_mesh_eval_->polygons();
+  const Span<MLoop> loops = export_mesh_eval_->loops();
+  const Span<MDeformVert> dverts = export_mesh_eval_->deform_verts();
+  if (dverts.is_empty()) {
     return NOT_FOUND;
   }
 
   group_weights.fill(0);
   bool found_any_group = false;
-  const MPoly &mpoly = export_mesh_eval_->mpoly[poly_index];
-  const MLoop *mloop = &export_mesh_eval_->mloop[mpoly.loopstart];
+  const MPoly &mpoly = polys[poly_index];
+  const MLoop *mloop = &loops[mpoly.loopstart];
   for (int loop_i = 0; loop_i < mpoly.totloop; ++loop_i, ++mloop) {
-    const MDeformVert &dvert = dvert_layer[mloop->v];
-    for (int weight_i = 0; weight_i < dvert.totweight; ++weight_i) {
-      const auto group = dvert.dw[weight_i].def_nr;
+    const MDeformVert &dv = dverts[mloop->v];
+    for (int weight_i = 0; weight_i < dv.totweight; ++weight_i) {
+      const auto group = dv.dw[weight_i].def_nr;
       if (group < group_weights.size()) {
-        group_weights[group] += dvert.dw[weight_i].weight;
+        group_weights[group] += dv.dw[weight_i].weight;
         found_any_group = true;
       }
     }
@@ -490,7 +500,8 @@ const char *OBJMesh::get_poly_deform_group_name(const int16_t def_group_index) c
 
 std::optional<std::array<int, 2>> OBJMesh::calc_loose_edge_vert_indices(const int edge_index) const
 {
-  const MEdge &edge = export_mesh_eval_->medge[edge_index];
+  const Span<MEdge> edges = export_mesh_eval_->edges();
+  const MEdge &edge = edges[edge_index];
   if (edge.flag & ME_LOOSEEDGE) {
     return std::array<int, 2>{static_cast<int>(edge.v1), static_cast<int>(edge.v2)};
   }
diff --git a/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc b/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
index e01b64d7885..4b4609c053b 100644
--- a/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
+++ b/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
@@ -158,6 +158,7 @@ void MeshFromGeometry::fixup_invalid_faces()
 
 void MeshFromGeometry::create_vertices(Mesh *mesh)
 {
+  MutableSpan<MVert> verts = mesh->vertices_for_write();
   /* Go through all the global vertex indices from min to max,
    * checking which ones are actually and building a global->local
    * index mapping. Write out the used vertex positions into the Mesh
@@ -171,20 +172,21 @@ void MeshFromGeometry::create_vertices(Mesh *mesh)
     }
     int local_vi = (int)mesh_geometry_.global_to_local_vertices_.size();
     BLI_assert(local_vi >= 0 && local_vi < mesh->totvert);
-    copy_v3_v3(mesh->mvert[local_vi].co, global_vertices_.vertices[vi]);
+    copy_v3_v3(verts[local_vi].co, global_vertices_.vertices[vi]);
     mesh_geometry_.global_to_local_vertices_.add_new(vi, local_vi);
   }
 }
 
 void MeshFromGeometry::create_polys_loops(Mesh *mesh, bool use_vertex_groups)
 {
-  mesh->dvert = nullptr;
+  MutableSpan<MDeformVert> dverts;
   const int64_t total_verts = mesh_geometry_.get_vertex_count();
   if (use_vertex_groups && total_verts && mesh_geometry_.has_vertex_groups_) {
-    mesh->dvert = static_cast<MDeformVert *>(
-        CustomData_add_layer(&mesh->vdata, CD_MDEFORMVERT, CD_SET_DEFAULT, nullptr, total_verts));
+    dverts = mesh->deform_verts_for_write();
   }
 
+  MutableSpan<MPoly> polys = mesh->polygons_for_write();
+  MutableSpan<MLoop> loops = mesh->loops_for_write();
   bke::SpanAttributeWriter<int> material_indices =
       bke::mesh_attributes_for_write(*mesh).lookup_or_add_for_write_only_span<int>(
           "material_index", ATTR_DOMAIN_FACE);
@@ -200,7 +202,7 @@ void MeshFromGeometry::create_polys_loops(Mesh *mesh, bool use_vertex_groups)
       continue;
     }
 
-    MPoly &mpoly = mesh->mpoly[poly_idx];
+    MPoly &mpoly = polys[poly_idx];
     mpoly.totloop = curr_face.corner_count_;
     mpoly.loopstart = tot_loop_idx;
     if (curr_face.shaded_smooth) {
@@ -215,16 +217,16 @@ void MeshFromGeometry::create_polys_loops(Mesh *mesh, bool use_vertex_groups)
 
     for (int idx = 0; idx < curr_face.corner_count_; ++idx) {
       const PolyCorner &curr_corner = mesh_geometry_.face_corners_[curr_face.start_index_ + idx];
-      MLoop &mloop = mesh->mloop[tot_loop_idx];
+      MLoop &mloop = loops[tot_loop_idx];
       tot_loop_idx++;
       mloop.v = mesh_geometry_.global_to_local_vertices_.lookup_default(curr_corner.vert_index, 0);
 
       /* Setup vertex group data, if needed. */
-      if (!mesh->dvert) {
+      if (dverts.is_empty()) {
         continue;
       }
       const int group_index = curr_face.vertex_group_index;
-      MDeformWeight *dw = BKE_defvert_ensure_index(mesh->dvert + mloop.v, group_index);
+      MDeformWeight *dw = BKE_defvert_ensure_index(&dverts[mloop.v], group_index);
       dw->weight = 1.0f;
     }
   }
@@ -235,7 +237,7 @@ void MeshFromGeometry::create_polys_loops(Mesh *mesh, bool use_vertex_groups)
 void MeshFromGeometry::create_vertex_groups(Object *obj)
 {
   Mesh *mesh = static_cast<Mesh *>(obj->data);
-  if (mesh->dvert == nullptr) {
+  if (mesh->deform_verts().is_empty()) {
     return;
   }
   for (const std::string &name : mesh_geometry_.group_order_) {
@@ -245,12 +247,14 @@ void MeshFromGeometry::create_vertex_groups(Object *obj)
 
 void MeshFromGeometry::create_edges(Mesh *mesh)
 {
+  MutableSpan<MEdge> edges = mesh->edges_for_write();
+
   const int64_t tot_edges{mesh_geometry_.edges_.size()};
   const int64_t total_verts{mesh_geometry_.get_vertex_count()};
   UNUSED_VARS_NDEBUG(total_verts);
   for (int i = 0; i < tot_edges; ++i) {
     const MEdge &src_edge = mesh_geometry_.edges_[i];
-    MEdge &dst_edge = mesh->medge[i];
+    MEdge &dst_edge = edges[i];
     dst_edge.v1 = mesh_geometry_.global_to_local_vertices_.lookup_default(src_edge.v1, 0);
     dst_edge.v2 = mesh_geometry_.global_to_local_vertices_.lookup_default(src_edge.v2, 0);
     BLI_assert(dst_edge.v1 < total_verts && dst_edge.v2 < total_verts);
diff --git a/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc b/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc
index 35f977f41df..669a7ba80cf 100644
--- a/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc
+++ b/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc
@@ -8,6 +8,7 @@
 #include "BKE_curve.h"
 #include "BKE_customdata.h"
 #include "BKE_main.h"
+#include "BKE_mesh.h"
 #include "BKE_object.h"
 #include "BKE_scene.h"
 
@@ -95,8 +96,9 @@ class obj_importer_test : public BlendfileLoadingBaseTest {
         EXPECT_EQ(mesh->totedge, exp.mesh_totedge_or_curve_endp);
         EXPECT_EQ(mesh->totpoly, exp.mesh_totpoly_or_curve_order);
         EXPECT_EQ(mesh->totloop, exp.mesh_totloop_or_curve_cyclic);
-        EXPECT_V3_NEAR(mesh->mvert[0].co, exp.vert_first, 0.0001f);
-        EXPECT_V3_NEAR(mesh->mvert[mesh->totvert - 1].co, exp.vert_last, 0.0001f);
+        const Span<MVert> verts = mesh->vertices();
+        EXPECT_V3_NEAR(verts.first().co, exp.vert_first, 0.0001f);
+        EXPECT_V3_NEAR(verts.last().co, exp.vert_last, 0.0001f);
         const float3 *lnors = (const float3 *)(CustomData_get_layer(&mesh->ldata, CD_NORMAL));
         float3 normal_first = lnors != nullptr ? lnors[0] : float3(0, 0, 0);
         EXPECT_V3_NEAR(normal_first, exp.normal_first, 0.0001f);