Refactor CDData masks, to have one mask per mesh elem type.

We already have different storages for cddata of verts, edges etc.,
'simply' do the same for the mask flags we use all around Blender code
to request some data, or limit some operation to some layers, etc.

Reason we need this is that some cddata types (like Normals) are
actually shared between verts/polys/loops, and we don’t want to generate
clnors everytime we request vnors!

As a side note, this also does final fix to T59338, which was the
trigger for this patch (need to request computed loop normals for
another mesh than evaluated one).

Reviewers: brecht, campbellbarton, sergey

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

1 files changed, 173 insertions, 135 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 27da5b8c635..a3f89d65c5a 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -28,6 +28,7 @@
 #include "MEM_guardedalloc.h"
 
 #include "DNA_cloth_types.h"
+#include "DNA_customdata_types.h"
 #include "DNA_key_types.h"
 #include "DNA_material_types.h"
 #include "DNA_mesh_types.h"
@@ -361,13 +362,13 @@ void DM_from_template_ex(
         DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
         int numVerts, int numEdges, int numTessFaces,
         int numLoops, int numPolys,
-        CustomDataMask mask)
+        const CustomData_MeshMasks *mask)
 {
-	CustomData_copy(&source->vertData, &dm->vertData, mask, CD_CALLOC, numVerts);
-	CustomData_copy(&source->edgeData, &dm->edgeData, mask, CD_CALLOC, numEdges);
-	CustomData_copy(&source->faceData, &dm->faceData, mask, CD_CALLOC, numTessFaces);
-	CustomData_copy(&source->loopData, &dm->loopData, mask, CD_CALLOC, numLoops);
-	CustomData_copy(&source->polyData, &dm->polyData, mask, CD_CALLOC, numPolys);
+	CustomData_copy(&source->vertData, &dm->vertData, mask->vmask, CD_CALLOC, numVerts);
+	CustomData_copy(&source->edgeData, &dm->edgeData, mask->emask, CD_CALLOC, numEdges);
+	CustomData_copy(&source->faceData, &dm->faceData, mask->fmask, CD_CALLOC, numTessFaces);
+	CustomData_copy(&source->loopData, &dm->loopData, mask->lmask, CD_CALLOC, numLoops);
+	CustomData_copy(&source->polyData, &dm->polyData, mask->pmask, CD_CALLOC, numPolys);
 
 	dm->cd_flag = source->cd_flag;
 
@@ -392,7 +393,7 @@ void DM_from_template(
 	        dm, source, type,
 	        numVerts, numEdges, numTessFaces,
 	        numLoops, numPolys,
-	        CD_MASK_DERIVEDMESH);
+	        &CD_MASK_DERIVEDMESH);
 }
 
 int DM_release(DerivedMesh *dm)
@@ -433,8 +434,8 @@ void DM_DupPolys(DerivedMesh *source, DerivedMesh *target)
 	CustomData_free(&target->loopData, source->numLoopData);
 	CustomData_free(&target->polyData, source->numPolyData);
 
-	CustomData_copy(&source->loopData, &target->loopData, CD_MASK_DERIVEDMESH, CD_DUPLICATE, source->numLoopData);
-	CustomData_copy(&source->polyData, &target->polyData, CD_MASK_DERIVEDMESH, CD_DUPLICATE, source->numPolyData);
+	CustomData_copy(&source->loopData, &target->loopData, CD_MASK_DERIVEDMESH.lmask, CD_DUPLICATE, source->numLoopData);
+	CustomData_copy(&source->polyData, &target->polyData, CD_MASK_DERIVEDMESH.pmask, CD_DUPLICATE, source->numPolyData);
 
 	target->numLoopData = source->numLoopData;
 	target->numPolyData = source->numPolyData;
@@ -492,7 +493,7 @@ void DM_ensure_looptri_data(DerivedMesh *dm)
 	}
 }
 
