Mesh: Move runtime data out of DNA

This commit replaces the `Mesh_Runtime` struct embedded in `Mesh`
with `blender::bke::MeshRuntime`. This has quite a few benefits:
- It's possible to use C++ types like `std::mutex`, `Array`,
  `BitVector`, etc. more easily
- Meshes saved in files are slightly smaller
- Copying and writing meshes is a bit more obvious without
  clearing of runtime data, etc.

The first is by far the most important. It will allows us to avoid a
bunch of manual memory management boilerplate that is error-prone and
annoying. It should also simplify future CoW improvements for runtime
data.

This patch doesn't change anything besides changing `mesh.runtime.data`
to `mesh.runtime->data`. The cleanups above will happen separately.

Differential Revision: https://developer.blender.org/D16180

28 files changed, 257 insertions, 265 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.cc b/source/blender/blenkernel/intern/DerivedMesh.cc
index 742f20fa65f..9930e5f23fa 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.cc
+++ b/source/blender/blenkernel/intern/DerivedMesh.cc
@@ -35,6 +35,7 @@
 #include "BKE_colorband.h"
 #include "BKE_deform.h"
 #include "BKE_editmesh.h"
+#include "BKE_editmesh_cache.h"
 #include "BKE_geometry_set.hh"
 #include "BKE_geometry_set_instances.hh"
 #include "BKE_key.h"
@@ -537,7 +538,7 @@ static void mesh_calc_modifier_final_normals(const Mesh *mesh_input,
                                   (final_datamask->lmask & CD_MASK_NORMAL) != 0);
 
   /* Needed as `final_datamask` is not preserved outside modifier stack evaluation. */
-  SubsurfRuntimeData *subsurf_runtime_data = mesh_final->runtime.subsurf_runtime_data;
+  SubsurfRuntimeData *subsurf_runtime_data = mesh_final->runtime->subsurf_runtime_data;
   if (subsurf_runtime_data) {
     subsurf_runtime_data->calc_loop_normals = calc_loop_normals;
   }
@@ -585,11 +586,12 @@ static void mesh_calc_finalize(const Mesh *mesh_input, Mesh *mesh_eval)
 void BKE_mesh_wrapper_deferred_finalize_mdata(Mesh *me_eval,
                                               const CustomData_MeshMasks *cd_mask_finalize)
 {
-  if (me_eval->runtime.wrapper_type_finalize & (1 << ME_WRAPPER_TYPE_BMESH)) {
+  if (me_eval->runtime->wrapper_type_finalize & (1 << ME_WRAPPER_TYPE_BMESH)) {
     editbmesh_calc_modifier_final_normals(me_eval, cd_mask_finalize);
-    me_eval->runtime.wrapper_type_finalize &= ~(1 << ME_WRAPPER_TYPE_BMESH);
+    me_eval->runtime->wrapper_type_finalize = eMeshWrapperType(
+        me_eval->runtime->wrapper_type_finalize & ~(1 << ME_WRAPPER_TYPE_BMESH));
   }
-  BLI_assert(me_eval->runtime.wrapper_type_finalize == 0);
+  BLI_assert(me_eval->runtime->wrapper_type_finalize == 0);
 }
 
 /**
@@ -1052,7 +1054,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
         append_mask.lmask |= CD_MASK_PREVIEW_MLOOPCOL;
       }
 
-      mesh_final->runtime.deformed_only = false;
+      mesh_final->runtime->deformed_only = false;
     }
 
     isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
@@ -1119,7 +1121,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
     mesh_calc_finalize(mesh_input, mesh_final);
   }
   else {
-    Mesh_Runtime *runtime = &mesh_input->runtime;
+    blender::bke::MeshRuntime *runtime = mesh_input->runtime;
     if (runtime->mesh_eval == nullptr) {
       BLI_assert(runtime->eval_mutex != nullptr);
       BLI_mutex_lock((ThreadMutex *)runtime->eval_mutex);
@@ -1207,7 +1209,7 @@ static void editbmesh_calc_modifier_final_normals(Mesh *mesh_final,
   const bool calc_loop_normals = ((mesh_final->flag & ME_AUTOSMOOTH) != 0 ||
                                   (final_datamask->lmask & CD_MASK_NORMAL) != 0);
 
-  SubsurfRuntimeData *subsurf_runtime_data = mesh_final->runtime.subsurf_runtime_data;
+  SubsurfRuntimeData *subsurf_runtime_data = mesh_final->runtime->subsurf_runtime_data;
   if (subsurf_runtime_data) {
     subsurf_runtime_data->calc_loop_normals = calc_loop_normals;
   }
@@ -1234,9 +1236,10 @@ static void editbmesh_calc_modifier_final_normals(Mesh *mesh_final,
 static void editbmesh_calc_modifier_final_normals_or_defer(
     Mesh *mesh_final, const CustomData_MeshMasks *final_datamask)
 {
-  if (mesh_final->runtime.wrapper_type != ME_WRAPPER_TYPE_MDATA) {
+  if (mesh_final->runtime->wrapper_type != ME_WRAPPER_TYPE_MDATA) {
     /* Generated at draw time. */
-    mesh_final->runtime.wrapper_type_finalize = (1 << mesh_final->runtime.wrapper_type);
+    mesh_final->runtime->wrapper_type_finalize = eMeshWrapperType(
+        1 << mesh_final->runtime->wrapper_type);
     return;
   }
 
@@ -1450,7 +1453,7 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
           deformed_verts = nullptr;
         }
       }
-      mesh_final->runtime.deformed_only = false;
+      mesh_final->runtime->deformed_only = false;
     }
 
     if (r_cage && i == cageIndex) {
@@ -1469,7 +1472,8 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
           if (!BKE_mesh_runtime_ensure_edit_data(me_orig)) {
             BKE_mesh_runtime_reset_edit_data(me_orig);
           }
-          me_orig->runtime.edit_data->vertexCos = (const float(*)[3])MEM_dupallocN(deformed_verts);
+          me_orig->runtime->edit_data->vertexCos = (const float(*)[3])MEM_dupallocN(
+              deformed_verts);
         }
         mesh_cage = BKE_mesh_wrapper_from_editmesh_with_coords(
             em_input,
@@ -1583,7 +1587,7 @@ static void mesh_build_data(struct Depsgraph *depsgraph,
    * object's runtime: this could cause access freed data on depsgraph destruction (mesh who owns
    * the final result might be freed prior to object). */
   Mesh *mesh = (Mesh *)ob->data;
-  const bool is_mesh_eval_owned = (mesh_eval != mesh->runtime.mesh_eval);
+  const bool is_mesh_eval_owned = (mesh_eval != mesh->runtime->mesh_eval);
   BKE_object_eval_assign_data(ob, &mesh_eval->id, is_mesh_eval_owned);
 
   /* Add the final mesh as a non-owning component to the geometry set. */
@@ -1643,7 +1647,7 @@ static void editbmesh_build_data(struct Depsgraph *depsgraph,
     }
   }
 
-  const bool is_mesh_eval_owned = (me_final != mesh->runtime.mesh_eval);
+  const bool is_mesh_eval_owned = (me_final != mesh->runtime->mesh_eval);
   BKE_object_eval_assign_data(obedit, &me_final->id, is_mesh_eval_owned);
 
   obedit->runtime.editmesh_eval_cage = me_cage;
