Modifier: move edit-mesh calculation from DerivedMesh to Mesh

1 files changed, 143 insertions, 180 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index e4c2c935a33..208803a8de9 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -463,12 +463,6 @@ void DM_ensure_normals(DerivedMesh *dm)
 	BLI_assert((dm->dirty & DM_DIRTY_NORMALS) == 0);
 }
 
-static void DM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, float split_angle)
-{
-	dm->calcLoopNormals(dm, use_split_normals, split_angle);
-	dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
-}
-
 /* note: until all modifiers can take MPoly's as input,
  * use this at the start of modifiers  */
 void DM_ensure_tessface(DerivedMesh *dm)
@@ -1169,7 +1163,7 @@ static float (*get_editbmesh_orco_verts(BMEditMesh *em))[3]
 }
 
 /* orco custom data layer */
-static float (*get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *free))[3]
+static float (*get_orco_coords(Object *ob, BMEditMesh *em, int layer, int *free))[3]
 {
 	*free = 0;
 
@@ -1200,29 +1194,6 @@ static float (*get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *fr
 	return NULL;
 }
 
-static DerivedMesh *create_orco_dm(Object *ob, Mesh *me, BMEditMesh *em, int layer)
-{
-	DerivedMesh *dm;
-	float (*orco)[3];
-	int free;
-
-	if (em) {
-		dm = CDDM_from_editbmesh(em, false, false);
-	}
-	else {
-		dm = CDDM_from_mesh(me);
-	}
-
-	orco = get_orco_coords_dm(ob, em, layer, &free);
-
-	if (orco) {
-		CDDM_apply_vert_coords(dm, orco);
-		if (free) MEM_freeN(orco);
-	}
-
-	return dm;
-}
-
 static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
 {
 	Mesh *mesh;
@@ -1236,7 +1207,7 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
 		mesh = BKE_mesh_copy_for_eval(me, true);
 	}
 
-	orco = get_orco_coords_dm(ob, em, layer, &free);
+	orco = get_orco_coords(ob, em, layer, &free);
 
 	if (orco) {
 		BKE_mesh_apply_vert_coords(mesh, orco);
@@ -1246,44 +1217,6 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
 	return mesh;
 }
 
-static void add_orco_dm(
-        Object *ob, BMEditMesh *em, DerivedMesh *dm,
-        DerivedMesh *orcodm, int layer)
-{
-	float (*orco)[3], (*layerorco)[3];
-	int totvert, free;
-
-	totvert = dm->getNumVerts(dm);
-
-	if (orcodm) {
-		orco = MEM_calloc_arrayN(totvert, sizeof(float[3]), "dm orco");
-		free = 1;
-
-		if (orcodm->getNumVerts(orcodm) == totvert)
-			orcodm->getVertCos(orcodm, orco);
-		else
-			dm->getVertCos(dm, orco);
-	}
-	else {
-		/* TODO(sybren): totvert should potentially change here, as ob->data
-		 * or em may have a different number of vertices than dm. */
-		orco = get_orco_coords_dm(ob, em, layer, &free);
-	}
-
-	if (orco) {
-		if (layer == CD_ORCO)
-			BKE_mesh_orco_verts_transform(ob->data, orco, totvert, 0);
-
-		if (!(layerorco = DM_get_vert_data_layer(dm, layer))) {
-			DM_add_vert_layer(dm, layer, CD_CALLOC, NULL);
-			layerorco = DM_get_vert_data_layer(dm, layer);
-		}
-
-		memcpy(layerorco, orco, sizeof(float) * 3 * totvert);
-		if (free) MEM_freeN(orco);
-	}
-}
-
 static void add_orco_mesh(
         Object *ob, BMEditMesh *em, Mesh *mesh,
         Mesh *orco_mesh, int layer)
@@ -1306,7 +1239,7 @@ static void add_orco_mesh(
 	else {
 		/* TODO(sybren): totvert should potentially change here, as ob->data
 		 * or em may have a different number of vertices than dm. */
-		orco = get_orco_coords_dm(ob, em, layer, &free);
+		orco = get_orco_coords(ob, em, layer, &free);
 	}
 
 	if (orco) {
@@ -1326,7 +1259,7 @@ static void add_orco_mesh(
 	}
 }
 
-static void DM_update_statvis_color(const Scene *scene, Object *ob, DerivedMesh *dm)
+static void UNUSED_FUNCTION(DM_update_statvis_color)(const Scene *scene, Object *ob, DerivedMesh *dm)
 {
 	BMEditMesh *em = BKE_editmesh_from_object(ob);
 
@@ -1433,21 +1366,6 @@ static void UNUSED_FUNCTION(add_shapekey_layers)(DerivedMesh *dm, Mesh *me, Obje
  *
  * \note tessfaces should already be calculated.
  */
-static void dm_ensure_display_normals(DerivedMesh *dm)
-{
-	/* Note: dm *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.).
-	 *       We do not use it here, though. And it should be tagged as temp!
-	 */
-	/* BLI_assert((CustomData_has_layer(&dm->polyData, CD_NORMAL) == false)); */
-
-	if ((dm->type == DM_TYPE_CDDM) &&
-	    ((dm->dirty & DM_DIRTY_NORMALS) || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false))
-	{
-		/* if normals are dirty we want to calculate vertex normals too */
-		CDDM_calc_normals_mapping_ex(dm, (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
-	}
-}
-
 static void mesh_ensure_display_normals(Mesh *mesh)
 {
 	/* Note: mesh *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.).
@@ -1979,7 +1897,7 @@ float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
 	return cos;
 }
 
-bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *dm)
+bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, bool has_prev_mesh)
 {
 	const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 	const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
@@ -1988,7 +1906,7 @@ bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *
 		return false;
 	}
 
-	if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && dm) {
+	if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && has_prev_mesh) {
 		modifier_setError(md, "Modifier requires original data, bad stack position");
 		return false;
 	}
@@ -1996,21 +1914,42 @@ bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *
 	return true;
 }
 
+
+/* TODO(campbell): support mesh with only an edit-mesh which is lazy initialized. */
+static Mesh *mesh_from_editmesh_with_coords(
+        BMEditMesh *em, CustomDataMask data_mask, float (*vertexCos)[3])
+{
+	Mesh *me = BKE_bmesh_to_mesh_nomain(
+	        em->bm,
+	        &(struct BMeshToMeshParams){
+	            .cd_mask_extra = data_mask,
+	        });
+	if (vertexCos) {
+		/* We will own this array in the future. */
+		BKE_mesh_apply_vert_coords(me, vertexCos);
+		MEM_freeN(vertexCos);
+	}
+	return me;
+}
+
 static void editbmesh_calc_modifiers(
         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
         BMEditMesh *em, CustomDataMask dataMask,
         /* return args */
-        DerivedMesh **r_cage, DerivedMesh **r_final)
+        Mesh **r_cage, Mesh **r_final)
 {
 	ModifierData *md;
 	float (*deformedVerts)[3] = NULL;
 	CustomDataMask mask = 0, append_mask = 0;
-	DerivedMesh *dm = NULL, *orcodm = NULL;
+	Mesh *me = NULL;
+	Mesh *me_orco = NULL;
 	int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
 	CDMaskLink *datamasks, *curr;
 	const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
 
+#if 0
 	const bool do_init_statvis = false;
+#endif
 	VirtualModifierData virtualModifierData;
 
 	/* TODO(sybren): do we really need multiple objects, or shall we change the flags where needed? */
@@ -2019,12 +1958,11 @@ static void editbmesh_calc_modifiers(
 	const ModifierEvalContext mectx_cache = {depsgraph, ob, MOD_APPLY_USECACHE};
 
 	const bool do_loop_normals = (((Mesh *)(ob->data))->flag & ME_AUTOSMOOTH) != 0;
-	const float loop_normals_split_angle = ((Mesh *)(ob->data))->smoothresh;
 
 	modifiers_clearErrors(ob);
 
 	if (r_cage && cageIndex == -1) {
-		*r_cage = getEditDerivedBMesh(em, ob, dataMask, NULL);
+		*r_cage = mesh_from_editmesh_with_coords(em, dataMask, NULL);
 	}
 
 	md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
@@ -2036,15 +1974,16 @@ static void editbmesh_calc_modifiers(
 	for (i = 0; md; i++, md = md->next, curr = curr->next) {
 		const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 
-		if (!editbmesh_modifier_is_enabled(scene, md, dm)) {
+		if (!editbmesh_modifier_is_enabled(scene, md, me != NULL)) {
 			continue;
 		}
 
 		/* add an orco layer if needed by this modifier */
-		if (dm && mti->requiredDataMask) {
+		if (me && mti->requiredDataMask) {
 			mask = mti->requiredDataMask(ob, md);
-			if (mask & CD_MASK_ORCO)
-				add_orco_dm(ob, em, dm, orcodm, CD_ORCO);
+			if (mask & CD_MASK_ORCO) {
+				add_orco_mesh(ob, em, me, me_orco, CD_ORCO);
+			}
 		}
 
 		/* How to apply modifier depends on (a) what we already have as
@@ -2055,15 +1994,12 @@ static void editbmesh_calc_modifiers(
 		if (mti->type == eModifierTypeType_OnlyDeform) {
 			/* No existing verts to deform, need to build them. */
 			if (!deformedVerts) {
-				if (dm) {
+				if (me) {
 					/* Deforming a derived mesh, read the vertex locations
 					 * out of the mesh and deform them. Once done with this
 					 * run of deformers verts will be written back.
 					 */
-					numVerts = dm->getNumVerts(dm);
-					deformedVerts =
-					    MEM_malloc_arrayN(numVerts, sizeof(*deformedVerts), "dfmv");
-					dm->getVertCos(dm, deformedVerts);
+					deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
 				}
 				else {
 					deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
@@ -2071,60 +2007,63 @@ static void editbmesh_calc_modifiers(
 			}
 
 			if (mti->deformVertsEM)
-				modwrap_deformVertsEM_DM_deprecated(md, &mectx, em, dm, deformedVerts, numVerts);
+				modwrap_deformVertsEM(md, &mectx, em, me, deformedVerts, numVerts);
 			else
-				modwrap_deformVerts_DM_deprecated(md, &mectx, dm, deformedVerts, numVerts);
+				modwrap_deformVerts(md, &mectx, me, deformedVerts, numVerts);
 		}
 		else {
-			DerivedMesh *ndm;
+			Mesh *me_next;
 
 			/* apply vertex coordinates or build a DerivedMesh as necessary */
-			if (dm) {
+			if (me) {
 				if (deformedVerts) {
-					DerivedMesh *tdm = CDDM_copy(dm);
-					if (!(r_cage && dm == *r_cage)) {
-						dm->release(dm);
-					}
-					dm = tdm;
+					Mesh *me_temp = BKE_mesh_copy_for_eval(me, false);
 
-					CDDM_apply_vert_coords(dm, deformedVerts);
+					if (!(r_cage && me == *r_cage)) {
+						BKE_id_free(NULL, me);
+					}
+					me = me_temp;
+					BKE_mesh_apply_vert_coords(me, deformedVerts);
 				}
-				else if (r_cage && dm == *r_cage) {
-					/* dm may be changed by this modifier, so we need to copy it */
-					dm = CDDM_copy(dm);
+				else if (r_cage && me == *r_cage) {
+					/* 'me' may be changed by this modifier, so we need to copy it. */
+					me = BKE_mesh_copy_for_eval(me, false);
 				}
 
 			}
 			else {
-				dm = CDDM_from_editbmesh(em, false, false);
-				ASSERT_IS_VALID_DM(dm);
+				me = BKE_bmesh_to_mesh_nomain(em->bm, &(struct BMeshToMeshParams){0});
+				ASSERT_IS_VALID_MESH(me);
 
 				if (deformedVerts) {
-					CDDM_apply_vert_coords(dm, deformedVerts);
+					BKE_mesh_apply_vert_coords(me, deformedVerts);
 				}
 			}
 
 			/* create an orco derivedmesh in parallel */
 			mask = curr->mask;
 			if (mask & CD_MASK_ORCO) {
-				if (!orcodm)
-					orcodm = create_orco_dm(ob, ob->data, em, CD_ORCO);
+				if (!me_orco) {
+					me_orco = create_orco_mesh(ob, ob->data, em, CD_ORCO);
+				}
 
 				mask &= ~CD_MASK_ORCO;
-				DM_set_only_copy(orcodm, mask | CD_MASK_ORIGINDEX);
+				mesh_set_only_copy(me_orco, mask | CD_MASK_ORIGINDEX);
 
 				if (mti->applyModifierEM) {
-					ndm = modwrap_applyModifierEM_DM_deprecated(md, &mectx_orco, em, orcodm);
+					me_next = modwrap_applyModifierEM(md, &mectx_orco, em, me_orco);
 				}
 				else {
-					ndm = modwrap_applyModifier_DM_deprecated(md, &mectx_orco, orcodm);
+					me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
 				}
-				ASSERT_IS_VALID_DM(ndm);
+				ASSERT_IS_VALID_MESH(me_next);
 
-				if (ndm) {
+				if (me_next) {
 					/* if the modifier returned a new dm, release the old one */
-					if (orcodm && orcodm != ndm) orcodm->release(orcodm);
-					orcodm = ndm;
+					if (me_orco && me_orco != me_next) {
+						BKE_id_free(NULL, me_orco);
+					}
+					me_orco = me_next;
 				}
 			}
 
@@ -2132,52 +2071,53 @@ static void editbmesh_calc_modifiers(
 			mask |= append_mask;
 			mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */
 
-			DM_set_only_copy(dm, mask | CD_MASK_ORIGINDEX);
+			mesh_set_only_copy(me, mask | CD_MASK_ORIGINDEX);
 
 			if (mask & CD_MASK_ORIGSPACE_MLOOP) {
-				if (!CustomData_has_layer(&dm->loopData, CD_ORIGSPACE_MLOOP)) {
-					DM_add_loop_layer(dm, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL);
-					DM_init_origspace(dm);
+				if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
+					CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
+					mesh_init_origspace(me);
 				}
 			}
 
-			if (mti->applyModifierEM)
-				ndm = modwrap_applyModifierEM_DM_deprecated(md, &mectx_cache, em, dm);
-			else
-				ndm = modwrap_applyModifier_DM_deprecated(md, &mectx_cache, dm);
-			ASSERT_IS_VALID_DM(ndm);
-
-			if (ndm) {
-				if (dm && dm != ndm)
-					dm->release(dm);
+			if (mti->applyModifierEM) {
+				me_next = modwrap_applyModifierEM(md, &mectx_cache, em, me);
+			}
+			else {
+				me_next = modwrap_applyModifier(md, &mectx_cache, me);
+			}
+			ASSERT_IS_VALID_MESH(me_next);
 
-				dm = ndm;
+			if (me_next) {
+				if (me && me != me_next) {
+					BKE_id_free(NULL, me);
+				}
+				me = me_next;
 
 				if (deformedVerts) {
 					MEM_freeN(deformedVerts);
 					deformedVerts = NULL;
 				}
 			}
-
-			dm->deformedOnly = false;
+			me->runtime.deformed_only = false;
 		}
 
 		if (r_cage && i == cageIndex) {
-			if (dm && deformedVerts) {
-				*r_cage = CDDM_copy(dm);
-				CDDM_apply_vert_coords(*r_cage, deformedVerts);
+			if (me && deformedVerts) {
+				*r_cage = BKE_mesh_copy_for_eval(me, false);
+				BKE_mesh_apply_vert_coords(*r_cage, deformedVerts);
 			}
-			else if (dm) {
-				*r_cage = dm;
+			else if (me) {
+				*r_cage = me;
 			}
 			else {
-				struct Mesh *mesh = ob->data;
-				if (mesh->id.tag & LIB_TAG_COPIED_ON_WRITE) {
-					BKE_mesh_runtime_ensure_edit_data(mesh);
-					mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
+				struct Mesh *me_orig = ob->data;
+				if (me_orig->id.tag & LIB_TAG_COPIED_ON_WRITE) {
+					BKE_mesh_runtime_ensure_edit_data(me_orig);
+					me_orig->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
 				}
-				*r_cage = getEditDerivedBMesh(
-				        em, ob, mask,
+				*r_cage = mesh_from_editmesh_with_coords(
+				        em, mask,
 				        deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
 			}
 		}
@@ -2189,25 +2129,27 @@ static void editbmesh_calc_modifiers(
 	 * to apply these back onto the DerivedMesh. If we have no DerivedMesh
 	 * then we need to build one.
 	 */
-	if (dm && deformedVerts) {
-		*r_final = CDDM_copy(dm);
+	if (me && deformedVerts) {
+		*r_final = BKE_mesh_copy_for_eval(me, false);
 
-		if (!(r_cage && dm == *r_cage)) {
-			dm->release(dm);
+		if (!(r_cage && me == *r_cage)) {
+			BKE_id_free(NULL, me);
 		}
-
-		CDDM_apply_vert_coords(*r_final, deformedVerts);
+		BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
 	}
-	else if (dm) {
-		*r_final = dm;
+	else if (me) {
+		*r_final = me;
 	}
 	else if (!deformedVerts && r_cage && *r_cage) {
 		/* cage should already have up to date normals */
 		*r_final = *r_cage;
 
+#if 0
 		/* In this case, we should never have weight-modifying modifiers in stack... */
-		if (do_init_statvis)
+		if (do_init_statvis) {
 			DM_update_statvis_color(scene, ob, *r_final);
+		}
+#endif
 	}
 	else {
 		/* this is just a copy of the editmesh, no need to calc normals */
@@ -2218,19 +2160,24 @@ static void editbmesh_calc_modifiers(
 				MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
 			mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
 		}
-		*r_final = getEditDerivedBMesh(em, ob, dataMask, deformedVerts);
+		*r_final = mesh_from_editmesh_with_coords(em, dataMask, deformedVerts);
 		deformedVerts = NULL;
 
+#if 0
 		/* In this case, we should never have weight-modifying modifiers in stack... */
-		if (do_init_statvis)
+		if (do_init_statvis) {
 			DM_update_statvis_color(scene, ob, *r_final);
+		}
+#endif
 	}
 
 	if (do_loop_normals) {
 		/* Compute loop normals */
-		DM_calc_loop_normals(*r_final, do_loop_normals, loop_normals_split_angle);
+		BKE_mesh_calc_normals_split(*r_final);
+		BKE_mesh_tessface_clear(*r_final);
 		if (r_cage && *r_cage && (*r_cage != *r_final)) {
-			DM_calc_loop_normals(*r_cage, do_loop_normals, loop_normals_split_angle);
+			BKE_mesh_calc_normals_split(*r_cage);
+			BKE_mesh_tessface_clear(*r_cage);
 		}
 	}
 
@@ -2239,13 +2186,13 @@ static void editbmesh_calc_modifiers(
 	 * check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential
 	 * but quiets annoying error messages since tessfaces wont be created. */
 	if (dataMask & CD_MASK_MFACE) {
-		if ((*r_final)->type != DM_TYPE_EDITBMESH) {
-			DM_ensure_tessface(*r_final);
+		if ((*r_final)->edit_btmesh == NULL) {
+			BKE_mesh_tessface_ensure(*r_final);
 		}
 		if (r_cage && *r_cage) {
-			if ((*r_cage)->type != DM_TYPE_EDITBMESH) {
+			if ((*r_cage)->edit_btmesh == NULL) {
 				if (*r_cage != *r_final) {
-					DM_ensure_tessface(*r_cage);
+					BKE_mesh_tessface_ensure(*r_cage);
 				}
 			}
 		}
@@ -2254,27 +2201,29 @@ static void editbmesh_calc_modifiers(
 
 	/* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */
 	if (!do_loop_normals) {
-		dm_ensure_display_normals(*r_final);
+		mesh_ensure_display_normals(*r_final);
 
 		/* Some modifiers, like datatransfer, may generate those data, we do not want to keep them,
 		 * as they are used by display code when available (i.e. even if autosmooth is disabled). */
-		if (CustomData_has_layer(&(*r_final)->loopData, CD_NORMAL)) {
-			CustomData_free_layers(&(*r_final)->loopData, CD_NORMAL, (*r_final)->numLoopData);
+		if (CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
+			CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
 		}
-		if (r_cage && CustomData_has_layer(&(*r_cage)->loopData, CD_NORMAL)) {
-			CustomData_free_layers(&(*r_cage)->loopData, CD_NORMAL, (*r_cage)->numLoopData);
+		if (r_cage && CustomData_has_layer(&(*r_cage)->ldata, CD_NORMAL)) {
+			CustomData_free_layers(&(*r_cage)->ldata, CD_NORMAL, (*r_cage)->totloop);
 		}
 	}
 
 	/* add an orco layer if needed */
 	if (dataMask & CD_MASK_ORCO)
-		add_orco_dm(ob, em, *r_final, orcodm, CD_ORCO);
+		add_orco_mesh(ob, em, *r_final, me_orco, CD_ORCO);
 
-	if (orcodm)
-		orcodm->release(orcodm);
+	if (me_orco) {
+		BKE_id_free(NULL, me_orco);
+	}
 
-	if (deformedVerts)
+	if (deformedVerts) {
 		MEM_freeN(deformedVerts);
+	}
 }
 
 static void mesh_finalize_eval(Object *object)
@@ -2368,9 +2317,23 @@ static void editbmesh_build_data(
 
 	BKE_editmesh_free_derivedmesh(em);
 
+	Mesh *me_cage;
+	Mesh *me_final;
+
 	editbmesh_calc_modifiers(
 	        depsgraph, scene, obedit, em, dataMask,
-	        &em->derivedCage, &em->derivedFinal);
+	        &me_cage, &me_final);
+
+	/* TODO(campbell): remove derived mesh conversion. */
+	em->derivedFinal = CDDM_from_mesh_ex(me_final, CD_DUPLICATE, CD_MASK_MESH);
+	BKE_id_free(NULL, me_final);
+	if (me_cage != me_final) {
+		em->derivedCage = CDDM_from_mesh_ex(me_cage, CD_DUPLICATE, CD_MASK_MESH);
+		BKE_id_free(NULL, me_cage);
+	}
+	else {
+		em->derivedCage = em->derivedFinal;
+	}
 
 	DM_set_object_boundbox(obedit, em->derivedFinal);