-void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob, CustomDataMask mask, bool take_ownership)
+void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob, const CustomData_MeshMasks *mask, bool take_ownership)
 {
 	/* dm might depend on me, so we need to do everything with a local copy */
 	Mesh tmp = *me;
@@ -526,10 +527,10 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob, CustomDataMask mask, bool
 	totpoly = tmp.totpoly = dm->getNumPolys(dm);
 	tmp.totface = 0;
 
-	CustomData_copy(&dm->vertData, &tmp.vdata, mask, alloctype, totvert);
-	CustomData_copy(&dm->edgeData, &tmp.edata, mask, alloctype, totedge);
-	CustomData_copy(&dm->loopData, &tmp.ldata, mask, alloctype, totloop);
-	CustomData_copy(&dm->polyData, &tmp.pdata, mask, alloctype, totpoly);
+	CustomData_copy(&dm->vertData, &tmp.vdata, mask->vmask, alloctype, totvert);
+	CustomData_copy(&dm->edgeData, &tmp.edata, mask->emask, alloctype, totedge);
+	CustomData_copy(&dm->loopData, &tmp.ldata, mask->lmask, alloctype, totloop);
+	CustomData_copy(&dm->polyData, &tmp.pdata, mask->pmask, alloctype, totpoly);
 	tmp.cd_flag = dm->cd_flag;
 	tmp.runtime.deformed_only = dm->deformedOnly;
 
@@ -627,10 +628,10 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob, CustomDataMask mask, bool
 
 	if (take_ownership) {
 		if (alloctype == CD_ASSIGN) {
-			CustomData_free_typemask(&dm->vertData, dm->numVertData, ~mask);
-			CustomData_free_typemask(&dm->edgeData, dm->numEdgeData, ~mask);
-			CustomData_free_typemask(&dm->loopData, dm->numLoopData, ~mask);
-			CustomData_free_typemask(&dm->polyData, dm->numPolyData, ~mask);
+			CustomData_free_typemask(&dm->vertData, dm->numVertData, ~mask->vmask);
+			CustomData_free_typemask(&dm->edgeData, dm->numEdgeData, ~mask->emask);
+			CustomData_free_typemask(&dm->loopData, dm->numLoopData, ~mask->lmask);
+			CustomData_free_typemask(&dm->polyData, dm->numPolyData, ~mask->pmask);
 		}
 		dm->release(dm);
 	}
@@ -655,31 +656,31 @@ void BKE_mesh_runtime_eval_to_meshkey(Mesh *me_deformed, Mesh *me, KeyBlock *kb)
  * zero for the layer type, so only layer types specified by the mask
  * will be copied
  */
-void DM_set_only_copy(DerivedMesh *dm, CustomDataMask mask)
+void DM_set_only_copy(DerivedMesh *dm, const CustomData_MeshMasks *mask)
 {
-	CustomData_set_only_copy(&dm->vertData, mask);
-	CustomData_set_only_copy(&dm->edgeData, mask);
-	CustomData_set_only_copy(&dm->faceData, mask);
+	CustomData_set_only_copy(&dm->vertData, mask->vmask);
+	CustomData_set_only_copy(&dm->edgeData, mask->emask);
+	CustomData_set_only_copy(&dm->faceData, mask->fmask);
 	/* this wasn't in 2.63 and is disabled for 2.64 because it gives problems with
 	 * weight paint mode when there are modifiers applied, needs further investigation,
 	 * see replies to r50969, Campbell */
 #if 0
-	CustomData_set_only_copy(&dm->loopData, mask);
-	CustomData_set_only_copy(&dm->polyData, mask);
+	CustomData_set_only_copy(&dm->loopData, mask->lmask);
+	CustomData_set_only_copy(&dm->polyData, mask->pmask);
 #endif
 }
 
-static void mesh_set_only_copy(Mesh *mesh, CustomDataMask mask)
+static void mesh_set_only_copy(Mesh *mesh, const CustomData_MeshMasks *mask)
 {
-	CustomData_set_only_copy(&mesh->vdata, mask);
-	CustomData_set_only_copy(&mesh->edata, mask);
-	CustomData_set_only_copy(&mesh->fdata, mask);
+	CustomData_set_only_copy(&mesh->vdata, mask->vmask);
+	CustomData_set_only_copy(&mesh->edata, mask->emask);
+	CustomData_set_only_copy(&mesh->fdata, mask->fmask);
 	/* this wasn't in 2.63 and is disabled for 2.64 because it gives problems with
 	 * weight paint mode when there are modifiers applied, needs further investigation,
 	 * see replies to r50969, Campbell */
 #if 0
-	CustomData_set_only_copy(&mesh->ldata, mask);
-	CustomData_set_only_copy(&mesh->pdata, mask);
+	CustomData_set_only_copy(&mesh->ldata, mask->lmask);
+	CustomData_set_only_copy(&mesh->pdata, mask->pmask);
 #endif
 }
 
@@ -982,7 +983,7 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
 	int free;
 
 	if (em) {
-		mesh = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, 0);
+		mesh = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, NULL);
 	}
 	else {
 		mesh = BKE_mesh_copy_for_eval(me, true);
@@ -1152,7 +1153,7 @@ static void mesh_copy_autosmooth(Mesh *me, Mesh *me_orig)
 static void mesh_calc_modifiers(
         struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
         int useDeform,
-        const bool need_mapping, CustomDataMask dataMask,
+        const bool need_mapping, const CustomData_MeshMasks *dataMask,
         const int index, const bool useCache, const bool build_shapekey_layers,
         /* return args */
         Mesh **r_deform, Mesh **r_final)
@@ -1160,7 +1161,8 @@ static void mesh_calc_modifiers(
 	ModifierData *firstmd, *md, *previewmd = NULL;
 	CDMaskLink *datamasks, *curr;
 	/* XXX Always copying POLYINDEX, else tessellated data are no more valid! */
-	CustomDataMask mask, nextmask, previewmask = 0, append_mask = CD_MASK_ORIGINDEX | CD_MASK_BAREMESH;
+	CustomData_MeshMasks mask, nextmask, previewmask = {0}, append_mask = CD_MASK_BAREMESH_ORIGINDEX;
+
 	float (*deformedVerts)[3] = NULL;
 	int numVerts = ((Mesh *)ob->data)->totvert;
 	const bool useRenderParams = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
@@ -1206,7 +1208,7 @@ static void mesh_calc_modifiers(
 		previewmd = modifiers_getLastPreview(scene, md, required_mode);
 	}
 
-	datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, previewmask);
+	datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, &previewmask);
 	curr = datamasks;
 
 	if (r_deform) {
@@ -1336,12 +1338,12 @@ static void mesh_calc_modifiers(
 		}
 
 		/* add an orco layer if needed by this modifier */
-		if (mti->requiredDataMask)
-			mask = mti->requiredDataMask(ob, md);
-		else
-			mask = 0;
+		memset(&mask, 0, sizeof(mask));
+		if (mti->requiredDataMask) {
+			mti->requiredDataMask(ob, md, &mask);
+		}
 
-		if (me && (mask & CD_MASK_ORCO)) {
+		if (me && (mask.vmask & CD_MASK_ORCO)) {
 			add_orco_mesh(ob, NULL, me, me_orco, CD_ORCO);
 		}
 
@@ -1381,7 +1383,7 @@ static void mesh_calc_modifiers(
 			if (curr->next)
 				nextmask = curr->next->mask;
 			else
-				nextmask = dataMask;
+				nextmask = *dataMask;
 
 			/* apply vertex coordinates or build a Mesh as necessary */
 			if (me) {
@@ -1408,7 +1410,7 @@ static void mesh_calc_modifiers(
 				 * requests it, this way Mirror, Solidify etc will keep ORIGINDEX
 				 * data by using generic DM_copy_vert_data() functions.
 				 */
-				if (need_mapping || (nextmask & CD_MASK_ORIGINDEX)) {
+				if (need_mapping || ((nextmask.vmask | nextmask.emask | nextmask.pmask) & CD_MASK_ORIGINDEX)) {
 					/* calc */
 					CustomData_add_layer(&me->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totvert);
 					CustomData_add_layer(&me->edata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totedge);
@@ -1426,15 +1428,21 @@ static void mesh_calc_modifiers(
 			mask = curr->mask;
 			/* needMapping check here fixes bug [#28112], otherwise it's
 			 * possible that it won't be copied */
-			mask |= append_mask;
-			mesh_set_only_copy(me, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
+			CustomData_MeshMasks_update(&mask, &append_mask);
+			if (need_mapping) {
+				mask.vmask |= CD_MASK_ORIGINDEX;
+				mask.emask |= CD_MASK_ORIGINDEX;
+				mask.pmask |= CD_MASK_ORIGINDEX;
+			}
+			mesh_set_only_copy(me, &mask);
 
 			/* add cloth rest shape key if needed */
-			if (mask & CD_MASK_CLOTH_ORCO)
+			if (mask.vmask & CD_MASK_CLOTH_ORCO) {
 				add_orco_mesh(ob, NULL, me, me_orco, CD_CLOTH_ORCO);
+			}
 
 			/* add an origspace layer if needed */
-			if ((curr->mask) & CD_MASK_ORIGSPACE_MLOOP) {
+			if ((curr->mask.lmask) & CD_MASK_ORIGSPACE_MLOOP) {
 				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);
@@ -1463,15 +1471,18 @@ static void mesh_calc_modifiers(
 			}
 
 			/* create an orco mesh in parallel */
-			if (nextmask & CD_MASK_ORCO) {
+			if (nextmask.vmask & CD_MASK_ORCO) {
 				if (!me_orco) {
 					me_orco = create_orco_mesh(ob, ob->data, NULL, CD_ORCO);
 				}
 
-				nextmask &= ~CD_MASK_ORCO;
-				mesh_set_only_copy(me_orco, nextmask | CD_MASK_ORIGINDEX |
-				                 (mti->requiredDataMask ?
-				                  mti->requiredDataMask(ob, md) : 0));
+				nextmask.vmask &= ~CD_MASK_ORCO;
+				CustomData_MeshMasks temp_cddata_masks = {.vmask=CD_MASK_ORIGINDEX, .emask=CD_MASK_ORIGINDEX, .fmask=CD_MASK_ORIGINDEX, .pmask=CD_MASK_ORIGINDEX};
+				if (mti->requiredDataMask != NULL) {
+					mti->requiredDataMask(ob, md, &temp_cddata_masks);
+				}
+				CustomData_MeshMasks_update(&temp_cddata_masks, &nextmask);
+				mesh_set_only_copy(me_orco, &temp_cddata_masks);
 
 				me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
 				ASSERT_IS_VALID_MESH(me_next);
@@ -1488,13 +1499,16 @@ static void mesh_calc_modifiers(
 			}
 
 			/* create cloth orco mesh in parallel */
-			if (nextmask & CD_MASK_CLOTH_ORCO) {
+			if (nextmask.vmask & CD_MASK_CLOTH_ORCO) {
 				if (!me_orco_cloth) {
 					me_orco_cloth = create_orco_mesh(ob, ob->data, NULL, CD_CLOTH_ORCO);
 				}
 
-				nextmask &= ~CD_MASK_CLOTH_ORCO;
-				mesh_set_only_copy(me_orco_cloth, nextmask | CD_MASK_ORIGINDEX);
+				nextmask.vmask &= ~CD_MASK_CLOTH_ORCO;
+				nextmask.vmask |= CD_MASK_ORIGINDEX;
+				nextmask.emask |= CD_MASK_ORIGINDEX;
+				nextmask.pmask |= CD_MASK_ORIGINDEX;
+				mesh_set_only_copy(me_orco_cloth, &nextmask);
 
 				me_next = modwrap_applyModifier(md, &mectx_orco, me_orco_cloth);
 				ASSERT_IS_VALID_MESH(me_next);
@@ -1512,8 +1526,9 @@ static void mesh_calc_modifiers(
 
 			/* in case of dynamic paint, make sure preview mask remains for following modifiers */
 			/* XXX Temp and hackish solution! */
-			if (md->type == eModifierType_DynamicPaint)
-				append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
+			if (md->type == eModifierType_DynamicPaint) {
+				append_mask.lmask |= CD_MASK_PREVIEW_MLOOPCOL;
+			}
 
 			me->runtime.deformed_only = false;
 		}
@@ -1556,7 +1571,7 @@ static void mesh_calc_modifiers(
 	}
 
 	/* add an orco layer if needed */
-	if (dataMask & CD_MASK_ORCO) {
+	if (dataMask->vmask & CD_MASK_ORCO) {
 		add_orco_mesh(ob, NULL, *r_final, me_orco, CD_ORCO);
 
 		if (r_deform && *r_deform)
@@ -1571,7 +1586,7 @@ static void mesh_calc_modifiers(
 
 	if (sculpt_dyntopo == false) {
 		/* watch this! after 2.75a we move to from tessface to looptri (by default) */
-		if (dataMask & CD_MASK_MFACE) {
+		if (dataMask->fmask & CD_MASK_MFACE) {
 			BKE_mesh_tessface_ensure(*r_final);
 		}
 
@@ -1613,7 +1628,7 @@ static void mesh_calc_modifiers(
 static void mesh_calc_modifiers_dm(
         struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
         int useDeform,
-        const bool need_mapping, CustomDataMask dataMask,
+        const bool need_mapping, const CustomData_MeshMasks *dataMask,
         const int index, const bool useCache, const bool build_shapekey_layers,
         /* return args */
         DerivedMesh **r_deformdm, DerivedMesh **r_finaldm)
@@ -1626,11 +1641,11 @@ static void mesh_calc_modifiers_dm(
 	        (r_deformdm ? &deform_mesh : NULL), &final_mesh);
 
 	if (deform_mesh) {
-		*r_deformdm = CDDM_from_mesh_ex(deform_mesh, CD_DUPLICATE, CD_MASK_MESH);
+		*r_deformdm = CDDM_from_mesh_ex(deform_mesh, CD_DUPLICATE, &CD_MASK_MESH);
 		BKE_id_free(NULL, deform_mesh);
 	}
 
-	*r_finaldm = CDDM_from_mesh_ex(final_mesh, CD_DUPLICATE, CD_MASK_MESH);
+	*r_finaldm = CDDM_from_mesh_ex(final_mesh, CD_DUPLICATE, &CD_MASK_MESH);
 	BKE_id_free(NULL, final_mesh);
 }
 #endif
@@ -1672,13 +1687,13 @@ bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, bool has_prev
 
 static void editbmesh_calc_modifiers(
         struct Depsgraph *depsgraph, Scene *scene, Object *ob,
-        BMEditMesh *em, CustomDataMask dataMask,
+        BMEditMesh *em, const CustomData_MeshMasks *dataMask,
         /* return args */
         Mesh **r_cage, Mesh **r_final)
 {
 	ModifierData *md;
 	float (*deformedVerts)[3] = NULL;
-	CustomDataMask mask = 0, append_mask = CD_MASK_BAREMESH;
+	CustomData_MeshMasks mask = {0}, append_mask = CD_MASK_BAREMESH;
 	int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
 	CDMaskLink *datamasks, *curr;
 	const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
@@ -1702,7 +1717,7 @@ static void editbmesh_calc_modifiers(
 	md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 
 	/* copied from mesh_calc_modifiers */
-	datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, NULL, 0);
+	datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, NULL, NULL);
 
 	curr = datamasks;
 
@@ -1711,6 +1726,7 @@ static void editbmesh_calc_modifiers(
 
 	for (i = 0; md; i++, md = md->next, curr = curr->next) {
 		const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
+		memset(&mask, 0, sizeof(mask));
 
 		if (!editbmesh_modifier_is_enabled(scene, md, me != NULL)) {
 			continue;
@@ -1718,8 +1734,8 @@ static void editbmesh_calc_modifiers(
 
 		/* add an orco layer if needed by this modifier */
 		if (me && mti->requiredDataMask) {
-			mask = mti->requiredDataMask(ob, md);
-			if (mask & CD_MASK_ORCO) {
+			mti->requiredDataMask(ob, md, &mask);
+			if (mask.vmask & CD_MASK_ORCO) {
 				add_orco_mesh(ob, em, me, me_orco, CD_ORCO);
 			}
 		}
@@ -1770,7 +1786,7 @@ static void editbmesh_calc_modifiers(
 
 			}
 			else {
-				me = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, 0);
+				me = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, NULL);
 				ASSERT_IS_VALID_MESH(me);
 
 				mesh_copy_autosmooth(me, ob->data);
@@ -1782,13 +1798,16 @@ static void editbmesh_calc_modifiers(
 
 			/* create an orco derivedmesh in parallel */
 			mask = curr->mask;
-			if (mask & CD_MASK_ORCO) {
+			if (mask.vmask & CD_MASK_ORCO) {
 				if (!me_orco) {
 					me_orco = create_orco_mesh(ob, ob->data, em, CD_ORCO);
 				}
 
-				mask &= ~CD_MASK_ORCO;
-				mesh_set_only_copy(me_orco, mask | CD_MASK_ORIGINDEX);
+				mask.vmask &= ~CD_MASK_ORCO;
+				mask.vmask |= CD_MASK_ORIGINDEX;
+				mask.emask |= CD_MASK_ORIGINDEX;
+				mask.pmask |= CD_MASK_ORIGINDEX;
+				mesh_set_only_copy(me_orco, &mask);
 
 				me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
 				ASSERT_IS_VALID_MESH(me_next);
@@ -1803,12 +1822,15 @@ static void editbmesh_calc_modifiers(
 			}
 
 			/* set the DerivedMesh to only copy needed data */
-			mask |= append_mask;
-			mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */
+			CustomData_MeshMasks_update(&mask, &append_mask);
+			mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */ /* XXX WHAT? ovewrites mask ??? */
+			mask.vmask |= CD_MASK_ORIGINDEX;
+			mask.emask |= CD_MASK_ORIGINDEX;
+			mask.pmask |= CD_MASK_ORIGINDEX;
 
-			mesh_set_only_copy(me, mask | CD_MASK_ORIGINDEX);
+			mesh_set_only_copy(me, &mask);
 
-			if (mask & CD_MASK_ORIGSPACE_MLOOP) {
+			if (mask.lmask & CD_MASK_ORIGSPACE_MLOOP) {
 				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);
@@ -1849,7 +1871,7 @@ static void editbmesh_calc_modifiers(
 					me_orig->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
 				}
 				*r_cage = BKE_mesh_from_editmesh_with_coords_thin_wrap(
-				        em, mask,
+				        em, &mask,
 				        deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
 				mesh_copy_autosmooth(*r_cage, ob->data);
 			}
@@ -1909,7 +1931,7 @@ static void editbmesh_calc_modifiers(
 	 * but don't recalculate if the last modifier in the stack gives us tessfaces
 	 * 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 (dataMask->fmask & CD_MASK_MFACE) {
 		if ((*r_final)->edit_mesh == NULL) {
 			BKE_mesh_tessface_ensure(*r_final);
 		}
@@ -1942,7 +1964,7 @@ static void editbmesh_calc_modifiers(
 	}
 
 	/* add an orco layer if needed */
-	if (dataMask & CD_MASK_ORCO)
+	if (dataMask->vmask & CD_MASK_ORCO)
 		add_orco_mesh(ob, em, *r_final, me_orco, CD_ORCO);
 
 	if (me_orco) {
@@ -2014,7 +2036,7 @@ static void mesh_runtime_check_normals_valid(const Mesh *mesh)
 }
 
 static void mesh_build_data(
-        struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask,
+        struct Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask,
         const bool build_shapekey_layers, const bool need_mapping)
 {
 	BLI_assert(ob->type == OB_MESH);
@@ -2026,10 +2048,14 @@ static void mesh_build_data(
 	BKE_object_free_derived_caches(ob);
 	BKE_object_sculpt_modifiers_changed(ob);
 
+#if 0 /* XXX This is already taken care of in mesh_calc_modifiers()... */
 	if (need_mapping) {
 		/* Also add the flag so that it is recorded in lastDataMask. */
-		dataMask |= CD_MASK_ORIGINDEX;
+		dataMask->vmask |= CD_MASK_ORIGINDEX;
+		dataMask->emask |= CD_MASK_ORIGINDEX;
+		dataMask->pmask |= CD_MASK_ORIGINDEX;
 	}
+#endif
 
 	mesh_calc_modifiers(
 	        depsgraph, scene, ob, NULL, 1, need_mapping, dataMask, -1, true, build_shapekey_layers,
@@ -2037,8 +2063,8 @@ static void mesh_build_data(
 
 #ifdef USE_DERIVEDMESH
 	/* TODO(campbell): remove these copies, they are expected in various places over the code. */
-	ob->derivedDeform = CDDM_from_mesh_ex(ob->runtime.mesh_deform_eval, CD_REFERENCE, CD_MASK_MESH);
-	ob->derivedFinal = CDDM_from_mesh_ex(ob->runtime.mesh_eval, CD_REFERENCE, CD_MASK_MESH);
+	ob->derivedDeform = CDDM_from_mesh_ex(ob->runtime.mesh_deform_eval, CD_REFERENCE, &CD_MASK_MESH);
+	ob->derivedFinal = CDDM_from_mesh_ex(ob->runtime.mesh_eval, CD_REFERENCE, &CD_MASK_MESH);
 #endif
 
 	BKE_object_boundbox_calc_from_mesh(ob, ob->runtime.mesh_eval);
@@ -2054,7 +2080,7 @@ static void mesh_build_data(
 	ob->derivedFinal->needsFree = 0;
 	ob->derivedDeform->needsFree = 0;
 #endif
-	ob->runtime.last_data_mask = dataMask;
+	ob->runtime.last_data_mask = *dataMask;
 	ob->runtime.last_need_mapping = need_mapping;
 
 	if ((ob->mode & OB_MODE_ALL_SCULPT) && ob->sculpt) {
@@ -2071,7 +2097,7 @@ static void mesh_build_data(
 
 static void editbmesh_build_data(
         struct Depsgraph *depsgraph, Scene *scene,
-        Object *obedit, BMEditMesh *em, CustomDataMask dataMask)
+        Object *obedit, BMEditMesh *em, CustomData_MeshMasks *dataMask)
 {
 	BLI_assert(em->ob->id.tag & LIB_TAG_COPIED_ON_WRITE);
 
@@ -2092,16 +2118,17 @@ static void editbmesh_build_data(
 
 	BKE_object_boundbox_calc_from_mesh(obedit, em->mesh_eval_final);
 
-	em->lastDataMask = dataMask;
+	em->lastDataMask = *dataMask;
 
 	mesh_runtime_check_normals_valid(em->mesh_eval_final);
 }
 
-static CustomDataMask object_get_datamask(const Depsgraph *depsgraph, Object *ob, bool *r_need_mapping)
+static void object_get_datamask(const Depsgraph *depsgraph, Object *ob, CustomData_MeshMasks *r_mask, bool *r_need_mapping)
 {
 	ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
 	Object *actob = view_layer->basact ? DEG_get_original_object(view_layer->basact->object) : NULL;
-	CustomDataMask mask = DEG_get_customdata_mask_for_object(depsgraph, ob);
+
+	DEG_get_customdata_mask_for_object(depsgraph, ob, r_mask);
 
 	if (r_need_mapping) {
 		*r_need_mapping = false;
@@ -2117,37 +2144,37 @@ static CustomDataMask object_get_datamask(const Depsgraph *depsgraph, Object *ob
 
 		/* check if we need tfaces & mcols due to face select or texture paint */
 		if ((ob->mode & OB_MODE_TEXTURE_PAINT) || editing) {
-			mask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTFACE;
+			r_mask->lmask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
+			r_mask->fmask |= CD_MASK_MTFACE;
 		}
 
 		/* check if we need mcols due to vertex paint or weightpaint */
 		if (ob->mode & OB_MODE_VERTEX_PAINT) {
-			mask |= CD_MASK_MLOOPCOL;
+			r_mask->lmask |= CD_MASK_MLOOPCOL;
 		}
 
 		if (ob->mode & OB_MODE_WEIGHT_PAINT) {
-			mask |= CD_MASK_MDEFORMVERT;
+			r_mask->vmask |= CD_MASK_MDEFORMVERT;
 		}
 
 		if (ob->mode & OB_MODE_EDIT)
-			mask |= CD_MASK_MVERT_SKIN;
+			r_mask->vmask |= CD_MASK_MVERT_SKIN;
 	}
-
-	return mask;
 }
 
 void makeDerivedMesh(
         struct Depsgraph *depsgraph, Scene *scene, Object *ob, BMEditMesh *em,
-        CustomDataMask dataMask, const bool build_shapekey_layers)
+        const CustomData_MeshMasks *dataMask, const bool build_shapekey_layers)
 {
 	bool need_mapping;
-	dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
+	CustomData_MeshMasks cddata_masks = *dataMask;
+	object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
 
 	if (em) {
-		editbmesh_build_data(depsgraph, scene, ob, em, dataMask);
+		editbmesh_build_data(depsgraph, scene, ob, em, &cddata_masks);
 	}
 	else {
-		mesh_build_data(depsgraph, scene, ob, dataMask, build_shapekey_layers, need_mapping);
+		mesh_build_data(depsgraph, scene, ob, &cddata_masks, build_shapekey_layers, need_mapping);
 	}
 }
 
@@ -2156,27 +2183,27 @@ void makeDerivedMesh(
 #ifdef USE_DERIVEDMESH
 /* Deprecated DM, use: 'mesh_get_eval_final'. */
 DerivedMesh *mesh_get_derived_final(
-        struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
+        struct Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	/* if there's no derived mesh or the last data mask used doesn't include
 	 * the data we need, rebuild the derived mesh
 	 */
 	bool need_mapping;
-	dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
+	CustomData_MeshMasks cddata_masks = *dataMask;
+	object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
 
 	if (!ob->derivedFinal ||
-	    ((dataMask & ob->lastDataMask) != dataMask) ||
+	    !CustomData_MeshMasks_are_matching(&(ob->lastDataMask), &cddata_masks) ||
 	    (need_mapping != ob->lastNeedMapping))
 	{
-		mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
+		mesh_build_data(depsgraph, scene, ob, cddata_masks, false, need_mapping);
 	}
 
 	if (ob->derivedFinal) { BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
 	return ob->derivedFinal;
 }
 #endif
-Mesh *mesh_get_eval_final(
-        struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
+Mesh *mesh_get_eval_final(struct Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	/* This function isn't thread-safe and can't be used during evaluation. */
 	BLI_assert(DEG_debug_is_evaluating(depsgraph) == false);
@@ -2189,13 +2216,15 @@ Mesh *mesh_get_eval_final(
 	 * the data we need, rebuild the derived mesh
 	 */
 	bool need_mapping;
-	dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
+	CustomData_MeshMasks cddata_masks = *dataMask;
+	object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
 
 	if (!ob->runtime.mesh_eval ||
-	    ((dataMask & ob->runtime.last_data_mask) != dataMask) ||
+	    !CustomData_MeshMasks_are_matching(&(ob->runtime.last_data_mask), &cddata_masks) ||
 	    (need_mapping && !ob->runtime.last_need_mapping))
 	{
-		mesh_build_data(depsgraph, scene, ob, dataMask | ob->runtime.last_data_mask,
+		CustomData_MeshMasks_update(&cddata_masks, &ob->runtime.last_data_mask);
+		mesh_build_data(depsgraph, scene, ob, &cddata_masks,
 		                false, need_mapping || ob->runtime.last_need_mapping);
 	}
 
@@ -2205,26 +2234,27 @@ Mesh *mesh_get_eval_final(
 
 #ifdef USE_DERIVEDMESH
 /* Deprecated DM, use: 'mesh_get_eval_deform' instead. */
-DerivedMesh *mesh_get_derived_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
+DerivedMesh *mesh_get_derived_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	/* if there's no derived mesh or the last data mask used doesn't include
 	 * the data we need, rebuild the derived mesh
 	 */
 	bool need_mapping;
 
-	dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
+	CustomData_MeshMasks cddata_masks = *dataMask;
+	object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
 
 	if (!ob->derivedDeform ||
-	    ((dataMask & ob->lastDataMask) != dataMask) ||
+	    !CustomData_MeshMasks_are_matching(&(ob->lastDataMask),  &cddata_masks) ||
 	    (need_mapping != ob->lastNeedMapping))
 	{
-		mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
+		mesh_build_data(depsgraph, scene, ob, cddata_masks, false, need_mapping);
 	}
 
 	return ob->derivedDeform;
 }
 #endif
-Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
+Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	/* This function isn't thread-safe and can't be used during evaluation. */
 	BLI_assert(DEG_debug_is_evaluating(depsgraph) == false);
@@ -2238,13 +2268,15 @@ Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob
 	 */
 	bool need_mapping;
 
-	dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
+	CustomData_MeshMasks cddata_masks = *dataMask;
+	object_get_datamask(depsgraph, ob, &cddata_masks, &need_mapping);
 
 	if (!ob->runtime.mesh_deform_eval ||
-	    ((dataMask & ob->runtime.last_data_mask) != dataMask) ||
+	    !CustomData_MeshMasks_are_matching(&(ob->runtime.last_data_mask), &cddata_masks) ||
 	    (need_mapping && !ob->runtime.last_need_mapping))
 	{
-		mesh_build_data(depsgraph, scene, ob, dataMask | ob->runtime.last_data_mask,
+		CustomData_MeshMasks_update(&cddata_masks, &ob->runtime.last_data_mask);
+		mesh_build_data(depsgraph, scene, ob, &cddata_masks,
 		                false, need_mapping || ob->runtime.last_need_mapping);
 	}
 
@@ -2254,7 +2286,8 @@ Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob
 
 #ifdef USE_DERIVEDMESH
 /* Deprecated, use `mesh_create_eval_final_render` instead. */
-DerivedMesh *mesh_create_derived_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
+DerivedMesh *mesh_create_derived_render(
+        struct Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	DerivedMesh *final;
 
@@ -2265,7 +2298,7 @@ DerivedMesh *mesh_create_derived_render(struct Depsgraph *depsgraph, Scene *scen
 	return final;
 }
 #endif
-Mesh *mesh_create_eval_final_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
+Mesh *mesh_create_eval_final_render(Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	Mesh *final;
 
@@ -2278,7 +2311,8 @@ Mesh *mesh_create_eval_final_render(struct Depsgraph *depsgraph, Scene *scene, O
 
 #ifdef USE_DERIVEDMESH
 /* Deprecated, use `mesh_create_eval_final_index_render` instead. */
-DerivedMesh *mesh_create_derived_index_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask, int index)
+DerivedMesh *mesh_create_derived_index_render(
+        struct Depsgraph *depsgraph, Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask, int index)
 {
 	DerivedMesh *final;
 
@@ -2290,8 +2324,8 @@ DerivedMesh *mesh_create_derived_index_render(struct Depsgraph *depsgraph, Scene
 }
 #endif
 Mesh *mesh_create_eval_final_index_render(
-        struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask, int index)
+        Depsgraph *depsgraph, Scene *scene,
+        Object *ob, const CustomData_MeshMasks *dataMask, int index)
 {
 	Mesh *final;
 
@@ -2306,7 +2340,7 @@ Mesh *mesh_create_eval_final_index_render(
 /* Deprecated, use `mesh_create_eval_final_view` instead. */
 DerivedMesh *mesh_create_derived_view(
         struct Depsgraph *depsgraph, Scene *scene,
-        Object *ob, CustomDataMask dataMask)
+        Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	DerivedMesh *final;
 
@@ -2327,8 +2361,8 @@ DerivedMesh *mesh_create_derived_view(
 #endif
 
 Mesh *mesh_create_eval_final_view(
-        struct Depsgraph *depsgraph, Scene *scene,
-        Object *ob, CustomDataMask dataMask)
+        Depsgraph *depsgraph, Scene *scene,
+        Object *ob, const CustomData_MeshMasks *dataMask)
 {
 	Mesh *final;
 
@@ -2348,8 +2382,8 @@ Mesh *mesh_create_eval_final_view(
 }
 
 Mesh *mesh_create_eval_no_deform(
-        struct Depsgraph *depsgraph, Scene *scene, Object *ob,
-        float (*vertCos)[3], CustomDataMask dataMask)
+        Depsgraph *depsgraph, Scene *scene, Object *ob,
+        float (*vertCos)[3], const CustomData_MeshMasks *dataMask)
 {
 	Mesh *final;
 
@@ -2361,8 +2395,8 @@ Mesh *mesh_create_eval_no_deform(
 }
 
 Mesh *mesh_create_eval_no_deform_render(
-        struct Depsgraph *depsgraph, Scene *scene, Object *ob,
-        float (*vertCos)[3], CustomDataMask dataMask)
+        Depsgraph *depsgraph, Scene *scene, Object *ob,
+        float (*vertCos)[3], const CustomData_MeshMasks *dataMask)
 {
 	Mesh *final;
 
@@ -2376,20 +2410,22 @@ Mesh *mesh_create_eval_no_deform_render(
 /***/
 
 Mesh *editbmesh_get_eval_cage_and_final(
-        struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
-        CustomDataMask dataMask,
+        Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
+        const CustomData_MeshMasks *dataMask,
         /* return args */
         Mesh **r_final)
 {
+	CustomData_MeshMasks cddata_masks = *dataMask;
+
 	/* if there's no derived mesh or the last data mask used doesn't include
 	 * the data we need, rebuild the derived mesh
 	 */
-	dataMask |= object_get_datamask(depsgraph, obedit, NULL);
+	object_get_datamask(depsgraph, obedit, &cddata_masks, NULL);
 
 	if (!em->mesh_eval_cage ||
-	    (em->lastDataMask & dataMask) != dataMask)
+	    !CustomData_MeshMasks_are_matching(&(em->lastDataMask), &cddata_masks))
 	{
-		editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
+		editbmesh_build_data(depsgraph, scene, obedit, em, &cddata_masks);
 	}
 
 	*r_final = em->mesh_eval_final;
@@ -2399,17 +2435,19 @@ Mesh *editbmesh_get_eval_cage_and_final(
 
 Mesh *editbmesh_get_eval_cage(
         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
-        CustomDataMask dataMask)
+        const CustomData_MeshMasks *dataMask)
 {
+	CustomData_MeshMasks cddata_masks = *dataMask;
+
 	/* if there's no derived mesh or the last data mask used doesn't include
 	 * the data we need, rebuild the derived mesh
 	 */
-	dataMask |= object_get_datamask(depsgraph, obedit, NULL);
+	object_get_datamask(depsgraph, obedit, &cddata_masks, NULL);
 
 	if (!em->mesh_eval_cage ||
-	    (em->lastDataMask & dataMask) != dataMask)
+	    !CustomData_MeshMasks_are_matching(&(em->lastDataMask), &cddata_masks))
 	{
-		editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
+		editbmesh_build_data(depsgraph, scene, obedit, em, &cddata_masks);
 	}
 
 	return em->mesh_eval_cage;
@@ -2417,7 +2455,7 @@ Mesh *editbmesh_get_eval_cage(
 
 Mesh *editbmesh_get_eval_cage_from_orig(
         struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *UNUSED(em),
-        CustomDataMask dataMask)
+        const CustomData_MeshMasks *dataMask)
 {
 	BLI_assert((obedit->id.tag & LIB_TAG_COPIED_ON_WRITE) == 0);
 	Scene *scene_eval = (Scene *)DEG_get_evaluated_id(depsgraph, &scene->id);
@@ -2467,7 +2505,7 @@ DMCoNo *mesh_get_mapped_verts_nors(Scene *scene, Object *ob)
 	if (ob->type != OB_MESH || me->totvert == 0)
 		return NULL;
 
-	dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
+	dm = mesh_get_derived_final(scene, ob, &CD_MASK_BAREMESH_ORIGINDEX);
 
 	if (dm->foreachMappedVert) {
 		vertexcosnos = MEM_calloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");