@@ -1914,7 +1918,7 @@ static void make_vertexcos__mapFunc(void *userData,
 
 void mesh_get_mapped_verts_coords(Mesh *me_eval, float (*r_cos)[3], const int totcos)
 {
-  if (me_eval->runtime.deformed_only == false) {
+  if (me_eval->runtime->deformed_only == false) {
     MappedUserData userData;
     memset(r_cos, 0, sizeof(*r_cos) * totcos);
     userData.vertexcos = r_cos;
diff --git a/source/blender/blenkernel/intern/bvhutils.cc b/source/blender/blenkernel/intern/bvhutils.cc
index 58b377eecdb..184356615d4 100644
--- a/source/blender/blenkernel/intern/bvhutils.cc
+++ b/source/blender/blenkernel/intern/bvhutils.cc
@@ -1222,8 +1222,8 @@ BVHTree *BKE_bvhtree_from_mesh_get(struct BVHTreeFromMesh *data,
                                    const BVHCacheType bvh_cache_type,
                                    const int tree_type)
 {
-  BVHCache **bvh_cache_p = (BVHCache **)&mesh->runtime.bvh_cache;
-  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)mesh->runtime.eval_mutex;
+  BVHCache **bvh_cache_p = (BVHCache **)&mesh->runtime->bvh_cache;
+  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)mesh->runtime->eval_mutex;
 
   const MLoopTri *looptri = nullptr;
   int looptri_len = 0;
diff --git a/source/blender/blenkernel/intern/cloth.c b/source/blender/blenkernel/intern/cloth.c
index 7ee6b4cdfc0..89983eb8f62 100644
--- a/source/blender/blenkernel/intern/cloth.c
+++ b/source/blender/blenkernel/intern/cloth.c
@@ -826,7 +826,7 @@ static void cloth_from_mesh(ClothModifierData *clmd, const Object *ob, Mesh *mes
   const MLoop *mloop = BKE_mesh_loops(mesh);
   const MLoopTri *looptri = BKE_mesh_runtime_looptri_ensure(mesh);
   const uint mvert_num = mesh->totvert;
-  const uint looptri_num = mesh->runtime.looptris.len;
+  const uint looptri_num = BKE_mesh_runtime_looptri_len(mesh);
 
   /* Allocate our vertices. */
   clmd->clothObject->mvert_num = mvert_num;
diff --git a/source/blender/blenkernel/intern/editmesh.cc b/source/blender/blenkernel/intern/editmesh.cc
index 2ed5ec7469f..b586b4110f2 100644
--- a/source/blender/blenkernel/intern/editmesh.cc
+++ b/source/blender/blenkernel/intern/editmesh.cc
@@ -240,12 +240,12 @@ const float (*BKE_editmesh_vert_coords_when_deformed(Depsgraph *depsgraph,
   Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
   Mesh *editmesh_eval_final = BKE_object_get_editmesh_eval_final(object_eval);
 
-  if ((me->runtime.edit_data != nullptr) && (me->runtime.edit_data->vertexCos != nullptr)) {
+  if ((me->runtime->edit_data != nullptr) && (me->runtime->edit_data->vertexCos != nullptr)) {
     /* Deformed, and we have deformed coords already. */
-    coords = me->runtime.edit_data->vertexCos;
+    coords = me->runtime->edit_data->vertexCos;
   }
   else if ((editmesh_eval_final != nullptr) &&
-           (editmesh_eval_final->runtime.wrapper_type == ME_WRAPPER_TYPE_BMESH)) {
+           (editmesh_eval_final->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH)) {
     /* If this is an edit-mesh type, leave nullptr as we can use the vertex coords. */
   }
   else {
diff --git a/source/blender/blenkernel/intern/mball_tessellate.cc b/source/blender/blenkernel/intern/mball_tessellate.cc
index 5e8d2bc6d76..bb3713e770a 100644
--- a/source/blender/blenkernel/intern/mball_tessellate.cc
+++ b/source/blender/blenkernel/intern/mball_tessellate.cc
@@ -1498,7 +1498,7 @@ Mesh *BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob)
   for (int i = 0; i < mesh->totvert; i++) {
     normalize_v3(process.no[i]);
   }
-  mesh->runtime.vert_normals = process.no;
+  mesh->runtime->vert_normals = process.no;
   BKE_mesh_vertex_normals_clear_dirty(mesh);
 
   mesh->totloop = loop_offset;
diff --git a/source/blender/blenkernel/intern/mesh.cc b/source/blender/blenkernel/intern/mesh.cc
index 9e7821428d1..0018c217964 100644
--- a/source/blender/blenkernel/intern/mesh.cc
+++ b/source/blender/blenkernel/intern/mesh.cc
@@ -89,7 +89,7 @@ static void mesh_init_data(ID *id)
   CustomData_reset(&mesh->pdata);
   CustomData_reset(&mesh->ldata);
 
-  BKE_mesh_runtime_init_data(mesh);
+  mesh->runtime = new blender::bke::MeshRuntime();
 
   /* A newly created mesh does not have normals, so tag them dirty. This will be cleared
    * by #BKE_mesh_vertex_normals_clear_dirty or #BKE_mesh_poly_normals_ensure. */
@@ -103,14 +103,19 @@ static void mesh_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int
   Mesh *mesh_dst = (Mesh *)id_dst;
   const Mesh *mesh_src = (const Mesh *)id_src;
 
-  BKE_mesh_runtime_reset_on_copy(mesh_dst, flag);
+  mesh_dst->runtime = new blender::bke::MeshRuntime();
+  mesh_dst->runtime->deformed_only = mesh_src->runtime->deformed_only;
+  mesh_dst->runtime->wrapper_type = mesh_src->runtime->wrapper_type;
+  mesh_dst->runtime->wrapper_type_finalize = mesh_src->runtime->wrapper_type_finalize;
+  mesh_dst->runtime->subsurf_runtime_data = mesh_src->runtime->subsurf_runtime_data;
+  mesh_dst->runtime->cd_mask_extra = mesh_src->runtime->cd_mask_extra;
   /* Copy face dot tags, since meshes may be duplicated after a subsurf modifier
    * or node, but we still need to be able to draw face center vertices. */
-  mesh_dst->runtime.subsurf_face_dot_tags = static_cast<uint32_t *>(
-      MEM_dupallocN(mesh_src->runtime.subsurf_face_dot_tags));
+  mesh_dst->runtime->subsurf_face_dot_tags = static_cast<uint32_t *>(
+      MEM_dupallocN(mesh_src->runtime->subsurf_face_dot_tags));
   if ((mesh_src->id.tag & LIB_TAG_NO_MAIN) == 0) {
     /* This is a direct copy of a main mesh, so for now it has the same topology. */
-    mesh_dst->runtime.deformed_only = true;
+    mesh_dst->runtime->deformed_only = true;
   }
   /* This option is set for run-time meshes that have been copied from the current objects mode.
    * Currently this is used for edit-mesh although it could be used for sculpt or other
@@ -121,7 +126,7 @@ static void mesh_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int
    *
    * While this could be the callers responsibility, keep here since it's
    * highly unlikely we want to create a duplicate and not use it for drawing. */
-  mesh_dst->runtime.is_original_bmesh = false;
+  mesh_dst->runtime->is_original_bmesh = false;
 
   /* Only do tessface if we have no polys. */
   const bool do_tessface = ((mesh_src->totface != 0) && (mesh_src->totpoly == 0));
@@ -194,6 +199,8 @@ static void mesh_free_data(ID *id)
   BKE_mesh_runtime_free_data(mesh);
   mesh_clear_geometry(mesh);
   MEM_SAFE_FREE(mesh->mat);
+
+  delete mesh->runtime;
 }
 
 static void mesh_foreach_id(ID *id, LibraryForeachIDData *data)
@@ -229,7 +236,7 @@ static void mesh_blend_write(BlendWriter *writer, ID *id, const void *id_address
   mesh->mface = nullptr;
   mesh->totface = 0;
   memset(&mesh->fdata, 0, sizeof(mesh->fdata));
-  mesh->runtime = blender::dna::shallow_zero_initialize();
+  mesh->runtime = nullptr;
 
   /* Do not store actual geometry data in case this is a library override ID. */
   if (ID_IS_OVERRIDE_LIBRARY(mesh) && !is_undo) {
@@ -339,8 +346,7 @@ static void mesh_blend_read_data(BlendDataReader *reader, ID *id)
   mesh->texflag &= ~ME_AUTOSPACE_EVALUATED;
   mesh->edit_mesh = nullptr;
 
-  mesh->runtime = blender::dna::shallow_zero_initialize();
-  BKE_mesh_runtime_init_data(mesh);
+  mesh->runtime = new blender::bke::MeshRuntime();
 
   /* happens with old files */
   if (mesh->mselect == nullptr) {
@@ -1137,7 +1143,7 @@ static void ensure_orig_index_layer(CustomData &data, const int size)
 
 void BKE_mesh_ensure_default_orig_index_customdata(Mesh *mesh)
 {
-  BLI_assert(mesh->runtime.wrapper_type == ME_WRAPPER_TYPE_MDATA);
+  BLI_assert(mesh->runtime->wrapper_type == ME_WRAPPER_TYPE_MDATA);
   BKE_mesh_ensure_default_orig_index_customdata_no_check(mesh);
 }
 
@@ -2106,8 +2112,8 @@ void BKE_mesh_split_faces(Mesh *mesh, bool free_loop_normals)
     }
 
     /* Update normals manually to avoid recalculation after this operation. */
-    mesh->runtime.vert_normals = (float(*)[3])MEM_reallocN(mesh->runtime.vert_normals,
-                                                           sizeof(float[3]) * mesh->totvert);
+    mesh->runtime->vert_normals = (float(*)[3])MEM_reallocN(mesh->runtime->vert_normals,
+                                                            sizeof(float[3]) * mesh->totvert);
 
     /* Perform actual split of vertices and edges. */
     split_faces_split_new_verts(mesh, new_verts, num_new_verts);
@@ -2141,10 +2147,10 @@ void BKE_mesh_eval_geometry(Depsgraph *depsgraph, Mesh *mesh)
   /* We are here because something did change in the mesh. This means we can not trust the existing
    * evaluated mesh, and we don't know what parts of the mesh did change. So we simply delete the
    * evaluated mesh and let objects to re-create it with updated settings. */
-  if (mesh->runtime.mesh_eval != nullptr) {
-    mesh->runtime.mesh_eval->edit_mesh = nullptr;
-    BKE_id_free(nullptr, mesh->runtime.mesh_eval);
-    mesh->runtime.mesh_eval = nullptr;
+  if (mesh->runtime->mesh_eval != nullptr) {
+    mesh->runtime->mesh_eval->edit_mesh = nullptr;
+    BKE_id_free(nullptr, mesh->runtime->mesh_eval);
+    mesh->runtime->mesh_eval = nullptr;
   }
   if (DEG_is_active(depsgraph)) {
     Mesh *mesh_orig = (Mesh *)DEG_get_original_id(&mesh->id);
diff --git a/source/blender/blenkernel/intern/mesh_convert.cc b/source/blender/blenkernel/intern/mesh_convert.cc
index b4f729ca507..027423f5774 100644
--- a/source/blender/blenkernel/intern/mesh_convert.cc
+++ b/source/blender/blenkernel/intern/mesh_convert.cc
@@ -903,7 +903,7 @@ static Mesh *mesh_new_from_mesh(Object *object, Mesh *mesh)
 {
   /* While we could copy this into the new mesh,
    * add the data to 'mesh' so future calls to this function don't need to re-convert the data. */
-  if (mesh->runtime.wrapper_type == ME_WRAPPER_TYPE_BMESH) {
+  if (mesh->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH) {
     BKE_mesh_wrapper_ensure_mdata(mesh);
   }
   else {
diff --git a/source/blender/blenkernel/intern/mesh_debug.cc b/source/blender/blenkernel/intern/mesh_debug.cc
index ba4f25c74ee..6cf237a7c8c 100644
--- a/source/blender/blenkernel/intern/mesh_debug.cc
+++ b/source/blender/blenkernel/intern/mesh_debug.cc
@@ -41,9 +41,9 @@ char *BKE_mesh_debug_info(const Mesh *me)
   BLI_dynstr_appendf(dynstr, "    'totface': %d,\n", me->totface);
   BLI_dynstr_appendf(dynstr, "    'totpoly': %d,\n", me->totpoly);
 
-  BLI_dynstr_appendf(dynstr, "    'runtime.deformed_only': %d,\n", me->runtime.deformed_only);
+  BLI_dynstr_appendf(dynstr, "    'runtime.deformed_only': %d,\n", me->runtime->deformed_only);
   BLI_dynstr_appendf(
-      dynstr, "    'runtime.is_original_bmesh': %d,\n", me->runtime.is_original_bmesh);
+      dynstr, "    'runtime->is_original_bmesh': %d,\n", me->runtime->is_original_bmesh);
 
   BLI_dynstr_append(dynstr, "    'vert_layers': (\n");
   CustomData_debug_info_from_layers(&me->vdata, indent8, dynstr);
diff --git a/source/blender/blenkernel/intern/mesh_iterators.cc b/source/blender/blenkernel/intern/mesh_iterators.cc
index cf2518d7c9b..a99e9b2348d 100644
--- a/source/blender/blenkernel/intern/mesh_iterators.cc
+++ b/source/blender/blenkernel/intern/mesh_iterators.cc
@@ -36,18 +36,18 @@ void BKE_mesh_foreach_mapped_vert(
     void *userData,
     MeshForeachFlag flag)
 {
-  if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data != nullptr) {
+  if (mesh->edit_mesh != nullptr && mesh->runtime->edit_data != nullptr) {
     BMEditMesh *em = mesh->edit_mesh;
     BMesh *bm = em->bm;
     BMIter iter;
     BMVert *eve;
     int i;
-    if (mesh->runtime.edit_data->vertexCos != nullptr) {
-      const float(*vertexCos)[3] = mesh->runtime.edit_data->vertexCos;
+    if (mesh->runtime->edit_data->vertexCos != nullptr) {
+      const float(*vertexCos)[3] = mesh->runtime->edit_data->vertexCos;
       const float(*vertexNos)[3];
       if (flag & MESH_FOREACH_USE_NORMAL) {
-        BKE_editmesh_cache_ensure_vert_normals(em, mesh->runtime.edit_data);
-        vertexNos = mesh->runtime.edit_data->vertexNos;
+        BKE_editmesh_cache_ensure_vert_normals(em, mesh->runtime->edit_data);
+        vertexNos = mesh->runtime->edit_data->vertexNos;
       }
       else {
         vertexNos = nullptr;
@@ -96,14 +96,14 @@ void BKE_mesh_foreach_mapped_edge(
     void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
     void *userData)
 {
-  if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data) {
+  if (mesh->edit_mesh != nullptr && mesh->runtime->edit_data) {
     BMEditMesh *em = mesh->edit_mesh;
     BMesh *bm = em->bm;
     BMIter iter;
     BMEdge *eed;
     int i;
-    if (mesh->runtime.edit_data->vertexCos != nullptr) {
-      const float(*vertexCos)[3] = mesh->runtime.edit_data->vertexCos;
+    if (mesh->runtime->edit_data->vertexCos != nullptr) {
+      const float(*vertexCos)[3] = mesh->runtime->edit_data->vertexCos;
       BM_mesh_elem_index_ensure(bm, BM_VERT);
 
       BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
@@ -154,13 +154,13 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
   /* We can't use `dm->getLoopDataLayout(dm)` here,
    * we want to always access `dm->loopData`, `EditDerivedBMesh` would
    * return loop data from BMesh itself. */
-  if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data) {
+  if (mesh->edit_mesh != nullptr && mesh->runtime->edit_data) {
     BMEditMesh *em = mesh->edit_mesh;
     BMesh *bm = em->bm;
     BMIter iter;
     BMFace *efa;
 
-    const float(*vertexCos)[3] = mesh->runtime.edit_data->vertexCos;
+    const float(*vertexCos)[3] = mesh->runtime->edit_data->vertexCos;
 
     /* XXX: investigate using EditMesh data. */
     const float(*lnors)[3] = (flag & MESH_FOREACH_USE_NORMAL) ?
@@ -231,7 +231,7 @@ void BKE_mesh_foreach_mapped_face_center(
     void *userData,
     MeshForeachFlag flag)
 {
-  if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data != nullptr) {
+  if (mesh->edit_mesh != nullptr && mesh->runtime->edit_data != nullptr) {
     BMEditMesh *em = mesh->edit_mesh;
     BMesh *bm = em->bm;
     const float(*polyCos)[3];
@@ -240,12 +240,12 @@ void BKE_mesh_foreach_mapped_face_center(
     BMIter iter;
     int i;
 
-    BKE_editmesh_cache_ensure_poly_centers(em, mesh->runtime.edit_data);
-    polyCos = mesh->runtime.edit_data->polyCos; /* always set */
+    BKE_editmesh_cache_ensure_poly_centers(em, mesh->runtime->edit_data);
+    polyCos = mesh->runtime->edit_data->polyCos; /* always set */
 
     if (flag & MESH_FOREACH_USE_NORMAL) {
-      BKE_editmesh_cache_ensure_poly_normals(em, mesh->runtime.edit_data);
-      polyNos = mesh->runtime.edit_data->polyNos; /* maybe nullptr */
+      BKE_editmesh_cache_ensure_poly_normals(em, mesh->runtime->edit_data);
+      polyNos = mesh->runtime->edit_data->polyNos; /* maybe nullptr */
     }
     else {
       polyNos = nullptr;
@@ -317,7 +317,7 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
                                       BKE_mesh_vertex_normals_ensure(mesh) :
                                       nullptr;
   const int *index = static_cast<const int *>(CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX));
-  const BLI_bitmap *facedot_tags = mesh->runtime.subsurf_face_dot_tags;
+  const BLI_bitmap *facedot_tags = mesh->runtime->subsurf_face_dot_tags;
   BLI_assert(facedot_tags != nullptr);
 
   if (index) {
diff --git a/source/blender/blenkernel/intern/mesh_normals.cc b/source/blender/blenkernel/intern/mesh_normals.cc
index 76f2078e6c8..c2594ea3816 100644
--- a/source/blender/blenkernel/intern/mesh_normals.cc
+++ b/source/blender/blenkernel/intern/mesh_normals.cc
@@ -95,72 +95,72 @@ static void add_v3_v3_atomic(float r[3], const float a[3])
 
 void BKE_mesh_normals_tag_dirty(Mesh *mesh)
 {
-  mesh->runtime.vert_normals_dirty = true;
-  mesh->runtime.poly_normals_dirty = true;
+  mesh->runtime->vert_normals_dirty = true;
+  mesh->runtime->poly_normals_dirty = true;
 }
 
 float (*BKE_mesh_vertex_normals_for_write(Mesh *mesh))[3]
 {
-  if (mesh->runtime.vert_normals == nullptr) {
-    mesh->runtime.vert_normals = (float(*)[3])MEM_malloc_arrayN(
+  if (mesh->runtime->vert_normals == nullptr) {
+    mesh->runtime->vert_normals = (float(*)[3])MEM_malloc_arrayN(
         mesh->totvert, sizeof(float[3]), __func__);
   }
 
-  BLI_assert(MEM_allocN_len(mesh->runtime.vert_normals) >= sizeof(float[3]) * mesh->totvert);
+  BLI_assert(MEM_allocN_len(mesh->runtime->vert_normals) >= sizeof(float[3]) * mesh->totvert);
 
-  return mesh->runtime.vert_normals;
+  return mesh->runtime->vert_normals;
 }
 
 float (*BKE_mesh_poly_normals_for_write(Mesh *mesh))[3]
 {
-  if (mesh->runtime.poly_normals == nullptr) {
-    mesh->runtime.poly_normals = (float(*)[3])MEM_malloc_arrayN(
+  if (mesh->runtime->poly_normals == nullptr) {
+    mesh->runtime->poly_normals = (float(*)[3])MEM_malloc_arrayN(
         mesh->totpoly, sizeof(float[3]), __func__);
   }
 
-  BLI_assert(MEM_allocN_len(mesh->runtime.poly_normals) >= sizeof(float[3]) * mesh->totpoly);
+  BLI_assert(MEM_allocN_len(mesh->runtime->poly_normals) >= sizeof(float[3]) * mesh->totpoly);
 
-  return mesh->runtime.poly_normals;
+  return mesh->runtime->poly_normals;
 }
 
 void BKE_mesh_vertex_normals_clear_dirty(Mesh *mesh)
 {
-  mesh->runtime.vert_normals_dirty = false;
+  mesh->runtime->vert_normals_dirty = false;
   BKE_mesh_assert_normals_dirty_or_calculated(mesh);
 }
 
 void BKE_mesh_poly_normals_clear_dirty(Mesh *mesh)
 {
-  mesh->runtime.poly_normals_dirty = false;
+  mesh->runtime->poly_normals_dirty = false;
   BKE_mesh_assert_normals_dirty_or_calculated(mesh);
 }
 
 bool BKE_mesh_vertex_normals_are_dirty(const Mesh *mesh)
 {
-  return mesh->runtime.vert_normals_dirty;
+  return mesh->runtime->vert_normals_dirty;
 }
 
 bool BKE_mesh_poly_normals_are_dirty(const Mesh *mesh)
 {
-  return mesh->runtime.poly_normals_dirty;
+  return mesh->runtime->poly_normals_dirty;
 }
 
 void BKE_mesh_clear_derived_normals(Mesh *mesh)
 {
-  MEM_SAFE_FREE(mesh->runtime.vert_normals);
-  MEM_SAFE_FREE(mesh->runtime.poly_normals);
+  MEM_SAFE_FREE(mesh->runtime->vert_normals);
+  MEM_SAFE_FREE(mesh->runtime->poly_normals);
 
-  mesh->runtime.vert_normals_dirty = true;
-  mesh->runtime.poly_normals_dirty = true;
+  mesh->runtime->vert_normals_dirty = true;
+  mesh->runtime->poly_normals_dirty = true;
 }
 
 void BKE_mesh_assert_normals_dirty_or_calculated(const Mesh *mesh)
 {
-  if (!mesh->runtime.vert_normals_dirty) {
-    BLI_assert(mesh->runtime.vert_normals || mesh->totvert == 0);
+  if (!mesh->runtime->vert_normals_dirty) {
+    BLI_assert(mesh->runtime->vert_normals || mesh->totvert == 0);
   }
-  if (!mesh->runtime.poly_normals_dirty) {
-    BLI_assert(mesh->runtime.poly_normals || mesh->totpoly == 0);
+  if (!mesh->runtime->poly_normals_dirty) {
+    BLI_assert(mesh->runtime->poly_normals || mesh->totpoly == 0);
   }
 }
 
@@ -348,20 +348,20 @@ void BKE_mesh_calc_normals_poly_and_vertex(const MVert *mvert,
 const float (*BKE_mesh_vertex_normals_ensure(const Mesh *mesh))[3]
 {
   if (!BKE_mesh_vertex_normals_are_dirty(mesh)) {
-    BLI_assert(mesh->runtime.vert_normals != nullptr || mesh->totvert == 0);
-    return mesh->runtime.vert_normals;
+    BLI_assert(mesh->runtime->vert_normals != nullptr || mesh->totvert == 0);
+    return mesh->runtime->vert_normals;
   }
 
   if (mesh->totvert == 0) {
     return nullptr;
   }
 
-  ThreadMutex *normals_mutex = (ThreadMutex *)mesh->runtime.normals_mutex;
+  ThreadMutex *normals_mutex = (ThreadMutex *)mesh->runtime->normals_mutex;
   BLI_mutex_lock(normals_mutex);
   if (!BKE_mesh_vertex_normals_are_dirty(mesh)) {
-    BLI_assert(mesh->runtime.vert_normals != nullptr);
+    BLI_assert(mesh->runtime->vert_normals != nullptr);
     BLI_mutex_unlock(normals_mutex);
-    return mesh->runtime.vert_normals;
+    return mesh->runtime->vert_normals;
   }
 
   float(*vert_normals)[3];
@@ -397,20 +397,20 @@ const float (*BKE_mesh_vertex_normals_ensure(const Mesh *mesh))[3]
 const float (*BKE_mesh_poly_normals_ensure(const Mesh *mesh))[3]
 {
   if (!BKE_mesh_poly_normals_are_dirty(mesh)) {
-    BLI_assert(mesh->runtime.poly_normals != nullptr || mesh->totpoly == 0);
-    return mesh->runtime.poly_normals;
+    BLI_assert(mesh->runtime->poly_normals != nullptr || mesh->totpoly == 0);
+    return mesh->runtime->poly_normals;
   }
 
   if (mesh->totpoly == 0) {
     return nullptr;
   }
 
-  ThreadMutex *normals_mutex = (ThreadMutex *)mesh->runtime.normals_mutex;
+  ThreadMutex *normals_mutex = (ThreadMutex *)mesh->runtime->normals_mutex;
   BLI_mutex_lock(normals_mutex);
   if (!BKE_mesh_poly_normals_are_dirty(mesh)) {
-    BLI_assert(mesh->runtime.poly_normals != nullptr);
+    BLI_assert(mesh->runtime->poly_normals != nullptr);
     BLI_mutex_unlock(normals_mutex);
-    return mesh->runtime.poly_normals;
+    return mesh->runtime->poly_normals;
   }
 
   float(*poly_normals)[3];
@@ -441,7 +441,7 @@ const float (*BKE_mesh_poly_normals_ensure(const Mesh *mesh))[3]
 
 void BKE_mesh_ensure_normals_for_display(Mesh *mesh)
 {
-  switch ((eMeshWrapperType)mesh->runtime.wrapper_type) {
+  switch (mesh->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_SUBD:
     case ME_WRAPPER_TYPE_MDATA:
       BKE_mesh_vertex_normals_ensure(mesh);
@@ -449,7 +449,7 @@ void BKE_mesh_ensure_normals_for_display(Mesh *mesh)
       break;
     case ME_WRAPPER_TYPE_BMESH: {
       struct BMEditMesh *em = mesh->edit_mesh;
-      EditMeshData *emd = mesh->runtime.edit_data;
+      EditMeshData *emd = mesh->runtime->edit_data;
       if (emd->vertexCos) {
         BKE_editmesh_cache_ensure_vert_normals(em, emd);
         BKE_editmesh_cache_ensure_poly_normals(em, emd);
diff --git a/source/blender/blenkernel/intern/mesh_remap.c b/source/blender/blenkernel/intern/mesh_remap.c
index cb05d33bc2e..90798ea593d 100644
--- a/source/blender/blenkernel/intern/mesh_remap.c
+++ b/source/blender/blenkernel/intern/mesh_remap.c
@@ -1529,7 +1529,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
         BLI_bitmap *looptri_active;
 
         looptri_src = BKE_mesh_runtime_looptri_ensure(me_src);
-        num_looptri_src = me_src->runtime.looptris.len;
+        num_looptri_src = BKE_mesh_runtime_looptri_len(me_src);
         looptri_active = BLI_BITMAP_NEW((size_t)num_looptri_src, __func__);
 
         for (tindex = 0; tindex < num_trees; tindex++) {
diff --git a/source/blender/blenkernel/intern/mesh_runtime.cc b/source/blender/blenkernel/intern/mesh_runtime.cc
index bd9f8242274..100b4de9045 100644
--- a/source/blender/blenkernel/intern/mesh_runtime.cc
+++ b/source/blender/blenkernel/intern/mesh_runtime.cc
@@ -17,6 +17,7 @@
 #include "BLI_task.hh"
 
 #include "BKE_bvhutils.h"
+#include "BKE_editmesh_cache.h"
 #include "BKE_lib_id.h"
 #include "BKE_mesh.h"
 #include "BKE_mesh_runtime.h"
@@ -30,81 +31,50 @@ using blender::Span;
 /** \name Mesh Runtime Struct Utils
  * \{ */
 
-/**
- * \brief Initialize the runtime mutexes of the given mesh.
- *
- * Any existing mutexes will be overridden.
- */
-static void mesh_runtime_init_mutexes(Mesh *mesh)
+void BKE_mesh_runtime_free_data(Mesh *mesh)
 {
-  mesh->runtime.eval_mutex = MEM_new<ThreadMutex>("mesh runtime eval_mutex");
-  BLI_mutex_init(static_cast<ThreadMutex *>(mesh->runtime.eval_mutex));
-  mesh->runtime.normals_mutex = MEM_new<ThreadMutex>("mesh runtime normals_mutex");
-  BLI_mutex_init(static_cast<ThreadMutex *>(mesh->runtime.normals_mutex));
-  mesh->runtime.render_mutex = MEM_new<ThreadMutex>("mesh runtime render_mutex");
-  BLI_mutex_init(static_cast<ThreadMutex *>(mesh->runtime.render_mutex));
+  BKE_mesh_runtime_clear_cache(mesh);
 }
 
-/**
- * \brief free the mutexes of the given mesh runtime.
- */
-static void mesh_runtime_free_mutexes(Mesh *mesh)
-{
-  if (mesh->runtime.eval_mutex != nullptr) {
-    BLI_mutex_end(static_cast<ThreadMutex *>(mesh->runtime.eval_mutex));
-    MEM_freeN(mesh->runtime.eval_mutex);
-    mesh->runtime.eval_mutex = nullptr;
-  }
-  if (mesh->runtime.normals_mutex != nullptr) {
-    BLI_mutex_end(static_cast<ThreadMutex *>(mesh->runtime.normals_mutex));
-    MEM_freeN(mesh->runtime.normals_mutex);
-    mesh->runtime.normals_mutex = nullptr;
-  }
-  if (mesh->runtime.render_mutex != nullptr) {
-    BLI_mutex_end(static_cast<ThreadMutex *>(mesh->runtime.render_mutex));
-    MEM_freeN(mesh->runtime.render_mutex);
-    mesh->runtime.render_mutex = nullptr;
-  }
-}
+namespace blender::bke {
 
-void BKE_mesh_runtime_init_data(Mesh *mesh)
+MeshRuntime::MeshRuntime()
 {
-  mesh_runtime_init_mutexes(mesh);
+  this->eval_mutex = MEM_new<ThreadMutex>("mesh runtime eval_mutex");
+  BLI_mutex_init(static_cast<ThreadMutex *>(this->eval_mutex));
+  this->normals_mutex = MEM_new<ThreadMutex>("mesh runtime normals_mutex");
+  BLI_mutex_init(static_cast<ThreadMutex *>(this->normals_mutex));
+  this->render_mutex = MEM_new<ThreadMutex>("mesh runtime render_mutex");
+  BLI_mutex_init(static_cast<ThreadMutex *>(this->render_mutex));
 }
 
-void BKE_mesh_runtime_free_data(Mesh *mesh)
+MeshRuntime::~MeshRuntime()
 {
-  BKE_mesh_runtime_clear_cache(mesh);
-  mesh_runtime_free_mutexes(mesh);
+  if (this->eval_mutex != nullptr) {
+    BLI_mutex_end(static_cast<ThreadMutex *>(this->eval_mutex));
+    MEM_freeN(this->eval_mutex);
+    this->eval_mutex = nullptr;
+  }
+  if (this->normals_mutex != nullptr) {
+    BLI_mutex_end(static_cast<ThreadMutex *>(this->normals_mutex));
+    MEM_freeN(this->normals_mutex);
+    this->normals_mutex = nullptr;
+  }
+  if (this->render_mutex != nullptr) {
+    BLI_mutex_end(static_cast<ThreadMutex *>(this->render_mutex));
+    MEM_freeN(this->render_mutex);
+    this->render_mutex = nullptr;
+  }
 }
 
-void BKE_mesh_runtime_reset_on_copy(Mesh *mesh, const int /*flag*/)
-{
-  Mesh_Runtime *runtime = &mesh->runtime;
-
-  runtime->mesh_eval = nullptr;
-  runtime->edit_data = nullptr;
-  runtime->batch_cache = nullptr;
-  runtime->subdiv_ccg = nullptr;
-  runtime->looptris = blender::dna::shallow_zero_initialize();
-  runtime->bvh_cache = nullptr;
-  runtime->shrinkwrap_data = nullptr;
-  runtime->subsurf_face_dot_tags = nullptr;
-
-  runtime->vert_normals_dirty = true;
-  runtime->poly_normals_dirty = true;
-  runtime->vert_normals = nullptr;
-  runtime->poly_normals = nullptr;
-
-  mesh_runtime_init_mutexes(mesh);
-}
+}  // namespace blender::bke
 
 void BKE_mesh_runtime_clear_cache(Mesh *mesh)
 {
-  if (mesh->runtime.mesh_eval != nullptr) {
-    mesh->runtime.mesh_eval->edit_mesh = nullptr;
-    BKE_id_free(nullptr, mesh->runtime.mesh_eval);
-    mesh->runtime.mesh_eval = nullptr;
+  if (mesh->runtime->mesh_eval != nullptr) {
+    mesh->runtime->mesh_eval->edit_mesh = nullptr;
+    BKE_id_free(nullptr, mesh->runtime->mesh_eval);
+    mesh->runtime->mesh_eval = nullptr;
   }
   BKE_mesh_runtime_clear_geometry(mesh);
   BKE_mesh_batch_cache_free(mesh);
@@ -131,32 +101,32 @@ static void mesh_ensure_looptri_data(Mesh *mesh)
   const uint totpoly = mesh->totpoly;
   const int looptris_len = poly_to_tri_count(totpoly, mesh->totloop);
 
-  BLI_assert(mesh->runtime.looptris.array_wip == nullptr);
+  BLI_assert(mesh->runtime->looptris.array_wip == nullptr);
 
-  SWAP(MLoopTri *, mesh->runtime.looptris.array, mesh->runtime.looptris.array_wip);
+  SWAP(MLoopTri *, mesh->runtime->looptris.array, mesh->runtime->looptris.array_wip);
 
-  if ((looptris_len > mesh->runtime.looptris.len_alloc) ||
-      (looptris_len < mesh->runtime.looptris.len_alloc * 2) || (totpoly == 0)) {
-    MEM_SAFE_FREE(mesh->runtime.looptris.array_wip);
-    mesh->runtime.looptris.len_alloc = 0;
-    mesh->runtime.looptris.len = 0;
+  if ((looptris_len > mesh->runtime->looptris.len_alloc) ||
+      (looptris_len < mesh->runtime->looptris.len_alloc * 2) || (totpoly == 0)) {
+    MEM_SAFE_FREE(mesh->runtime->looptris.array_wip);
+    mesh->runtime->looptris.len_alloc = 0;
+    mesh->runtime->looptris.len = 0;
   }
 
   if (totpoly) {
-    if (mesh->runtime.looptris.array_wip == nullptr) {
-      mesh->runtime.looptris.array_wip = static_cast<MLoopTri *>(
-          MEM_malloc_arrayN(looptris_len, sizeof(*mesh->runtime.looptris.array_wip), __func__));
-      mesh->runtime.looptris.len_alloc = looptris_len;
+    if (mesh->runtime->looptris.array_wip == nullptr) {
+      mesh->runtime->looptris.array_wip = static_cast<MLoopTri *>(
+          MEM_malloc_arrayN(looptris_len, sizeof(*mesh->runtime->looptris.array_wip), __func__));
+      mesh->runtime->looptris.len_alloc = looptris_len;
     }
 
-    mesh->runtime.looptris.len = looptris_len;
+    mesh->runtime->looptris.len = looptris_len;
   }
 }
 
 void BKE_mesh_runtime_looptri_recalc(Mesh *mesh)
 {
   mesh_ensure_looptri_data(mesh);
-  BLI_assert(mesh->totpoly == 0 || mesh->runtime.looptris.array_wip != nullptr);
+  BLI_assert(mesh->totpoly == 0 || mesh->runtime->looptris.array_wip != nullptr);
   const Span<MVert> verts = mesh->verts();
   const Span<MPoly> polys = mesh->polys();
   const Span<MLoop> loops = mesh->loops();
@@ -167,7 +137,7 @@ void BKE_mesh_runtime_looptri_recalc(Mesh *mesh)
                                          verts.data(),
                                          mesh->totloop,
                                          mesh->totpoly,
-                                         mesh->runtime.looptris.array_wip,
+                                         mesh->runtime->looptris.array_wip,
                                          BKE_mesh_poly_normals_ensure(mesh));
   }
   else {
@@ -176,39 +146,39 @@ void BKE_mesh_runtime_looptri_recalc(Mesh *mesh)
                             verts.data(),
                             mesh->totloop,
                             mesh->totpoly,
-                            mesh->runtime.looptris.array_wip);
+                            mesh->runtime->looptris.array_wip);
   }
 
-  BLI_assert(mesh->runtime.looptris.array == nullptr);
-  atomic_cas_ptr((void **)&mesh->runtime.looptris.array,
-                 mesh->runtime.looptris.array,
-                 mesh->runtime.looptris.array_wip);
-  mesh->runtime.looptris.array_wip = nullptr;
+  BLI_assert(mesh->runtime->looptris.array == nullptr);
+  atomic_cas_ptr((void **)&mesh->runtime->looptris.array,
+                 mesh->runtime->looptris.array,
+                 mesh->runtime->looptris.array_wip);
+  mesh->runtime->looptris.array_wip = nullptr;
 }
 
 int BKE_mesh_runtime_looptri_len(const Mesh *mesh)
 {
   /* This is a ported copy of `dm_getNumLoopTri(dm)`. */
   const int looptri_len = poly_to_tri_count(mesh->totpoly, mesh->totloop);
-  BLI_assert(ELEM(mesh->runtime.looptris.len, 0, looptri_len));
+  BLI_assert(ELEM(mesh->runtime->looptris.len, 0, looptri_len));
   return looptri_len;
 }
 
 const MLoopTri *BKE_mesh_runtime_looptri_ensure(const Mesh *mesh)
 {
-  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)mesh->runtime.eval_mutex;
+  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)mesh->runtime->eval_mutex;
   BLI_mutex_lock(mesh_eval_mutex);
 
-  MLoopTri *looptri = mesh->runtime.looptris.array;
+  MLoopTri *looptri = mesh->runtime->looptris.array;
 
   if (looptri != nullptr) {
-    BLI_assert(BKE_mesh_runtime_looptri_len(mesh) == mesh->runtime.looptris.len);
+    BLI_assert(BKE_mesh_runtime_looptri_len(mesh) == mesh->runtime->looptris.len);
   }
   else {
     /* Must isolate multithreaded tasks while holding a mutex lock. */
     blender::threading::isolate_task(
         [&]() { BKE_mesh_runtime_looptri_recalc(const_cast<Mesh *>(mesh)); });
-    looptri = mesh->runtime.looptris.array;
+    looptri = mesh->runtime->looptris.array;
   }
 
   BLI_mutex_unlock(mesh_eval_mutex);
@@ -230,17 +200,17 @@ void BKE_mesh_runtime_verttri_from_looptri(MVertTri *r_verttri,
 
 bool BKE_mesh_runtime_ensure_edit_data(struct Mesh *mesh)
 {
-  if (mesh->runtime.edit_data != nullptr) {
+  if (mesh->runtime->edit_data != nullptr) {
     return false;
   }
 
-  mesh->runtime.edit_data = MEM_cnew<EditMeshData>(__func__);
+  mesh->runtime->edit_data = MEM_cnew<EditMeshData>(__func__);
   return true;
 }
 
 bool BKE_mesh_runtime_reset_edit_data(Mesh *mesh)
 {
-  EditMeshData *edit_data = mesh->runtime.edit_data;
+  EditMeshData *edit_data = mesh->runtime->edit_data;
   if (edit_data == nullptr) {
     return false;
   }
@@ -255,13 +225,13 @@ bool BKE_mesh_runtime_reset_edit_data(Mesh *mesh)
 
 bool BKE_mesh_runtime_clear_edit_data(Mesh *mesh)
 {
-  if (mesh->runtime.edit_data == nullptr) {
+  if (mesh->runtime->edit_data == nullptr) {
     return false;
   }
   BKE_mesh_runtime_reset_edit_data(mesh);
 
-  MEM_freeN(mesh->runtime.edit_data);
-  mesh->runtime.edit_data = nullptr;
+  MEM_freeN(mesh->runtime->edit_data);
+  mesh->runtime->edit_data = nullptr;
 
   return true;
 }
@@ -271,22 +241,22 @@ void BKE_mesh_runtime_clear_geometry(Mesh *mesh)
   BKE_mesh_tag_coords_changed(mesh);
 
   /* TODO(sergey): Does this really belong here? */
-  if (mesh->runtime.subdiv_ccg != nullptr) {
-    BKE_subdiv_ccg_destroy(mesh->runtime.subdiv_ccg);
-    mesh->runtime.subdiv_ccg = nullptr;
+  if (mesh->runtime->subdiv_ccg != nullptr) {
+    BKE_subdiv_ccg_destroy(mesh->runtime->subdiv_ccg);
+    mesh->runtime->subdiv_ccg = nullptr;
   }
   BKE_shrinkwrap_discard_boundary_data(mesh);
 
-  MEM_SAFE_FREE(mesh->runtime.subsurf_face_dot_tags);
+  MEM_SAFE_FREE(mesh->runtime->subsurf_face_dot_tags);
 }
 
 void BKE_mesh_tag_coords_changed(Mesh *mesh)
 {
   BKE_mesh_normals_tag_dirty(mesh);
-  MEM_SAFE_FREE(mesh->runtime.looptris.array);
-  if (mesh->runtime.bvh_cache) {
-    bvhcache_free(mesh->runtime.bvh_cache);
-    mesh->runtime.bvh_cache = nullptr;
+  MEM_SAFE_FREE(mesh->runtime->looptris.array);
+  if (mesh->runtime->bvh_cache) {
+    bvhcache_free(mesh->runtime->bvh_cache);
+    mesh->runtime->bvh_cache = nullptr;
   }
 }
 
@@ -305,6 +275,16 @@ void BKE_mesh_tag_coords_changed_uniformly(Mesh *mesh)
   }
 }
 
+bool BKE_mesh_is_deformed_only(const Mesh *mesh)
+{
+  return mesh->runtime->deformed_only;
+}
+
+eMeshWrapperType BKE_mesh_wrapper_type(const struct Mesh *mesh)
+{
+  return mesh->runtime->wrapper_type;
+}
+
 /** \} */
 
 /* -------------------------------------------------------------------- */
@@ -317,13 +297,13 @@ void (*BKE_mesh_batch_cache_free_cb)(Mesh *me) = nullptr;
 
 void BKE_mesh_batch_cache_dirty_tag(Mesh *me, eMeshBatchDirtyMode mode)
 {
-  if (me->runtime.batch_cache) {
+  if (me->runtime->batch_cache) {
     BKE_mesh_batch_cache_dirty_tag_cb(me, mode);
   }
 }
 void BKE_mesh_batch_cache_free(Mesh *me)
 {
-  if (me->runtime.batch_cache) {
+  if (me->runtime->batch_cache) {
     BKE_mesh_batch_cache_free_cb(me);
   }
 }
diff --git a/source/blender/blenkernel/intern/mesh_tangent.cc b/source/blender/blenkernel/intern/mesh_tangent.cc
index 1162986aaf5..49ea23a1552 100644
--- a/source/blender/blenkernel/intern/mesh_tangent.cc
+++ b/source/blender/blenkernel/intern/mesh_tangent.cc
@@ -570,8 +570,6 @@ void BKE_mesh_calc_loop_tangents(Mesh *me_eval,
                                  const char (*tangent_names)[MAX_NAME],
                                  int tangent_names_len)
 {
-  BKE_mesh_runtime_looptri_ensure(me_eval);
-
   /* TODO(@campbellbarton): store in Mesh.runtime to avoid recalculation. */
   short tangent_mask = 0;
   BKE_mesh_calc_loop_tangent_ex(
@@ -579,8 +577,8 @@ void BKE_mesh_calc_loop_tangents(Mesh *me_eval,
       BKE_mesh_polys(me_eval),
       uint(me_eval->totpoly),
       BKE_mesh_loops(me_eval),
-      me_eval->runtime.looptris.array,
-      uint(me_eval->runtime.looptris.len),
+      BKE_mesh_runtime_looptri_ensure(me_eval),
+      uint(BKE_mesh_runtime_looptri_len(me_eval)),
       &me_eval->ldata,
       calc_active_tangent,
       tangent_names,
diff --git a/source/blender/blenkernel/intern/mesh_wrapper.cc b/source/blender/blenkernel/intern/mesh_wrapper.cc
index 101fad2fce8..db15789e847 100644
--- a/source/blender/blenkernel/intern/mesh_wrapper.cc
+++ b/source/blender/blenkernel/intern/mesh_wrapper.cc
@@ -57,13 +57,13 @@ Mesh *BKE_mesh_wrapper_from_editmesh_with_coords(BMEditMesh *em,
   BKE_mesh_copy_parameters_for_eval(me, me_settings);
   BKE_mesh_runtime_ensure_edit_data(me);
 
-  me->runtime.wrapper_type = ME_WRAPPER_TYPE_BMESH;
+  me->runtime->wrapper_type = ME_WRAPPER_TYPE_BMESH;
   if (cd_mask_extra) {
-    me->runtime.cd_mask_extra = *cd_mask_extra;
+    me->runtime->cd_mask_extra = *cd_mask_extra;
   }
 
   /* Use edit-mesh directly where possible. */
-  me->runtime.is_original_bmesh = true;
+  me->runtime->is_original_bmesh = true;
 
   me->edit_mesh = static_cast<BMEditMesh *>(MEM_dupallocN(em));
   me->edit_mesh->is_shallow_copy = true;
@@ -81,7 +81,7 @@ Mesh *BKE_mesh_wrapper_from_editmesh_with_coords(BMEditMesh *em,
   me->totloop = 0;
 #endif
 
-  EditMeshData *edit_data = me->runtime.edit_data;
+  EditMeshData *edit_data = me->runtime->edit_data;
   edit_data->vertexCos = vert_coords;
   return me;
 }
@@ -95,17 +95,17 @@ Mesh *BKE_mesh_wrapper_from_editmesh(BMEditMesh *em,
 
 void BKE_mesh_wrapper_ensure_mdata(Mesh *me)
 {
-  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)me->runtime.eval_mutex;
+  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)me->runtime->eval_mutex;
   BLI_mutex_lock(mesh_eval_mutex);
 
-  if (me->runtime.wrapper_type == ME_WRAPPER_TYPE_MDATA) {
+  if (me->runtime->wrapper_type == ME_WRAPPER_TYPE_MDATA) {
     BLI_mutex_unlock(mesh_eval_mutex);
     return;
   }
 
   /* Must isolate multithreaded tasks while holding a mutex lock. */
   blender::threading::isolate_task([&]() {
-    switch (static_cast<eMeshWrapperType>(me->runtime.wrapper_type)) {
+    switch (static_cast<eMeshWrapperType>(me->runtime->wrapper_type)) {
       case ME_WRAPPER_TYPE_MDATA:
       case ME_WRAPPER_TYPE_SUBD: {
         break; /* Quiet warning. */
@@ -117,10 +117,10 @@ void BKE_mesh_wrapper_ensure_mdata(Mesh *me)
         me->totloop = 0;
 
         BLI_assert(me->edit_mesh != nullptr);
-        BLI_assert(me->runtime.edit_data != nullptr);
+        BLI_assert(me->runtime->edit_data != nullptr);
 
         BMEditMesh *em = me->edit_mesh;
-        BM_mesh_bm_to_me_for_eval(em->bm, me, &me->runtime.cd_mask_extra);
+        BM_mesh_bm_to_me_for_eval(em->bm, me, &me->runtime->cd_mask_extra);
 
         /* Adding original index layers assumes that all BMesh mesh wrappers are created from
          * original edit mode meshes (the only case where adding original indices makes sense).
@@ -132,22 +132,22 @@ void BKE_mesh_wrapper_ensure_mdata(Mesh *me)
          * harmful. */
         BKE_mesh_ensure_default_orig_index_customdata_no_check(me);
 
-        EditMeshData *edit_data = me->runtime.edit_data;
+        EditMeshData *edit_data = me->runtime->edit_data;
         if (edit_data->vertexCos) {
           BKE_mesh_vert_coords_apply(me, edit_data->vertexCos);
-          me->runtime.is_original_bmesh = false;
+          me->runtime->is_original_bmesh = false;
         }
         break;
       }
     }
 
-    if (me->runtime.wrapper_type_finalize) {
-      BKE_mesh_wrapper_deferred_finalize_mdata(me, &me->runtime.cd_mask_extra);
+    if (me->runtime->wrapper_type_finalize) {
+      BKE_mesh_wrapper_deferred_finalize_mdata(me, &me->runtime->cd_mask_extra);
     }
 
     /* Keep type assignment last, so that read-only access only uses the mdata code paths after all
      * the underlying data has been initialized. */
-    me->runtime.wrapper_type = ME_WRAPPER_TYPE_MDATA;
+    me->runtime->wrapper_type = ME_WRAPPER_TYPE_MDATA;
   });
 
   BLI_mutex_unlock(mesh_eval_mutex);
@@ -155,9 +155,9 @@ void BKE_mesh_wrapper_ensure_mdata(Mesh *me)
 
 bool BKE_mesh_wrapper_minmax(const Mesh *me, float min[3], float max[3])
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH:
-      return BKE_editmesh_cache_calc_minmax(me->edit_mesh, me->runtime.edit_data, min, max);
+      return BKE_editmesh_cache_calc_minmax(me->edit_mesh, me->runtime->edit_data, min, max);
     case ME_WRAPPER_TYPE_MDATA:
     case ME_WRAPPER_TYPE_SUBD:
       return BKE_mesh_minmax(me, min, max);
@@ -174,11 +174,11 @@ void BKE_mesh_wrapper_vert_coords_copy(const Mesh *me,
                                        float (*vert_coords)[3],
                                        int vert_coords_len)
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH: {
       BMesh *bm = me->edit_mesh->bm;
       BLI_assert(vert_coords_len <= bm->totvert);
-      EditMeshData *edit_data = me->runtime.edit_data;
+      EditMeshData *edit_data = me->runtime->edit_data;
       if (edit_data->vertexCos != nullptr) {
         for (int i = 0; i < vert_coords_len; i++) {
           copy_v3_v3(vert_coords[i], edit_data->vertexCos[i]);
@@ -212,11 +212,11 @@ void BKE_mesh_wrapper_vert_coords_copy_with_mat4(const Mesh *me,
                                                  int vert_coords_len,
                                                  const float mat[4][4])
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH: {
       BMesh *bm = me->edit_mesh->bm;
       BLI_assert(vert_coords_len == bm->totvert);
-      EditMeshData *edit_data = me->runtime.edit_data;
+      EditMeshData *edit_data = me->runtime->edit_data;
       if (edit_data->vertexCos != nullptr) {
         for (int i = 0; i < vert_coords_len; i++) {
           mul_v3_m4v3(vert_coords[i], mat, edit_data->vertexCos[i]);
@@ -253,7 +253,7 @@ void BKE_mesh_wrapper_vert_coords_copy_with_mat4(const Mesh *me,
 
 int BKE_mesh_wrapper_vert_len(const Mesh *me)
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH:
       return me->edit_mesh->bm->totvert;
     case ME_WRAPPER_TYPE_MDATA:
@@ -266,7 +266,7 @@ int BKE_mesh_wrapper_vert_len(const Mesh *me)
 
 int BKE_mesh_wrapper_edge_len(const Mesh *me)
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH:
       return me->edit_mesh->bm->totedge;
     case ME_WRAPPER_TYPE_MDATA:
@@ -279,7 +279,7 @@ int BKE_mesh_wrapper_edge_len(const Mesh *me)
 
 int BKE_mesh_wrapper_loop_len(const Mesh *me)
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH:
       return me->edit_mesh->bm->totloop;
     case ME_WRAPPER_TYPE_MDATA:
@@ -292,7 +292,7 @@ int BKE_mesh_wrapper_loop_len(const Mesh *me)
 
 int BKE_mesh_wrapper_poly_len(const Mesh *me)
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH:
       return me->edit_mesh->bm->totface;
     case ME_WRAPPER_TYPE_MDATA:
@@ -311,7 +311,7 @@ int BKE_mesh_wrapper_poly_len(const Mesh *me)
 
 static Mesh *mesh_wrapper_ensure_subdivision(Mesh *me)
 {
-  SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)me->runtime.subsurf_runtime_data;
+  SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)me->runtime->subsurf_runtime_data;
   if (runtime_data == nullptr || runtime_data->settings.level == 0) {
     return me;
   }
@@ -359,24 +359,24 @@ static Mesh *mesh_wrapper_ensure_subdivision(Mesh *me)
   }
 
   if (subdiv_mesh != me) {
-    if (me->runtime.mesh_eval != nullptr) {
-      BKE_id_free(nullptr, me->runtime.mesh_eval);
+    if (me->runtime->mesh_eval != nullptr) {
+      BKE_id_free(nullptr, me->runtime->mesh_eval);
     }
-    me->runtime.mesh_eval = subdiv_mesh;
-    me->runtime.wrapper_type = ME_WRAPPER_TYPE_SUBD;
+    me->runtime->mesh_eval = subdiv_mesh;
+    me->runtime->wrapper_type = ME_WRAPPER_TYPE_SUBD;
   }
 
-  return me->runtime.mesh_eval;
+  return me->runtime->mesh_eval;
 }
 
 Mesh *BKE_mesh_wrapper_ensure_subdivision(Mesh *me)
 {
-  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)me->runtime.eval_mutex;
+  ThreadMutex *mesh_eval_mutex = (ThreadMutex *)me->runtime->eval_mutex;
   BLI_mutex_lock(mesh_eval_mutex);
 
-  if (me->runtime.wrapper_type == ME_WRAPPER_TYPE_SUBD) {
+  if (me->runtime->wrapper_type == ME_WRAPPER_TYPE_SUBD) {
     BLI_mutex_unlock(mesh_eval_mutex);
-    return me->runtime.mesh_eval;
+    return me->runtime->mesh_eval;
   }
 
   Mesh *result;
diff --git a/source/blender/blenkernel/intern/modifier.cc b/source/blender/blenkernel/intern/modifier.cc
index 2eb8ef70a4d..fc1a0f47684 100644
--- a/source/blender/blenkernel/intern/modifier.cc
+++ b/source/blender/blenkernel/intern/modifier.cc
@@ -963,9 +963,9 @@ void BKE_modifier_path_init(char *path, int path_maxlen, const char *name)
  */
 static void modwrap_dependsOnNormals(Mesh *me)
 {
-  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+  switch (me->runtime->wrapper_type) {
     case ME_WRAPPER_TYPE_BMESH: {
-      EditMeshData *edit_data = me->runtime.edit_data;
+      EditMeshData *edit_data = me->runtime->edit_data;
       if (edit_data->vertexCos) {
         /* Note that 'ensure' is acceptable here since these values aren't modified in-place.
          * If that changes we'll need to recalculate. */
@@ -993,7 +993,7 @@ struct Mesh *BKE_modifier_modify_mesh(ModifierData *md,
 {
   const ModifierTypeInfo *mti = BKE_modifier_get_info(ModifierType(md->type));
 
-  if (me->runtime.wrapper_type == ME_WRAPPER_TYPE_BMESH) {
+  if (me->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH) {
     if ((mti->flags & eModifierTypeFlag_AcceptsBMesh) == 0) {
       BKE_mesh_wrapper_ensure_mdata(me);
     }
diff --git a/source/blender/blenkernel/intern/multires.cc b/source/blender/blenkernel/intern/multires.cc
index 61cfe043927..5ff9602650e 100644
--- a/source/blender/blenkernel/intern/multires.cc
+++ b/source/blender/blenkernel/intern/multires.cc
@@ -397,7 +397,7 @@ void multires_mark_as_modified(Depsgraph *depsgraph, Object *object, MultiresMod
    * In a longer term maybe special dependency graph tag can help sanitizing this a bit. */
   Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
   Mesh *mesh = static_cast<Mesh *>(object_eval->data);
-  SubdivCCG *subdiv_ccg = mesh->runtime.subdiv_ccg;
+  SubdivCCG *subdiv_ccg = mesh->runtime->subdiv_ccg;
   if (subdiv_ccg == nullptr) {
     return;
   }
diff --git a/source/blender/blenkernel/intern/object.cc b/source/blender/blenkernel/intern/object.cc
index 9417d1afc7e..2d949fb5c65 100644
--- a/source/blender/blenkernel/intern/object.cc
+++ b/source/blender/blenkernel/intern/object.cc
@@ -1691,7 +1691,7 @@ static void object_update_from_subsurf_ccg(Object *object)
   if (mesh_eval == nullptr) {
     return;
   }
-  SubdivCCG *subdiv_ccg = mesh_eval->runtime.subdiv_ccg;
+  SubdivCCG *subdiv_ccg = mesh_eval->runtime->subdiv_ccg;
   if (subdiv_ccg == nullptr) {
     return;
   }
@@ -1699,7 +1699,7 @@ static void object_update_from_subsurf_ccg(Object *object)
   if (!subdiv_ccg->dirty.coords && !subdiv_ccg->dirty.hidden) {
     return;
   }
-  const int tot_level = mesh_eval->runtime.subdiv_ccg_tot_level;
+  const int tot_level = mesh_eval->runtime->subdiv_ccg_tot_level;
   Object *object_orig = DEG_get_original_object(object);
   Mesh *mesh_orig = (Mesh *)object_orig->data;
   multiresModifier_reshapeFromCCG(tot_level, mesh_orig, subdiv_ccg);
@@ -3218,7 +3218,7 @@ static void give_parvert(Object *par, int nr, float vec[3])
       int count = 0;
       int numVerts = me_eval->totvert;
 
-      if (em && me_eval->runtime.wrapper_type == ME_WRAPPER_TYPE_BMESH) {
+      if (em && me_eval->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH) {
         numVerts = em->bm->totvert;
         if (em->bm->elem_table_dirty & BM_VERT) {
 #ifdef VPARENT_THREADING_HACK
@@ -3233,8 +3233,8 @@ static void give_parvert(Object *par, int nr, float vec[3])
 #endif
         }
         if (nr < numVerts) {
-          if (me_eval && me_eval->runtime.edit_data && me_eval->runtime.edit_data->vertexCos) {
-            add_v3_v3(vec, me_eval->runtime.edit_data->vertexCos[nr]);
+          if (me_eval && me_eval->runtime->edit_data && me_eval->runtime->edit_data->vertexCos) {
+            add_v3_v3(vec, me_eval->runtime->edit_data->vertexCos[nr]);
           }
           else {
             const BMVert *v = BM_vert_at_index(em->bm, nr);
diff --git a/source/blender/blenkernel/intern/object_dupli.cc b/source/blender/blenkernel/intern/object_dupli.cc
index 306e508dc83..96da99af97e 100644
--- a/source/blender/blenkernel/intern/object_dupli.cc
+++ b/source/blender/blenkernel/intern/object_dupli.cc
@@ -423,8 +423,8 @@ static const Mesh *mesh_data_from_duplicator_object(Object *ob,
     /* Note that this will only show deformation if #eModifierMode_OnCage is enabled.
      * We could change this but it matches 2.7x behavior. */
     me_eval = BKE_object_get_editmesh_eval_cage(ob);
-    if ((me_eval == nullptr) || (me_eval->runtime.wrapper_type == ME_WRAPPER_TYPE_BMESH)) {
-      EditMeshData *emd = me_eval ? me_eval->runtime.edit_data : nullptr;
+    if ((me_eval == nullptr) || (me_eval->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH)) {
+      EditMeshData *emd = me_eval ? me_eval->runtime->edit_data : nullptr;
 
       /* Only assign edit-mesh in the case we can't use `me_eval`. */
       *r_em = em;
diff --git a/source/blender/blenkernel/intern/object_update.cc b/source/blender/blenkernel/intern/object_update.cc
index 5328d956cee..f6a765e8809 100644
--- a/source/blender/blenkernel/intern/object_update.cc
+++ b/source/blender/blenkernel/intern/object_update.cc
@@ -373,7 +373,7 @@ void BKE_object_select_update(Depsgraph *depsgraph, Object *object)
   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
   if (object->type == OB_MESH && !object->runtime.is_data_eval_owned) {
     Mesh *mesh_input = (Mesh *)object->runtime.data_orig;
-    Mesh_Runtime *mesh_runtime = &mesh_input->runtime;
+    blender::bke::MeshRuntime *mesh_runtime = mesh_input->runtime;
     BLI_mutex_lock(static_cast<ThreadMutex *>(mesh_runtime->eval_mutex));
     BKE_object_data_select_update(depsgraph, static_cast<ID *>(object->data));
     BLI_mutex_unlock(static_cast<ThreadMutex *>(mesh_runtime->eval_mutex));
diff --git a/source/blender/blenkernel/intern/paint.cc b/source/blender/blenkernel/intern/paint.cc
index fbb7642c067..d45ce776b64 100644
--- a/source/blender/blenkernel/intern/paint.cc
+++ b/source/blender/blenkernel/intern/paint.cc
@@ -1743,7 +1743,7 @@ static void sculpt_update_object(
 
   ss->hide_poly = (bool *)CustomData_get_layer_named(&me->pdata, CD_PROP_BOOL, ".hide_poly");
 
-  ss->subdiv_ccg = me_eval->runtime.subdiv_ccg;
+  ss->subdiv_ccg = me_eval->runtime->subdiv_ccg;
 
   PBVH *pbvh = BKE_sculpt_object_pbvh_ensure(depsgraph, ob);
   BLI_assert(pbvh == ss->pbvh);
@@ -2258,7 +2258,7 @@ PBVH *BKE_sculpt_object_pbvh_ensure(Depsgraph *depsgraph, Object *ob)
     if (BKE_pbvh_type(pbvh) == PBVH_GRIDS) {
       Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
       Mesh *mesh_eval = static_cast<Mesh *>(object_eval->data);
-      SubdivCCG *subdiv_ccg = mesh_eval->runtime.subdiv_ccg;
+      SubdivCCG *subdiv_ccg = mesh_eval->runtime->subdiv_ccg;
       if (subdiv_ccg != nullptr) {
         BKE_sculpt_bvh_update_from_ccg(pbvh, subdiv_ccg);
       }
@@ -2277,8 +2277,8 @@ PBVH *BKE_sculpt_object_pbvh_ensure(Depsgraph *depsgraph, Object *ob)
   else {
     Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
     Mesh *mesh_eval = static_cast<Mesh *>(object_eval->data);
-    if (mesh_eval->runtime.subdiv_ccg != nullptr) {
-      pbvh = build_pbvh_from_ccg(ob, mesh_eval->runtime.subdiv_ccg, respect_hide);
+    if (mesh_eval->runtime->subdiv_ccg != nullptr) {
+      pbvh = build_pbvh_from_ccg(ob, mesh_eval->runtime->subdiv_ccg, respect_hide);
     }
     else if (ob->type == OB_MESH) {
       Mesh *me_eval_deform = object_eval->runtime.mesh_deform_eval;
diff --git a/source/blender/blenkernel/intern/particle.c b/source/blender/blenkernel/intern/particle.c
index 6d42d344b86..d6dd3cf0dbb 100644
--- a/source/blender/blenkernel/intern/particle.c
+++ b/source/blender/blenkernel/intern/particle.c
@@ -60,6 +60,7 @@
 #include "BKE_material.h"
 #include "BKE_mesh.h"
 #include "BKE_mesh_legacy_convert.h"
+#include "BKE_mesh_runtime.h"
 #include "BKE_modifier.h"
 #include "BKE_object.h"
 #include "BKE_particle.h"
@@ -1933,7 +1934,7 @@ int psys_particle_dm_face_lookup(Mesh *mesh_final,
     index_mf_to_mpoly_deformed = CustomData_get_layer(&mesh_original->fdata, CD_ORIGINDEX);
   }
   else {
-    BLI_assert(mesh_final->runtime.deformed_only);
+    BLI_assert(BKE_mesh_is_deformed_only(mesh_final));
     index_mf_to_mpoly_deformed = index_mf_to_mpoly;
   }
   BLI_assert(index_mf_to_mpoly_deformed);
@@ -2023,7 +2024,7 @@ static int psys_map_index_on_dm(Mesh *mesh,
     return 0;
   }
 
-  if (mesh->runtime.deformed_only || index_dmcache == DMCACHE_ISCHILD) {
+  if (BKE_mesh_is_deformed_only(mesh) || index_dmcache == DMCACHE_ISCHILD) {
     /* for meshes that are either only deformed or for child particles, the
      * index and fw do not require any mapping, so we can directly use it */
     if (from == PART_FROM_VERT) {
diff --git a/source/blender/blenkernel/intern/particle_distribute.c b/source/blender/blenkernel/intern/particle_distribute.c
index 4c56a8a9275..0301b83a043 100644
--- a/source/blender/blenkernel/intern/particle_distribute.c
+++ b/source/blender/blenkernel/intern/particle_distribute.c
@@ -29,6 +29,7 @@
 #include "BKE_lib_id.h"
 #include "BKE_mesh.h"
 #include "BKE_mesh_legacy_convert.h"
+#include "BKE_mesh_runtime.h"
 #include "BKE_object.h"
 #include "BKE_particle.h"
 
@@ -899,7 +900,7 @@ static int psys_thread_context_init_distribute(ParticleThreadContext *ctx,
     return 0;
   }
 
-  if (!final_mesh->runtime.deformed_only &&
+  if (!BKE_mesh_is_deformed_only(final_mesh) &&
       !CustomData_get_layer(&final_mesh->fdata, CD_ORIGINDEX)) {
     printf(
         "Can't create particles with the current modifier stack, disable destructive modifiers\n");
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index dec874caff4..c72bbe2fd08 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -48,6 +48,7 @@
 #include "BKE_lib_id.h"
 #include "BKE_lib_query.h"
 #include "BKE_mesh_legacy_convert.h"
+#include "BKE_mesh_runtime.h"
 #include "BKE_particle.h"
 
 #include "BKE_bvhutils.h"
@@ -319,7 +320,7 @@ void psys_calc_dmcache(Object *ob, Mesh *mesh_final, Mesh *mesh_original, Partic
   PARTICLE_P;
 
   /* CACHE LOCATIONS */
-  if (!mesh_final->runtime.deformed_only) {
+  if (!BKE_mesh_is_deformed_only(mesh_final)) {
     /* Will use later to speed up subsurf/evaluated mesh. */
     LinkNode *node, *nodedmelem, **nodearray;
     int totdmelem, totelem, i;
diff --git a/source/blender/blenkernel/intern/rigidbody.c b/source/blender/blenkernel/intern/rigidbody.c
index 6b4cddb05f2..ffc6bc8d7a3 100644
--- a/source/blender/blenkernel/intern/rigidbody.c
+++ b/source/blender/blenkernel/intern/rigidbody.c
@@ -404,7 +404,7 @@ static rbCollisionShape *rigidbody_get_shape_trimesh_from_mesh(Object *ob)
     const MVert *mvert = BKE_mesh_verts(mesh);
     totvert = mesh->totvert;
     looptri = BKE_mesh_runtime_looptri_ensure(mesh);
-    tottri = mesh->runtime.looptris.len;
+    tottri = BKE_mesh_runtime_looptri_len(mesh);
     const MLoop *mloop = BKE_mesh_loops(mesh);
 
     /* sanity checking - potential case when no data will be present */
@@ -679,7 +679,7 @@ void BKE_rigidbody_calc_volume(Object *ob, float *r_vol)
         const MVert *mvert = BKE_mesh_verts(mesh);
         totvert = mesh->totvert;
         lt = BKE_mesh_runtime_looptri_ensure(mesh);
-        tottri = mesh->runtime.looptris.len;
+        tottri = BKE_mesh_runtime_looptri_len(mesh);
         const MLoop *mloop = BKE_mesh_loops(mesh);
 
         if (totvert > 0 && tottri > 0) {
@@ -753,7 +753,7 @@ void BKE_rigidbody_calc_center_of_mass(Object *ob, float r_center[3])
         const MVert *mvert = BKE_mesh_verts(mesh);
         totvert = mesh->totvert;
         looptri = BKE_mesh_runtime_looptri_ensure(mesh);
-        tottri = mesh->runtime.looptris.len;
+        tottri = BKE_mesh_runtime_looptri_len(mesh);
         const MLoop *mloop = BKE_mesh_loops(mesh);
 
         if (totvert > 0 && tottri > 0) {
diff --git a/source/blender/blenkernel/intern/shrinkwrap.cc b/source/blender/blenkernel/intern/shrinkwrap.cc
index 703b012d170..65226a5db9d 100644
--- a/source/blender/blenkernel/intern/shrinkwrap.cc
+++ b/source/blender/blenkernel/intern/shrinkwrap.cc
@@ -140,7 +140,7 @@ bool BKE_shrinkwrap_init_tree(
   }
 
   if (shrinkType == MOD_SHRINKWRAP_TARGET_PROJECT) {
-    data->boundary = mesh->runtime.shrinkwrap_data;
+    data->boundary = mesh->runtime->shrinkwrap_data;
   }
 
   return true;
@@ -153,7 +153,7 @@ void BKE_shrinkwrap_free_tree(ShrinkwrapTreeData *data)
 
 void BKE_shrinkwrap_discard_boundary_data(Mesh *mesh)
 {
-  ShrinkwrapBoundaryData *data = mesh->runtime.shrinkwrap_data;
+  ShrinkwrapBoundaryData *data = mesh->runtime->shrinkwrap_data;
 
   if (data != nullptr) {
     MEM_freeN((void *)data->edge_is_boundary);
@@ -164,7 +164,7 @@ void BKE_shrinkwrap_discard_boundary_data(Mesh *mesh)
     MEM_freeN(data);
   }
 
-  mesh->runtime.shrinkwrap_data = nullptr;
+  mesh->runtime->shrinkwrap_data = nullptr;
 }
 
 /* Accumulate edge for average boundary edge direction. */
@@ -327,7 +327,7 @@ void BKE_shrinkwrap_compute_boundary_data(Mesh *mesh)
 {
   BKE_shrinkwrap_discard_boundary_data(mesh);
 
-  mesh->runtime.shrinkwrap_data = shrinkwrap_build_boundary_data(mesh);
+  mesh->runtime->shrinkwrap_data = shrinkwrap_build_boundary_data(mesh);
 }
 
 /**
diff --git a/source/blender/blenkernel/intern/subdiv_ccg.cc b/source/blender/blenkernel/intern/subdiv_ccg.cc
index 8ccf2c9cec5..bf09be444b1 100644
--- a/source/blender/blenkernel/intern/subdiv_ccg.cc
+++ b/source/blender/blenkernel/intern/subdiv_ccg.cc
@@ -615,7 +615,7 @@ Mesh *BKE_subdiv_to_ccg_mesh(Subdiv *subdiv,
     return nullptr;
   }
   Mesh *result = BKE_mesh_new_nomain_from_template(coarse_mesh, 0, 0, 0, 0, 0);
-  result->runtime.subdiv_ccg = subdiv_ccg;
+  result->runtime->subdiv_ccg = subdiv_ccg;
   return result;
 }
 
diff --git a/source/blender/blenkernel/intern/subdiv_mesh.cc b/source/blender/blenkernel/intern/subdiv_mesh.cc
index 00183ea90c2..3b97c1f5e68 100644
--- a/source/blender/blenkernel/intern/subdiv_mesh.cc
+++ b/source/blender/blenkernel/intern/subdiv_mesh.cc
@@ -528,9 +528,9 @@ static bool subdiv_mesh_topology_info(const SubdivForeachContext *foreach_contex
       subdiv_context->coarse_mesh, num_vertices, num_edges, 0, num_loops, num_polygons, mask);
   subdiv_mesh_ctx_cache_custom_data_layers(subdiv_context);
   subdiv_mesh_prepare_accumulator(subdiv_context, num_vertices);
-  MEM_SAFE_FREE(subdiv_context->subdiv_mesh->runtime.subsurf_face_dot_tags);
-  subdiv_context->subdiv_mesh->runtime.subsurf_face_dot_tags = BLI_BITMAP_NEW(num_vertices,
-                                                                              __func__);
+  MEM_SAFE_FREE(subdiv_context->subdiv_mesh->runtime->subsurf_face_dot_tags);
+  subdiv_context->subdiv_mesh->runtime->subsurf_face_dot_tags = BLI_BITMAP_NEW(num_vertices,
+                                                                               __func__);
   return true;
 }
 
@@ -595,7 +595,7 @@ static void evaluate_vertex_and_apply_displacement_copy(const SubdivMeshContext
   /* Evaluate undeformed texture coordinate. */
   subdiv_vertex_orco_evaluate(ctx, ptex_face_index, u, v, subdiv_vertex_index);
   /* Remove face-dot flag. This can happen if there is more than one subsurf modifier. */
-  BLI_BITMAP_DISABLE(ctx->subdiv_mesh->runtime.subsurf_face_dot_tags, subdiv_vertex_index);
+  BLI_BITMAP_DISABLE(ctx->subdiv_mesh->runtime->subsurf_face_dot_tags, subdiv_vertex_index);
 }
 
 static void evaluate_vertex_and_apply_displacement_interpolate(
@@ -753,7 +753,7 @@ static void subdiv_mesh_tag_center_vertex(const MPoly *coarse_poly,
                                           Mesh *subdiv_mesh)
 {
   if (subdiv_mesh_is_center_vertex(coarse_poly, u, v)) {
-    BLI_BITMAP_ENABLE(subdiv_mesh->runtime.subsurf_face_dot_tags, subdiv_vertex_index);
+    BLI_BITMAP_ENABLE(subdiv_mesh->runtime->subsurf_face_dot_tags, subdiv_vertex_index);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/subdiv_modifier.cc b/source/blender/blenkernel/intern/subdiv_modifier.cc
index a5529e9b8fa..84b772db045 100644
--- a/source/blender/blenkernel/intern/subdiv_modifier.cc
+++ b/source/blender/blenkernel/intern/subdiv_modifier.cc
@@ -11,6 +11,7 @@
 #include "DNA_scene_types.h"
 #include "DNA_userdef_types.h"
 
+#include "BKE_mesh.h"
 #include "BKE_modifier.h"
 #include "BKE_subdiv.h"
 
@@ -143,7 +144,7 @@ bool BKE_subsurf_modifier_can_do_gpu_subdiv(const Scene *scene,
 
 bool BKE_subsurf_modifier_has_gpu_subdiv(const Mesh *mesh)
 {
-  SubsurfRuntimeData *runtime_data = mesh->runtime.subsurf_runtime_data;
+  SubsurfRuntimeData *runtime_data = mesh->runtime->subsurf_runtime_data;
   return runtime_data && runtime_data->has_gpu_subdiv;
 }