Refactor CDData masks, to have one mask per mesh elem type.
authorBastien Montagne <montagne29@wanadoo.fr>
Thu, 7 Mar 2019 10:13:40 +0000 (11:13 +0100)
committerBastien Montagne <montagne29@wanadoo.fr>
Thu, 7 Mar 2019 10:29:50 +0000 (11:29 +0100)
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

128 files changed:
source/blender/alembic/intern/abc_hair.cc
source/blender/alembic/intern/abc_mesh.cc
source/blender/alembic/intern/abc_points.cc
source/blender/blenkernel/BKE_DerivedMesh.h
source/blender/blenkernel/BKE_cdderivedmesh.h
source/blender/blenkernel/BKE_customdata.h
source/blender/blenkernel/BKE_data_transfer.h
source/blender/blenkernel/BKE_editmesh.h
source/blender/blenkernel/BKE_mesh.h
source/blender/blenkernel/BKE_mesh_runtime.h
source/blender/blenkernel/BKE_modifier.h
source/blender/blenkernel/BKE_particle.h
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/crazyspace.c
source/blender/blenkernel/intern/customdata.c
source/blender/blenkernel/intern/data_transfer.c
source/blender/blenkernel/intern/editderivedmesh.c
source/blender/blenkernel/intern/fluidsim.c
source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/mesh_convert.c
source/blender/blenkernel/intern/mesh_validate.c
source/blender/blenkernel/intern/modifier.c
source/blender/blenkernel/intern/multires.c
source/blender/blenkernel/intern/multires_reshape.c
source/blender/blenkernel/intern/object_update.c
source/blender/blenkernel/intern/paint.c
source/blender/blenkernel/intern/particle.c
source/blender/blenkernel/intern/pbvh.c
source/blender/blenkernel/intern/subdiv_foreach.c
source/blender/blenkernel/intern/subdiv_mesh.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/bmesh/intern/bmesh_construct.c
source/blender/bmesh/intern/bmesh_core.c
source/blender/bmesh/intern/bmesh_mesh_conv.c
source/blender/bmesh/intern/bmesh_mesh_conv.h
source/blender/collada/MeshImporter.cpp
source/blender/collada/collada_utils.cpp
source/blender/depsgraph/DEG_depsgraph_build.h
source/blender/depsgraph/DEG_depsgraph_query.h
source/blender/depsgraph/intern/builder/deg_builder.cc
source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
source/blender/depsgraph/intern/builder/deg_builder_nodes.h
source/blender/depsgraph/intern/builder/deg_builder_relations.cc
source/blender/depsgraph/intern/builder/deg_builder_relations.h
source/blender/depsgraph/intern/builder/deg_builder_relations_rig.cc
source/blender/depsgraph/intern/depsgraph_build.cc
source/blender/depsgraph/intern/depsgraph_query.cc
source/blender/depsgraph/intern/depsgraph_type.cc
source/blender/depsgraph/intern/depsgraph_type.h
source/blender/depsgraph/intern/node/deg_node_id.cc
source/blender/depsgraph/intern/node/deg_node_id.h
source/blender/editors/armature/armature_skinning.c
source/blender/editors/include/ED_view3d.h
source/blender/editors/mesh/editmesh_add.c
source/blender/editors/mesh/editmesh_knife_project.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/editmesh_undo.c
source/blender/editors/mesh/mesh_data.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_add.c
source/blender/editors/object/object_bake.c
source/blender/editors/object/object_data_transfer.c
source/blender/editors/object/object_modifier.c
source/blender/editors/object/object_relations.c
source/blender/editors/object/object_vgroup.c
source/blender/editors/physics/particle_edit.c
source/blender/editors/physics/particle_object.c
source/blender/editors/render/render_opengl.c
source/blender/editors/sculpt_paint/paint_image_proj.c
source/blender/editors/sculpt_paint/paint_vertex_proj.c
source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/sculpt_paint/sculpt_undo.c
source/blender/editors/space_view3d/view3d_draw_legacy.c
source/blender/editors/space_view3d/view3d_iterators.c
source/blender/gpencil_modifiers/intern/MOD_gpencilsmooth.c
source/blender/makesdna/DNA_customdata_types.h
source/blender/makesdna/DNA_object_types.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesrna/intern/rna_modifier.c
source/blender/modifiers/intern/MOD_armature.c
source/blender/modifiers/intern/MOD_bevel.c
source/blender/modifiers/intern/MOD_boolean.c
source/blender/modifiers/intern/MOD_cast.c
source/blender/modifiers/intern/MOD_cloth.c
source/blender/modifiers/intern/MOD_correctivesmooth.c
source/blender/modifiers/intern/MOD_curve.c
source/blender/modifiers/intern/MOD_datatransfer.c
source/blender/modifiers/intern/MOD_decimate.c
source/blender/modifiers/intern/MOD_displace.c
source/blender/modifiers/intern/MOD_dynamicpaint.c
source/blender/modifiers/intern/MOD_edgesplit.c
source/blender/modifiers/intern/MOD_explode.c
source/blender/modifiers/intern/MOD_hook.c
source/blender/modifiers/intern/MOD_laplaciandeform.c
source/blender/modifiers/intern/MOD_laplaciansmooth.c
source/blender/modifiers/intern/MOD_lattice.c
source/blender/modifiers/intern/MOD_mask.c
source/blender/modifiers/intern/MOD_meshdeform.c
source/blender/modifiers/intern/MOD_mirror.c
source/blender/modifiers/intern/MOD_normal_edit.c
source/blender/modifiers/intern/MOD_ocean.c
source/blender/modifiers/intern/MOD_particleinstance.c
source/blender/modifiers/intern/MOD_particlesystem.c
source/blender/modifiers/intern/MOD_shrinkwrap.c
source/blender/modifiers/intern/MOD_simpledeform.c
source/blender/modifiers/intern/MOD_skin.c
source/blender/modifiers/intern/MOD_smoke.c
source/blender/modifiers/intern/MOD_smooth.c
source/blender/modifiers/intern/MOD_solidify.c
source/blender/modifiers/intern/MOD_surfacedeform.c
source/blender/modifiers/intern/MOD_triangulate.c
source/blender/modifiers/intern/MOD_util.c
source/blender/modifiers/intern/MOD_uvproject.c
source/blender/modifiers/intern/MOD_uvwarp.c
source/blender/modifiers/intern/MOD_warp.c
source/blender/modifiers/intern/MOD_wave.c
source/blender/modifiers/intern/MOD_weighted_normal.c
source/blender/modifiers/intern/MOD_weightvgedit.c
source/blender/modifiers/intern/MOD_weightvgmix.c
source/blender/modifiers/intern/MOD_weightvgproximity.c
source/blender/modifiers/intern/MOD_wireframe.c
source/blender/python/bmesh/bmesh_py_types.c
source/blender/python/mathutils/mathutils_bvhtree.c
source/blender/render/intern/source/pointdensity.c
source/blender/windowmanager/intern/wm_event_system.c

index 6e149956fbf3af2e0ebd1071a63db1f22a0b8b38..a587e2a2cd1d4167bceef63c40d5460f96f8ffd7 100644 (file)
@@ -69,7 +69,7 @@ void AbcHairWriter::do_write()
        if (!m_psys) {
                return;
        }
-       Mesh *mesh = mesh_get_eval_final(m_settings.depsgraph, m_settings.scene, m_object, CD_MASK_MESH);
+       Mesh *mesh = mesh_get_eval_final(m_settings.depsgraph, m_settings.scene, m_object, &CD_MASK_MESH);
        BKE_mesh_tessface_ensure(mesh);
 
        std::vector<Imath::V3f> verts;
index d7d826cce121b6e078edf043ea937115e4e35ee4..50d9567fba75ad92fa41420e066f70e0de11830e 100644 (file)
@@ -554,7 +554,7 @@ Mesh *AbcGenericMeshWriter::getFinalMesh(bool &r_needsfree)
 
                BM_mesh_triangulate(bm, quad_method, ngon_method, tag_only, NULL, NULL, NULL);
 
-               Mesh *result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+               Mesh *result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
                BM_mesh_free(bm);
 
                if (r_needsfree) {
@@ -671,7 +671,7 @@ AbcMeshWriter::~AbcMeshWriter()
 
 Mesh *AbcMeshWriter::getEvaluatedMesh(Scene *scene_eval, Object *ob_eval, bool &UNUSED(r_needsfree))
 {
-       return mesh_get_eval_final(m_settings.depsgraph, scene_eval, ob_eval, CD_MASK_MESH);
+       return mesh_get_eval_final(m_settings.depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
 }
 
 
@@ -1059,7 +1059,7 @@ void AbcMeshReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelec
        m_object->data = mesh;
 
        Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
-       BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, CD_MASK_MESH, true);
+       BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
 
        if (m_settings->validate_meshes) {
                BKE_mesh_validate(mesh, false, false);
@@ -1342,7 +1342,7 @@ void AbcSubDReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelec
        m_object->data = mesh;
 
        Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
-       BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, CD_MASK_MESH, true);
+       BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
 
        ISubDSchema::Sample sample;
        try {
index a36c7c5bfb96081830e0348ee7f1fac162dd1310..d9b78f83ff53577d09ed0f9e49e966f6cadd49da 100644 (file)
@@ -174,7 +174,7 @@ void AbcPointsReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSel
        Mesh *mesh = BKE_mesh_add(bmain, m_data_name.c_str());
        Mesh *read_mesh = this->read_mesh(mesh, sample_sel, 0, NULL);
 
-       BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, CD_MASK_MESH, true);
+       BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
 
        if (m_settings->validate_meshes) {
                BKE_mesh_validate(mesh, false, false);
index fb78e03639bbf074039f4e715e83bca374c99e67..cd7422415dcb189ef9985e522eba4f0c6281f6df 100644 (file)
@@ -75,6 +75,7 @@
 struct BMEditMesh;
 struct CCGElem;
 struct CCGKey;
+struct CustomData_MeshMasks;
 struct Depsgraph;
 struct MEdge;
 struct MFace;
@@ -348,7 +349,7 @@ void DM_from_template_ex(
         DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
         int numVerts, int numEdges, int numTessFaces,
         int numLoops, int numPolys,
-        CustomDataMask mask);
+        const struct CustomData_MeshMasks *mask);
 void DM_from_template(
         DerivedMesh *dm, DerivedMesh *source,
         DerivedMeshType type,
@@ -362,10 +363,11 @@ int DM_release(DerivedMesh *dm);
 
 /** utility function to convert a DerivedMesh to a Mesh
  */
-void DM_to_mesh(DerivedMesh *dm, struct Mesh *me, struct Object *ob, CustomDataMask mask, bool take_ownership);
+void DM_to_mesh(DerivedMesh *dm, struct Mesh *me, struct Object *ob,
+                const struct CustomData_MeshMasks *mask, bool take_ownership);
 
 
-void DM_set_only_copy(DerivedMesh *dm, CustomDataMask mask);
+void DM_set_only_copy(DerivedMesh *dm, const struct CustomData_MeshMasks *mask);
 
 /* adds a vertex/edge/face custom data layer to a DerivedMesh, optionally
  * backed by an external data array
@@ -488,27 +490,27 @@ void mesh_get_mapped_verts_coords(struct Mesh *me_eval, float (*r_cos)[3], const
 
 DerivedMesh *mesh_create_derived_render(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 
 /* same as above but wont use render settings */
 DerivedMesh *mesh_create_derived(struct Mesh *me, float (*vertCos)[3]);
 
 struct Mesh *editbmesh_get_eval_cage(
         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
-        struct BMEditMesh *em, CustomDataMask dataMask);
+        struct BMEditMesh *em, const struct CustomData_MeshMasks *dataMask);
 struct Mesh *editbmesh_get_eval_cage_from_orig(
         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
-        struct BMEditMesh *em, CustomDataMask dataMask);
+        struct BMEditMesh *em, const struct CustomData_MeshMasks *dataMask);
 struct Mesh *editbmesh_get_eval_cage_and_final(
         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
-        struct BMEditMesh *em, CustomDataMask dataMask,
+        struct BMEditMesh *em, const struct CustomData_MeshMasks *dataMask,
         struct Mesh **r_final);
 
 float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
 bool editbmesh_modifier_is_enabled(struct Scene *scene, struct ModifierData *md, bool has_prev_mesh);
 void makeDerivedMesh(
         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct BMEditMesh *em,
-        CustomDataMask dataMask, const bool build_shapekey_layers);
+        const struct CustomData_MeshMasks *dataMask, const bool build_shapekey_layers);
 
 void DM_add_named_tangent_layer_for_uv(
         CustomData *uv_data, CustomData *tan_data, int numLoopData,
index 1e7bad3cd6c4109911d9abde56962cb185bfd6ce..e218355447d787d401c54bdaa04e6338479659b6 100644 (file)
@@ -31,6 +31,7 @@
 #include "BKE_customdata.h"
 
 struct BMEditMesh;
+struct CustomData_MeshMasks;
 struct DerivedMesh;
 struct MLoopNorSpaceArray;
 struct Mesh;
@@ -47,7 +48,7 @@ struct DerivedMesh *CDDM_new(int numVerts, int numEdges, int numFaces,
 struct DerivedMesh *CDDM_from_mesh(struct Mesh *mesh);
 
 /* creates a CDDerivedMesh from the given Mesh with custom allocation type. */
-struct DerivedMesh *CDDM_from_mesh_ex(struct Mesh *mesh, eCDAllocType alloctype, CustomDataMask mask);
+struct DerivedMesh *CDDM_from_mesh_ex(struct Mesh *mesh, eCDAllocType alloctype, const struct CustomData_MeshMasks *mask);
 
 
 struct DerivedMesh *CDDM_from_bmesh(struct BMesh *bm, const bool use_mdisps);
@@ -71,11 +72,10 @@ struct DerivedMesh *CDDM_copy(struct DerivedMesh *dm);
  * given DerivedMesh and containing the requested numbers of elements.
  * elements are initialized to all zeros
  */
-struct DerivedMesh *CDDM_from_template_ex(
-        struct DerivedMesh *source,
+struct DerivedMesh *CDDM_from_template_ex(struct DerivedMesh *source,
         int numVerts, int numEdges, int numFaces,
         int numLoops, int numPolys,
-        CustomDataMask mask);
+        const struct CustomData_MeshMasks *mask);
 struct DerivedMesh *CDDM_from_template(
         struct DerivedMesh *source,
         int numVerts, int numEdges, int numFaces,
index ba3d1dbf187723660046b65b1b8f421186decff5..4a7e6b22b0ced91c80809b806ad56c4fa80bd018 100644 (file)
@@ -36,19 +36,21 @@ extern "C" {
 
 struct BMesh;
 struct CustomData;
+struct CustomData_MeshMasks;
 struct ID;
 typedef uint64_t CustomDataMask;
 
 /*a data type large enough to hold 1 element from any customdata layer type*/
 typedef struct {unsigned char data[64]; } CDBlockBytes;
 
-extern const CustomDataMask CD_MASK_BAREMESH;
-extern const CustomDataMask CD_MASK_MESH;
-extern const CustomDataMask CD_MASK_EDITMESH;
-extern const CustomDataMask CD_MASK_DERIVEDMESH;
-extern const CustomDataMask CD_MASK_BMESH;
-extern const CustomDataMask CD_MASK_FACECORNERS;
-extern const CustomDataMask CD_MASK_EVERYTHING;
+extern const CustomData_MeshMasks CD_MASK_BAREMESH;
+extern const CustomData_MeshMasks CD_MASK_BAREMESH_ORIGINDEX;
+extern const CustomData_MeshMasks CD_MASK_MESH;
+extern const CustomData_MeshMasks CD_MASK_EDITMESH;
+extern const CustomData_MeshMasks CD_MASK_DERIVEDMESH;
+extern const CustomData_MeshMasks CD_MASK_BMESH;
+extern const CustomData_MeshMasks CD_MASK_FACECORNERS;
+extern const CustomData_MeshMasks CD_MASK_EVERYTHING;
 
 /* for ORIGINDEX layer type, indicates no original index for this element */
 #define ORIGINDEX_NONE -1
@@ -69,12 +71,15 @@ typedef enum eCDAllocType {
 
 #define CD_TYPE_AS_MASK(_type) (CustomDataMask)((CustomDataMask)1 << (CustomDataMask)(_type))
 
-void customData_mask_layers__print(CustomDataMask mask);
+void customData_mask_layers__print(const struct CustomData_MeshMasks *mask);
 
 typedef void (*cd_interp)(const void **sources, const float *weights, const float *sub_weights, int count, void *dest);
 typedef void (*cd_copy)(const void *source, void *dest, int count);
 typedef bool (*cd_validate)(void *item, const uint totitems, const bool do_fixes);
 
+void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst, const CustomData_MeshMasks *mask_src);
+bool CustomData_MeshMasks_are_matching(const CustomData_MeshMasks *mask_ref, const CustomData_MeshMasks *mask_required);
+
 /**
  * Checks if the layer at physical offset \a layer_n (in data->layers) support math
  * the below operations.
index dea36a6fce3f31a92fd04bf8321f0e6639bcf39a..8f949e5d9854b9d34ff951f2402706aa28280d75 100644 (file)
@@ -66,7 +66,7 @@ enum {
 };
 
 
-CustomDataMask BKE_object_data_transfer_dttypes_to_cdmask(const int dtdata_types);
+void BKE_object_data_transfer_dttypes_to_cdmask(const int dtdata_types, struct CustomData_MeshMasks *r_data_masks);
 bool BKE_object_data_transfer_get_dttypes_capacity(
         const int dtdata_types, bool *r_advanced_mixing, bool *r_threshold);
 int BKE_object_data_transfer_get_dttypes_item_types(const int dtdata_types);
index 4850c864d4ab9e421d340ca818e3782f1ab1abd6..34cd3ddf6f6cbdff2f80098ad33919882b547230 100644 (file)
@@ -61,7 +61,7 @@ typedef struct BMEditMesh {
        struct Mesh *mesh_eval_final, *mesh_eval_cage;
 
        /*derivedmesh stuff*/
-       CustomDataMask lastDataMask;
+       CustomData_MeshMasks lastDataMask;
        unsigned char (*derivedVertColor)[4];
        int derivedVertColorLen;
        unsigned char (*derivedFaceColor)[4];
index 07d04a55496a92400d250efdcb9a9736493f6bda..a2613c2c2e3504585d658dd057ab5de36454c624 100644 (file)
@@ -27,7 +27,7 @@
 #include "BLI_compiler_compat.h"
 
 /* defines CustomDataMask */
-#include "BKE_customdata.h"
+//#include "BKE_customdata.h"
 
 struct BLI_Stack;
 struct BMEditMesh;
@@ -37,6 +37,7 @@ struct BMeshFromMeshParams;
 struct BMeshToMeshParams;
 struct BoundBox;
 struct CustomData;
+struct CustomData_MeshMasks;
 struct Depsgraph;
 struct EdgeHash;
 struct ID;
@@ -83,10 +84,10 @@ struct BMesh *BKE_mesh_to_bmesh(
         const bool add_key_index, const struct BMeshCreateParams *params);
 
 struct Mesh *BKE_mesh_from_bmesh_nomain(struct BMesh *bm, const struct BMeshToMeshParams *params);
-struct Mesh *BKE_mesh_from_bmesh_for_eval_nomain(struct BMesh *bm, const int64_t cd_mask_extra);
+struct Mesh *BKE_mesh_from_bmesh_for_eval_nomain(struct BMesh *bm, const struct CustomData_MeshMasks *cd_mask_extra);
 
 struct Mesh *BKE_mesh_from_editmesh_with_coords_thin_wrap(
-        struct BMEditMesh *em, CustomDataMask data_mask, float (*vertexCos)[3]);
+        struct BMEditMesh *em, const struct CustomData_MeshMasks *data_mask, float (*vertexCos)[3]);
 
 int poly_find_loop_from_vert(
         const struct MPoly *poly,
@@ -179,7 +180,7 @@ struct Mesh *BKE_mesh_create_derived_for_modifier(
 
 /* Copies a nomain-Mesh into an existing Mesh. */
 void BKE_mesh_nomain_to_mesh(struct Mesh *mesh_src, struct Mesh *mesh_dst, struct Object *ob,
-                             CustomDataMask mask, bool take_ownership);
+                             const struct CustomData_MeshMasks *mask, bool take_ownership);
 void BKE_mesh_nomain_to_meshkey(struct Mesh *mesh_src, struct Mesh *mesh_dst, struct KeyBlock *kb);
 
 
index 4ee8995dd99314c30c726b5d3295994980e9e63c..d3eb573bc2da2019b26a7fec84862dc3f2d5dc64 100644 (file)
  * This file contains access functions for the Mesh.runtime struct.
  */
 
-#include "BKE_customdata.h"  /* for CustomDataMask */
+//#include "BKE_customdata.h"  /* for CustomDataMask */
 
 struct ColorBand;
 struct CustomData;
+struct CustomData_MeshMasks;
 struct Depsgraph;
 struct KeyBlock;
 struct MLoop;
@@ -66,50 +67,50 @@ void BKE_mesh_runtime_verttri_from_looptri(
 #ifdef USE_DERIVEDMESH
 struct DerivedMesh *mesh_get_derived_final(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 #endif
 struct Mesh *mesh_get_eval_final(
-        struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, CustomDataMask dataMask);
+        struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 
 #ifdef USE_DERIVEDMESH
 struct DerivedMesh *mesh_get_derived_deform(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 #endif
 struct Mesh *mesh_get_eval_deform(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 
 struct Mesh *mesh_create_eval_final_render(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 
 #ifdef USE_DERIVEDMESH
 struct DerivedMesh *mesh_create_derived_index_render(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask, int index);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask, int index);
 #endif
 struct Mesh *mesh_create_eval_final_index_render(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask, int index);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask, int index);
 
 #ifdef USE_DERIVEDMESH
 struct DerivedMesh *mesh_create_derived_view(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 #endif
 struct Mesh *mesh_create_eval_final_view(
         struct Depsgraph *depsgraph, struct Scene *scene,
-        struct Object *ob, CustomDataMask dataMask);
+        struct Object *ob, const struct CustomData_MeshMasks *dataMask);
 
 struct Mesh *mesh_create_eval_no_deform(
         struct Depsgraph *depsgraph, struct Scene *scene,
         struct Object *ob, float (*vertCos)[3],
-        CustomDataMask dataMask);
+        const struct CustomData_MeshMasks *dataMask);
 struct Mesh *mesh_create_eval_no_deform_render(
         struct Depsgraph *depsgraph, struct Scene *scene,
         struct Object *ob, float (*vertCos)[3],
-        CustomDataMask dataMask);
+        const struct CustomData_MeshMasks *dataMask);
 
 
 void BKE_mesh_runtime_eval_to_meshkey(struct Mesh *me_deformed, struct Mesh *me, struct KeyBlock *kb);
index 51fb6d8a5919f4d0a018b5235fb52c81ae529036..1a1e510b9e1c0a275652adf335b217cdfbfa891b 100644 (file)
@@ -25,6 +25,7 @@
 #include "BKE_customdata.h"
 
 struct BMEditMesh;
+struct CustomData_MeshMasks;
 struct DepsNodeHandle;
 struct Depsgraph;
 struct DerivedMesh;
@@ -214,23 +215,20 @@ typedef struct ModifierTypeInfo {
         */
        void (*initData)(struct ModifierData *md);
 
-       /* Should return a CustomDataMask indicating what data this
+       /* Should add to passed \a r_cddata_masks the data types that this
         * modifier needs. If (mask & (1 << (layer type))) != 0, this modifier
-        * needs that custom data layer. This function's return value can change
+        * needs that custom data layer. It can change required layers
         * depending on the modifier's settings.
         *
         * Note that this means extra data (e.g. vertex groups) - it is assumed
         * that all modifiers need mesh data and deform modifiers need vertex
         * coordinates.
         *
-        * Note that this limits the number of custom data layer types to 32.
-        *
-        * If this function is not present or it returns 0, it is assumed that
-        * no extra data is needed.
+        * If this function is not present, it is assumed that no extra data is needed.
         *
         * This function is optional.
         */
-       CustomDataMask (*requiredDataMask)(struct Object *ob, struct ModifierData *md);
+       void (*requiredDataMask)(struct Object *ob, struct ModifierData *md, struct CustomData_MeshMasks *r_cddata_masks);
 
        /* Free internal modifier data variables, this function should
         * not free the md variable itself.
@@ -365,10 +363,10 @@ bool          modifiers_isPreview(struct Object *ob);
 
 typedef struct CDMaskLink {
        struct CDMaskLink *next;
-       CustomDataMask mask;
+       struct CustomData_MeshMasks mask;
 } CDMaskLink;
 
-/* Calculates and returns a linked list of CustomDataMasks indicating the
+/* Calculates and returns a linked list of CustomData_MeshMasks indicating the
  * data required by each modifier in the stack pointed to by md for correct
  * evaluation, assuming the data indicated by dataMask is required at the
  * end of the stack.
@@ -376,9 +374,10 @@ typedef struct CDMaskLink {
 struct CDMaskLink *modifiers_calcDataMasks(struct Scene *scene,
                                            struct Object *ob,
                                            struct ModifierData *md,
-                                           CustomDataMask dataMask,
+                                           const struct CustomData_MeshMasks *dataMask,
                                            int required_mode,
-                                           ModifierData *previewmd, CustomDataMask previewmask);
+                                           ModifierData *previewmd,
+                                           const struct CustomData_MeshMasks *previewmask);
 struct ModifierData *modifiers_getLastPreview(struct Scene *scene,
                                               struct ModifierData *md,
                                               int required_mode);
index 715d867007199a64606e202481b36b9f5baa80cb..19036e63a8c4b74f7ea6a859a60fe4a23f4081f8 100644 (file)
@@ -41,6 +41,7 @@ struct ParticleSystemModifierData;
 
 struct BVHTreeRay;
 struct BVHTreeRayHit;
+struct CustomData_MeshMasks;
 struct Depsgraph;
 struct Depsgraph;
 struct EdgeHash;
@@ -333,7 +334,7 @@ void psys_interpolate_mcol(const struct MCol *mcol, int quad, const float w[4],
 
 void copy_particle_key(struct ParticleKey *to, struct ParticleKey *from, int time);
 
-CustomDataMask psys_emitter_customdata_mask(struct ParticleSystem *psys);
+void psys_emitter_customdata_mask(struct ParticleSystem *psys, struct CustomData_MeshMasks *r_cddata_masks);
 void psys_particle_on_emitter(struct ParticleSystemModifierData *psmd, int distr, int index, int index_dmcache,
                               float fuv[4], float foffset, float vec[3], float nor[3],
                               float utan[3], float vtan[3], float orco[3]);
index 27da5b8c63582bf4de4d673f6afd4bc61017cc7e..a3f89d65c5a5ed884c7ed1ba51c3dbfc369ae454 100644 (file)
@@ -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");
index cb4118b6abb52b6c1a2ff7c143be7b27eaac5467..859c5534183f733206d8da802b9463dc58c6df0e 100644 (file)
@@ -582,15 +582,16 @@ DerivedMesh *CDDM_new(int numVerts, int numEdges, int numTessFaces, int numLoops
 
 DerivedMesh *CDDM_from_mesh(Mesh *mesh)
 {
-       return CDDM_from_mesh_ex(mesh, CD_REFERENCE, CD_MASK_MESH);
+       return CDDM_from_mesh_ex(mesh, CD_REFERENCE, &CD_MASK_MESH);
 }
 
-DerivedMesh *CDDM_from_mesh_ex(Mesh *mesh, eCDAllocType alloctype, CustomDataMask mask)
+DerivedMesh *CDDM_from_mesh_ex(Mesh *mesh, eCDAllocType alloctype, const CustomData_MeshMasks *mask)
 {
        CDDerivedMesh *cddm = cdDM_create(__func__);
        DerivedMesh *dm = &cddm->dm;
+       CustomData_MeshMasks cddata_masks = *mask;
 
-       mask &= ~CD_MASK_MDISPS;
+       cddata_masks.lmask &= ~CD_MASK_MDISPS;
 
        /* this does a referenced copy, with an exception for fluidsim */
 
@@ -608,15 +609,15 @@ DerivedMesh *CDDM_from_mesh_ex(Mesh *mesh, eCDAllocType alloctype, CustomDataMas
        }
        /* TODO DM_DIRTY_TESS_CDLAYERS ? Maybe not though, since we probably want to switch to looptris ? */
 
-       CustomData_merge(&mesh->vdata, &dm->vertData, mask, alloctype,
+       CustomData_merge(&mesh->vdata, &dm->vertData, cddata_masks.vmask, alloctype,
                         mesh->totvert);
-       CustomData_merge(&mesh->edata, &dm->edgeData, mask, alloctype,
+       CustomData_merge(&mesh->edata, &dm->edgeData, cddata_masks.emask, alloctype,
                         mesh->totedge);
-       CustomData_merge(&mesh->fdata, &dm->faceData, mask | CD_MASK_ORIGINDEX, alloctype,
+       CustomData_merge(&mesh->fdata, &dm->faceData, cddata_masks.fmask | CD_MASK_ORIGINDEX, alloctype,
                         0 /* mesh->totface */);
-       CustomData_merge(&mesh->ldata, &dm->loopData, mask, alloctype,
+       CustomData_merge(&mesh->ldata, &dm->loopData, cddata_masks.lmask, alloctype,
                         mesh->totloop);
-       CustomData_merge(&mesh->pdata, &dm->polyData, mask, alloctype,
+       CustomData_merge(&mesh->pdata, &dm->polyData, cddata_masks.pmask, alloctype,
                         mesh->totpoly);
 
        cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
@@ -767,7 +768,7 @@ static DerivedMesh *cddm_from_bmesh_ex(
        int numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
        int numUV  = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
        int *index, add_orig;
-       CustomDataMask mask;
+       CustomData_MeshMasks mask = {0};
        unsigned int i, j;
 
        const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
@@ -779,18 +780,21 @@ static DerivedMesh *cddm_from_bmesh_ex(
        /* don't add origindex layer if one already exists */
        add_orig = !CustomData_has_layer(&bm->pdata, CD_ORIGINDEX);
 
-       mask = use_mdisps ? CD_MASK_DERIVEDMESH | CD_MASK_MDISPS : CD_MASK_DERIVEDMESH;
+       mask = CD_MASK_DERIVEDMESH;
+       if (use_mdisps) {
+               mask.lmask |= CD_MASK_MDISPS;
+       }
 
        /* don't process shapekeys, we only feed them through the modifier stack as needed,
         * e.g. for applying modifiers or the like*/
-       mask &= ~CD_MASK_SHAPEKEY;
-       CustomData_merge(&bm->vdata, &dm->vertData, mask,
+       mask.vmask &= ~CD_MASK_SHAPEKEY;
+       CustomData_merge(&bm->vdata, &dm->vertData, mask.vmask,
                         CD_CALLOC, dm->numVertData);
-       CustomData_merge(&bm->edata, &dm->edgeData, mask,
+       CustomData_merge(&bm->edata, &dm->edgeData, mask.emask,
                         CD_CALLOC, dm->numEdgeData);
-       CustomData_merge(&bm->ldata, &dm->loopData, mask,
+       CustomData_merge(&bm->ldata, &dm->loopData, mask.lmask,
                         CD_CALLOC, dm->numLoopData);
-       CustomData_merge(&bm->pdata, &dm->polyData, mask,
+       CustomData_merge(&bm->pdata, &dm->polyData, mask.pmask,
                         CD_CALLOC, dm->numPolyData);
 
        /* add tessellation mface layers */
@@ -974,11 +978,10 @@ DerivedMesh *CDDM_copy(DerivedMesh *source)
 
 /* note, the CD_ORIGINDEX layers are all 0, so if there is a direct
  * relationship between mesh data this needs to be set by the caller. */
-DerivedMesh *CDDM_from_template_ex(
-        DerivedMesh *source,
+DerivedMesh *CDDM_from_template_ex(DerivedMesh *source,
         int numVerts, int numEdges, int numTessFaces,
         int numLoops, int numPolys,
-        CustomDataMask mask)
+        const CustomData_MeshMasks *mask)
 {
        CDDerivedMesh *cddm = cdDM_create("CDDM_from_template dest");
        DerivedMesh *dm = &cddm->dm;
@@ -1026,7 +1029,7 @@ DerivedMesh *CDDM_from_template(
        return CDDM_from_template_ex(
                source, numVerts, numEdges, numTessFaces,
                numLoops, numPolys,
-               CD_MASK_DERIVEDMESH);
+               &CD_MASK_DERIVEDMESH);
 }
 
 void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3])
index 270849c8ff8cdc9e2333bdff344295030aa12e0b..3b83d7308a479600cb3959a68920650e62c30224 100644 (file)
@@ -105,13 +105,13 @@ float (*BKE_crazyspace_get_mapped_editverts(
        /* disable subsurf temporal, get mapped cos, and enable it */
        if (modifiers_disable_subsurf_temporary(obedit)) {
                /* need to make new derivemesh */
-               makeDerivedMesh(depsgraph, scene, obedit, me->edit_mesh, CD_MASK_BAREMESH, false);
+               makeDerivedMesh(depsgraph, scene, obedit, me->edit_mesh, &CD_MASK_BAREMESH, false);
        }
 
        /* now get the cage */
        vertexcos = MEM_mallocN(sizeof(*vertexcos) * nverts, "vertexcos map");
 
-       me_eval = editbmesh_get_eval_cage_from_orig(depsgraph, scene, obedit, me->edit_mesh, CD_MASK_BAREMESH);
+       me_eval = editbmesh_get_eval_cage_from_orig(depsgraph, scene, obedit, me->edit_mesh, &CD_MASK_BAREMESH);
 
        mesh_get_mapped_verts_coords(me_eval, vertexcos, nverts);
 
@@ -273,12 +273,12 @@ int BKE_crazyspace_get_first_deform_matrices_editbmesh(
                if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
                        if (!defmats) {
                                const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
-                               CustomDataMask data_mask = CD_MASK_BAREMESH;
-                               CDMaskLink *datamasks = modifiers_calcDataMasks(scene, ob, md, data_mask, required_mode, NULL, 0);
+                               CustomData_MeshMasks data_mask = CD_MASK_BAREMESH;
+                               CDMaskLink *datamasks = modifiers_calcDataMasks(scene, ob, md, &data_mask, required_mode, NULL, NULL);
                                data_mask = datamasks->mask;
                                BLI_linklist_free((LinkNode *)datamasks, NULL);
 
-                               me = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, data_mask, NULL);
+                               me = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, &data_mask, NULL);
                                deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
                                defmats = MEM_mallocN(sizeof(*defmats) * numVerts, "defmats");
 
index f4b9040ce85ffd57ffbe40ff022dd7dfffc4c020..c3e45480a57fdf4be5a7dd4bedbddbf58c005932 100644 (file)
@@ -62,6 +62,28 @@ BLI_STATIC_ASSERT(ARRAY_SIZE(((CustomData *)NULL)->typemap) == CD_NUMTYPES, "siz
 
 static CLG_LogRef LOG = {"bke.customdata"};
 
+
+/** Update mask_dst with layers defined in mask_src (equivalent to a bitwise OR). */
+void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst, const CustomData_MeshMasks *mask_src)
+{
+       mask_dst->vmask |= mask_src->vmask;
+       mask_dst->emask |= mask_src->emask;
+       mask_dst->fmask |= mask_src->fmask;
+       mask_dst->pmask |= mask_src->pmask;
+       mask_dst->lmask |= mask_src->lmask;
+}
+
+/** Return True if all layers set in \a mask_required are also set in \a mask_ref */
+bool CustomData_MeshMasks_are_matching(const CustomData_MeshMasks *mask_ref, const CustomData_MeshMasks *mask_required)
+{
+       return (((mask_required->vmask & mask_ref->vmask) == mask_required->vmask) &&
+               ((mask_required->emask & mask_ref->emask) == mask_required->emask) &&
+               ((mask_required->fmask & mask_ref->fmask) == mask_required->fmask) &&
+               ((mask_required->pmask & mask_ref->pmask) == mask_required->pmask) &&
+               ((mask_required->lmask & mask_ref->lmask) == mask_required->lmask));
+}
+
+
 /********************* Layer type information **********************/
 typedef struct LayerTypeInfo {
        int size;          /* the memory size of one element of this layer's data */
@@ -1370,59 +1392,83 @@ static const char *LAYERTYPENAMES[CD_NUMTYPES] = {
 };
 
 
-const CustomDataMask CD_MASK_BAREMESH =
-    CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MLOOP | CD_MASK_MPOLY | CD_MASK_BWEIGHT | CD_MASK_FACEMAP;
-const CustomDataMask CD_MASK_MESH =
-    CD_MASK_MVERT | CD_MASK_MEDGE |
-    CD_MASK_MDEFORMVERT |
-    CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS |
-    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MPOLY | CD_MASK_MLOOP |
-    CD_MASK_RECAST | CD_MASK_PAINT_MASK |
-    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
-    CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_FACEMAP;
-const CustomDataMask CD_MASK_EDITMESH =
-    CD_MASK_MDEFORMVERT | CD_MASK_MLOOPUV |
-    CD_MASK_MLOOPCOL | CD_MASK_SHAPE_KEYINDEX |
-    CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR |
-    CD_MASK_MDISPS | CD_MASK_SHAPEKEY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
-    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_FACEMAP;
-const CustomDataMask CD_MASK_DERIVEDMESH =
-    CD_MASK_MDEFORMVERT |
-    CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_CLOTH_ORCO |
-    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_PREVIEW_MLOOPCOL |
-    CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP | CD_MASK_ORCO | CD_MASK_TANGENT |
-    CD_MASK_PREVIEW_MCOL | CD_MASK_SHAPEKEY | CD_MASK_RECAST |
-    CD_MASK_ORIGINDEX | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
-    CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_FACEMAP;
-const CustomDataMask CD_MASK_BMESH =
-    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL |
-    CD_MASK_MDEFORMVERT | CD_MASK_PROP_FLT | CD_MASK_PROP_INT |
-    CD_MASK_PROP_STR | CD_MASK_SHAPEKEY | CD_MASK_SHAPE_KEYINDEX | CD_MASK_MDISPS |
-    CD_MASK_CREASE | CD_MASK_BWEIGHT | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
-    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
-    CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_FACEMAP;
+const CustomData_MeshMasks CD_MASK_BAREMESH = {
+    .vmask = CD_MASK_MVERT | CD_MASK_BWEIGHT,
+    .emask = CD_MASK_MEDGE | CD_MASK_BWEIGHT,
+    .fmask = 0,
+    .lmask = CD_MASK_MLOOP,
+    .pmask = CD_MASK_MPOLY | CD_MASK_FACEMAP,
+};
+const CustomData_MeshMasks CD_MASK_BAREMESH_ORIGINDEX = {
+    .vmask = CD_MASK_MVERT | CD_MASK_BWEIGHT | CD_MASK_ORIGINDEX,
+    .emask = CD_MASK_MEDGE | CD_MASK_BWEIGHT | CD_MASK_ORIGINDEX,
+    .fmask = 0,
+    .lmask = CD_MASK_MLOOP,
+    .pmask = CD_MASK_MPOLY | CD_MASK_FACEMAP | CD_MASK_ORIGINDEX,
+};
+const CustomData_MeshMasks CD_MASK_MESH = {
+    .vmask = (CD_MASK_MVERT | CD_MASK_MDEFORMVERT | CD_MASK_BWEIGHT | CD_MASK_MVERT_SKIN | CD_MASK_PAINT_MASK |
+              CD_MASK_GENERIC_DATA),
+    .emask = (CD_MASK_MEDGE | CD_MASK_BWEIGHT | CD_MASK_FREESTYLE_EDGE | CD_MASK_GENERIC_DATA),
+    .fmask = 0,
+    .lmask = (CD_MASK_MLOOP | CD_MASK_MDISPS | CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_CUSTOMLOOPNORMAL |
+              CD_MASK_GRID_PAINT_MASK | CD_MASK_GENERIC_DATA),
+    .pmask = (CD_MASK_MPOLY | CD_MASK_RECAST | CD_MASK_FACEMAP | CD_MASK_FREESTYLE_FACE | CD_MASK_GENERIC_DATA),
+};
+const CustomData_MeshMasks CD_MASK_EDITMESH = {
+    .vmask = (CD_MASK_MDEFORMVERT | CD_MASK_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_SHAPEKEY |
+              CD_MASK_SHAPE_KEYINDEX | CD_MASK_GENERIC_DATA),
+    .emask = (CD_MASK_GENERIC_DATA),
+    .fmask = 0,
+    .lmask = (CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_GRID_PAINT_MASK |
+              CD_MASK_GENERIC_DATA),
+    .pmask = (CD_MASK_MDISPS | CD_MASK_RECAST | CD_MASK_FACEMAP | CD_MASK_GENERIC_DATA),
+};
+const CustomData_MeshMasks CD_MASK_DERIVEDMESH = {
+    .vmask = (CD_MASK_ORIGINDEX | CD_MASK_MDEFORMVERT | CD_MASK_SHAPEKEY | CD_MASK_MVERT_SKIN |
+              CD_MASK_ORCO | CD_MASK_CLOTH_ORCO | CD_MASK_GENERIC_DATA),
+    .emask = (CD_MASK_ORIGINDEX | CD_MASK_FREESTYLE_EDGE | CD_MASK_GENERIC_DATA),
+    .fmask = (CD_MASK_ORIGINDEX | CD_MASK_ORIGSPACE | CD_MASK_PREVIEW_MCOL | CD_MASK_TANGENT),
+    .lmask = (CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_PREVIEW_MLOOPCOL |
+              CD_MASK_ORIGSPACE_MLOOP | CD_MASK_TANGENT | CD_MASK_GENERIC_DATA),
+    .pmask = (CD_MASK_ORIGINDEX | CD_MASK_RECAST | CD_MASK_FREESTYLE_FACE | CD_MASK_FACEMAP | CD_MASK_GENERIC_DATA),
+};
+const CustomData_MeshMasks CD_MASK_BMESH = {
+    .vmask = (CD_MASK_MDEFORMVERT | CD_MASK_BWEIGHT | CD_MASK_MVERT_SKIN | CD_MASK_SHAPEKEY |
+              CD_MASK_SHAPE_KEYINDEX | CD_MASK_PAINT_MASK | CD_MASK_GENERIC_DATA),
+    .emask = (CD_MASK_BWEIGHT | CD_MASK_CREASE | CD_MASK_FREESTYLE_EDGE | CD_MASK_GENERIC_DATA),
+    .fmask = 0,
+    .lmask = (CD_MASK_MDISPS | CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_CUSTOMLOOPNORMAL |
+              CD_MASK_GRID_PAINT_MASK | CD_MASK_GENERIC_DATA),
+    .pmask = (CD_MASK_RECAST | CD_MASK_FREESTYLE_FACE | CD_MASK_FACEMAP | CD_MASK_GENERIC_DATA),
+};
 /**
  * cover values copied by #BKE_mesh_loops_to_tessdata
  */
-const CustomDataMask CD_MASK_FACECORNERS =
-    CD_MASK_MTFACE | CD_MASK_MLOOPUV |
-    CD_MASK_MCOL | CD_MASK_MLOOPCOL |
-    CD_MASK_PREVIEW_MCOL | CD_MASK_PREVIEW_MLOOPCOL |
-    CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP |
-    CD_MASK_TESSLOOPNORMAL | CD_MASK_NORMAL |
-    CD_MASK_TANGENT | CD_MASK_MLOOPTANGENT;
-const CustomDataMask CD_MASK_EVERYTHING =
-    CD_MASK_MVERT | CD_MASK_MDEFORMVERT | CD_MASK_MEDGE | CD_MASK_MFACE |
-    CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_ORIGINDEX | CD_MASK_NORMAL /* | CD_MASK_POLYINDEX */ | CD_MASK_PROP_FLT |
-    CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORCO | CD_MASK_MLOOPUV |
-    CD_MASK_MLOOPCOL | CD_MASK_TANGENT | CD_MASK_MDISPS | CD_MASK_PREVIEW_MCOL | CD_MASK_CLOTH_ORCO | CD_MASK_RECAST |
-    /* BMESH ONLY START */
-    CD_MASK_MPOLY | CD_MASK_MLOOP | CD_MASK_SHAPE_KEYINDEX | CD_MASK_SHAPEKEY | CD_MASK_BWEIGHT | CD_MASK_CREASE |
-    CD_MASK_ORIGSPACE_MLOOP | CD_MASK_PREVIEW_MLOOPCOL | CD_MASK_BM_ELEM_PYPTR |
-    /* BMESH ONLY END */
-    CD_MASK_PAINT_MASK | CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN |
-    CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
-    CD_MASK_MLOOPTANGENT | CD_MASK_TESSLOOPNORMAL | CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_FACEMAP;
+const CustomData_MeshMasks CD_MASK_FACECORNERS = {
+    .vmask = 0,
+    .emask = 0,
+    .fmask = (CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_PREVIEW_MCOL | CD_MASK_ORIGSPACE |
+              CD_MASK_TESSLOOPNORMAL | CD_MASK_TANGENT),
+    .lmask = (CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_PREVIEW_MLOOPCOL | CD_MASK_ORIGSPACE_MLOOP |
+              CD_MASK_NORMAL | CD_MASK_MLOOPTANGENT),
+    .pmask = 0,
+};
+const CustomData_MeshMasks CD_MASK_EVERYTHING = {
+    .vmask = (CD_MASK_MVERT | CD_MASK_BM_ELEM_PYPTR | CD_MASK_ORIGINDEX | CD_MASK_NORMAL | CD_MASK_MDEFORMVERT |
+              CD_MASK_BWEIGHT | CD_MASK_MVERT_SKIN | CD_MASK_ORCO | CD_MASK_CLOTH_ORCO | CD_MASK_SHAPEKEY |
+              CD_MASK_SHAPE_KEYINDEX | CD_MASK_PAINT_MASK | CD_MASK_GENERIC_DATA),
+    .emask = (CD_MASK_MEDGE | CD_MASK_BM_ELEM_PYPTR | CD_MASK_ORIGINDEX | CD_MASK_BWEIGHT | CD_MASK_CREASE |
+              CD_MASK_FREESTYLE_EDGE | CD_MASK_GENERIC_DATA),
+    .fmask = (CD_MASK_MFACE | CD_MASK_ORIGINDEX | CD_MASK_NORMAL | CD_MASK_MTFACE | CD_MASK_MCOL |
+              CD_MASK_ORIGSPACE | CD_MASK_TANGENT | CD_MASK_TESSLOOPNORMAL | CD_MASK_PREVIEW_MCOL |
+              CD_MASK_GENERIC_DATA),
+    .lmask = (CD_MASK_MLOOP | CD_MASK_BM_ELEM_PYPTR | CD_MASK_MDISPS | CD_MASK_NORMAL | CD_MASK_MLOOPUV |
+              CD_MASK_MLOOPCOL | CD_MASK_CUSTOMLOOPNORMAL | CD_MASK_MLOOPTANGENT | CD_MASK_PREVIEW_MLOOPCOL |
+              CD_MASK_ORIGSPACE_MLOOP | CD_MASK_GRID_PAINT_MASK | CD_MASK_GENERIC_DATA),
+    .pmask = (CD_MASK_MPOLY | CD_MASK_BM_ELEM_PYPTR | CD_MASK_ORIGINDEX | CD_MASK_NORMAL | CD_MASK_RECAST |
+              CD_MASK_FACEMAP | CD_MASK_FREESTYLE_FACE | CD_MASK_GENERIC_DATA),
+};
 
 static const LayerTypeInfo *layerType_getInfo(int type)
 {
@@ -1438,13 +1484,41 @@ static const char *layerType_getName(int type)
        return LAYERTYPENAMES[type];
 }
 
-void customData_mask_layers__print(CustomDataMask mask)
+void customData_mask_layers__print(const CustomData_MeshMasks *mask)
 {
        int i;
 
-       printf("mask=0x%lx:\n", (long unsigned int)mask);
+       printf("verts mask=0x%lx:\n", (long unsigned int)mask->vmask);
+       for (i = 0; i < CD_NUMTYPES; i++) {
+               if (mask->vmask & CD_TYPE_AS_MASK(i)) {
+                       printf("  %s\n", layerType_getName(i));
+               }
+       }
+
+       printf("edges mask=0x%lx:\n", (long unsigned int)mask->emask);
+       for (i = 0; i < CD_NUMTYPES; i++) {
+               if (mask->emask & CD_TYPE_AS_MASK(i)) {
+                       printf("  %s\n", layerType_getName(i));
+               }
+       }
+
+       printf("faces mask=0x%lx:\n", (long unsigned int)mask->fmask);
+       for (i = 0; i < CD_NUMTYPES; i++) {
+               if (mask->fmask & CD_TYPE_AS_MASK(i)) {
+                       printf("  %s\n", layerType_getName(i));
+               }
+       }
+
+       printf("loops mask=0x%lx:\n", (long unsigned int)mask->lmask);
+       for (i = 0; i < CD_NUMTYPES; i++) {
+               if (mask->lmask & CD_TYPE_AS_MASK(i)) {
+                       printf("  %s\n", layerType_getName(i));
+               }
+       }
+
+       printf("polys mask=0x%lx:\n", (long unsigned int)mask->pmask);
        for (i = 0; i < CD_NUMTYPES; i++) {
-               if (mask & CD_TYPE_AS_MASK(i)) {
+               if (mask->pmask & CD_TYPE_AS_MASK(i)) {
                        printf("  %s\n", layerType_getName(i));
                }
        }
index 2f011d6a9198742d2673b46b35109a5de88558a9..4c4d57ddbac5e54005c7483ab6b74cd9981742d4 100644 (file)
 
 static CLG_LogRef LOG = {"bke.data_transfer"};
 
-CustomDataMask BKE_object_data_transfer_dttypes_to_cdmask(const int dtdata_types)
+void BKE_object_data_transfer_dttypes_to_cdmask(const int dtdata_types, CustomData_MeshMasks *r_data_masks)
 {
-       CustomDataMask cddata_mask = 0;
-       int i;
-
-       for (i = 0; i < DT_TYPE_MAX; i++) {
+       for (int i = 0; i < DT_TYPE_MAX; i++) {
                const int dtdata_type = 1 << i;
                int cddata_type;
 
@@ -66,20 +63,30 @@ CustomDataMask BKE_object_data_transfer_dttypes_to_cdmask(const int dtdata_types
 
                cddata_type = BKE_object_data_transfer_dttype_to_cdtype(dtdata_type);
                if (!(cddata_type & CD_FAKE)) {
-                       cddata_mask |= 1LL << cddata_type;
+                       if (DT_DATATYPE_IS_VERT(dtdata_type)) {
+                               r_data_masks->vmask |= 1LL << cddata_type;
+                       }
+                       else if (DT_DATATYPE_IS_EDGE(dtdata_type)) {
+                               r_data_masks->emask |= 1LL << cddata_type;
+                       }
+                       else if (DT_DATATYPE_IS_LOOP(dtdata_type)) {
+                               r_data_masks->lmask |= 1LL << cddata_type;
+                       }
+                       else if (DT_DATATYPE_IS_POLY(dtdata_type)) {
+                               r_data_masks->pmask |= 1LL << cddata_type;
+                       }
                }
                else if (cddata_type == CD_FAKE_MDEFORMVERT) {
-                       cddata_mask |= CD_MASK_MDEFORMVERT;  /* Exception for vgroups :/ */
+                       r_data_masks->vmask |= CD_MASK_MDEFORMVERT;  /* Exception for vgroups :/ */
                }
                else if (cddata_type == CD_FAKE_UV) {
-                       cddata_mask |= CD_MASK_MLOOPUV;
+                       r_data_masks->lmask |= CD_MASK_MLOOPUV;
                }
                else if (cddata_type == CD_FAKE_LNOR) {
-                       cddata_mask |= CD_MASK_NORMAL | CD_MASK_CUSTOMLOOPNORMAL;
+                       r_data_masks->vmask |= CD_MASK_NORMAL;
+                       r_data_masks->lmask |= CD_MASK_NORMAL | CD_MASK_CUSTOMLOOPNORMAL;
                }
        }
-
-       return cddata_mask;
 }
 
 /* Check what can do each layer type (if it is actually handled by transferdata, if it supports advanced mixing... */
@@ -992,15 +999,15 @@ void BKE_object_data_transfer_layout(
 
        const bool use_create = true;  /* We always create needed layers here. */
 
-       CustomDataMask me_src_mask = CD_MASK_BAREMESH;
+       CustomData_MeshMasks me_src_mask = CD_MASK_BAREMESH;
 
        BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH));
 
        me_dst = ob_dst->data;
 
        /* Get source evaluated mesh.*/
-       me_src_mask |= BKE_object_data_transfer_dttypes_to_cdmask(data_types);
-       me_src = mesh_get_eval_final(depsgraph, scene, ob_src, me_src_mask);
+       BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask);
+       me_src = mesh_get_eval_final(depsgraph, scene, ob_src, &me_src_mask);
        if (!me_src) {
                return;
        }
@@ -1090,7 +1097,7 @@ bool BKE_object_data_transfer_ex(
 
        const bool use_delete = false;  /* We never delete data layers from destination here. */
 
-       CustomDataMask me_src_mask = CD_MASK_BAREMESH;
+       CustomData_MeshMasks me_src_mask = CD_MASK_BAREMESH;
 
        BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH));
 
@@ -1113,17 +1120,17 @@ bool BKE_object_data_transfer_ex(
        }
 
        /* Get source evaluated mesh.*/
-       me_src_mask |= BKE_object_data_transfer_dttypes_to_cdmask(data_types);
+       BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask);
        if (is_modifier) {
                me_src = BKE_modifier_get_evaluated_mesh_from_evaluated_object(ob_src, false);
 
-               if (me_src == NULL || (me_src_mask & ~ob_src->runtime.last_data_mask) != 0) {
+               if (me_src == NULL || !CustomData_MeshMasks_are_matching(&ob_src->runtime.last_data_mask, &me_src_mask)) {
                        CLOG_WARN(&LOG, "Data Transfer: source mesh data is not ready - dependency cycle?");
                        return changed;
                }
        }
        else {
-               me_src = mesh_get_eval_final(depsgraph, scene, ob_src, me_src_mask);
+               me_src = mesh_get_eval_final(depsgraph, scene, ob_src, &me_src_mask);
        }
        if (!me_src) {
                return changed;
index ddb4b9eb2115528a7b30646cf8aa5981307bb364..c46691901f0ef6e2930c29fb1a65a5c7770289c0 100644 (file)
@@ -526,7 +526,7 @@ float (*BKE_editmesh_vertexCos_get(struct Depsgraph *depsgraph, BMEditMesh *em,
        struct CageUserData data;
        float (*cos_cage)[3];
 
-       cage = editbmesh_get_eval_cage(depsgraph, scene, em->ob, em, CD_MASK_BAREMESH);
+       cage = editbmesh_get_eval_cage(depsgraph, scene, em->ob, em, &CD_MASK_BAREMESH);
        cos_cage = MEM_callocN(sizeof(*cos_cage) * em->bm->totvert, "bmbvh cos_cage");
 
        /* when initializing cage verts, we only want the first cage coordinate for each vertex,
index 70f021c57f41df7479cab3b611bf8de05043f150..2263c5f1a05420b5cc3666b4f02a0f1d6fa3b6e4 100644 (file)
@@ -54,7 +54,7 @@ void initElbeemMesh(struct Depsgraph *depsgraph, struct Scene *scene, struct Obj
        float *verts;
        int *tris;
 
-       mesh = mesh_create_eval_final_index_render(depsgraph, scene, ob, CD_MASK_BAREMESH, modifierIndex);
+       mesh = mesh_create_eval_final_index_render(depsgraph, scene, ob, &CD_MASK_BAREMESH, modifierIndex);
 
        mvert = mesh->mvert;
        mloop = mesh->mloop;
index a05ba2bb35fdce1dd6088af3aa4c628507b5033b..592f3a26a1206b1c0242f01fb0818102a4925fcb 100644 (file)
@@ -535,22 +535,22 @@ void BKE_mesh_copy_data(Main *bmain, Mesh *me_dst, const Mesh *me_src, const int
        me_dst->runtime.is_original = false;
 
        const bool do_tessface = ((me_src->totface != 0) && (me_src->totpoly == 0)); /* only do tessface if we have no polys */
-       CustomDataMask mask = CD_MASK_MESH;
+       CustomData_MeshMasks mask = CD_MASK_MESH;
 
        if (me_src->id.tag & LIB_TAG_NO_MAIN) {
                /* For copies in depsgraph, keep data like origindex and orco. */
-               mask |= CD_MASK_DERIVEDMESH;
+               CustomData_MeshMasks_update(&mask, &CD_MASK_DERIVEDMESH);
        }
 
        me_dst->mat = MEM_dupallocN(me_src->mat);
 
        const eCDAllocType alloc_type = (flag & LIB_ID_COPY_CD_REFERENCE) ? CD_REFERENCE : CD_DUPLICATE;
-       CustomData_copy(&me_src->vdata, &me_dst->vdata, mask, alloc_type, me_dst->totvert);
-       CustomData_copy(&me_src->edata, &me_dst->edata, mask, alloc_type, me_dst->totedge);
-       CustomData_copy(&me_src->ldata, &me_dst->ldata, mask, alloc_type, me_dst->totloop);
-       CustomData_copy(&me_src->pdata, &me_dst->pdata, mask, alloc_type, me_dst->totpoly);
+       CustomData_copy(&me_src->vdata, &me_dst->vdata, mask.vmask, alloc_type, me_dst->totvert);
+       CustomData_copy(&me_src->edata, &me_dst->edata, mask.emask, alloc_type, me_dst->totedge);
+       CustomData_copy(&me_src->ldata, &me_dst->ldata, mask.lmask, alloc_type, me_dst->totloop);
+       CustomData_copy(&me_src->pdata, &me_dst->pdata, mask.pmask, alloc_type, me_dst->totpoly);
        if (do_tessface) {
-               CustomData_copy(&me_src->fdata, &me_dst->fdata, mask, alloc_type, me_dst->totface);
+               CustomData_copy(&me_src->fdata, &me_dst->fdata, mask.fmask, alloc_type, me_dst->totface);
        }
        else {
                mesh_tessface_clear_intern(me_dst, false);
@@ -629,7 +629,7 @@ static Mesh *mesh_new_nomain_from_template_ex(
         const Mesh *me_src,
         int verts_len, int edges_len, int tessface_len,
         int loops_len, int polys_len,
-        CustomDataMask mask)
+        CustomData_MeshMasks mask)
 {
        /* Only do tessface if we are creating tessfaces or copying from mesh with only tessfaces. */
        const bool do_tessface = (tessface_len ||
@@ -648,12 +648,12 @@ static Mesh *mesh_new_nomain_from_template_ex(
 
        me_dst->cd_flag = me_src->cd_flag;
 
-       CustomData_copy(&me_src->vdata, &me_dst->vdata, mask, CD_CALLOC, verts_len);
-       CustomData_copy(&me_src->edata, &me_dst->edata, mask, CD_CALLOC, edges_len);
-       CustomData_copy(&me_src->ldata, &me_dst->ldata, mask, CD_CALLOC, loops_len);
-       CustomData_copy(&me_src->pdata, &me_dst->pdata, mask, CD_CALLOC, polys_len);
+       CustomData_copy(&me_src->vdata, &me_dst->vdata, mask.vmask, CD_CALLOC, verts_len);
+       CustomData_copy(&me_src->edata, &me_dst->edata, mask.emask, CD_CALLOC, edges_len);
+       CustomData_copy(&me_src->ldata, &me_dst->ldata, mask.lmask, CD_CALLOC, loops_len);
+       CustomData_copy(&me_src->pdata, &me_dst->pdata, mask.pmask, CD_CALLOC, polys_len);
        if (do_tessface) {
-               CustomData_copy(&me_src->fdata, &me_dst->fdata, mask, CD_CALLOC, tessface_len);
+               CustomData_copy(&me_src->fdata, &me_dst->fdata, mask.fmask, CD_CALLOC, tessface_len);
        }
        else {
                mesh_tessface_clear_intern(me_dst, false);
@@ -736,7 +736,7 @@ Mesh *BKE_mesh_from_bmesh_nomain(BMesh *bm, const struct BMeshToMeshParams *para
        return mesh;
 }
 
-Mesh *BKE_mesh_from_bmesh_for_eval_nomain(BMesh *bm, const int64_t cd_mask_extra)
+Mesh *BKE_mesh_from_bmesh_for_eval_nomain(BMesh *bm, const CustomData_MeshMasks *cd_mask_extra)
 {
        Mesh *mesh = BKE_id_new_nomain(ID_ME, NULL);
        BM_mesh_bm_to_me_for_eval(bm, mesh, cd_mask_extra);
@@ -747,7 +747,7 @@ Mesh *BKE_mesh_from_bmesh_for_eval_nomain(BMesh *bm, const int64_t cd_mask_extra
  * TODO(campbell): support mesh with only an edit-mesh which is lazy initialized.
  */
 Mesh *BKE_mesh_from_editmesh_with_coords_thin_wrap(
-        BMEditMesh *em, CustomDataMask data_mask, float (*vertexCos)[3])
+        BMEditMesh *em, const CustomData_MeshMasks *data_mask, float (*vertexCos)[3])
 {
        Mesh *me = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, data_mask);
        /* Use editmesh directly where possible. */
index 5831471eb0566ce12b1b0fef627130c4eb573e0b..ad60cb9c49ded5e76127c72df9336ddcb61ba4d0 100644 (file)
@@ -592,7 +592,7 @@ void BKE_mesh_from_nurbs_displist(
        else {
                me = BKE_mesh_add(bmain, obdata_name);
                ob->runtime.mesh_eval = NULL;
-               BKE_mesh_nomain_to_mesh(me_eval, me, ob, CD_MASK_MESH, false);
+               BKE_mesh_nomain_to_mesh(me_eval, me, ob, &CD_MASK_MESH, false);
        }
 
        me->totcol = cu->totcol;
@@ -817,7 +817,7 @@ void BKE_mesh_to_curve(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(scene),
        /* make new mesh data from the original copy */
        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
-       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_MESH);
+       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
        ListBase nurblist = {NULL, NULL};
 
        BKE_mesh_to_curve_nurblist(me_eval, &nurblist, 0);
@@ -981,22 +981,22 @@ Mesh *BKE_mesh_new_from_object(
                        else {
                                /* Make a dummy mesh, saves copying */
                                Mesh *me_eval;
-                               /* CustomDataMask mask = CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL; */
-                               CustomDataMask mask = CD_MASK_MESH; /* this seems more suitable, exporter,
-                                                                    * for example, needs CD_MASK_MDEFORMVERT */
+                               CustomData_MeshMasks mask = CD_MASK_MESH; /* this seems more suitable, exporter,
+                                                                      * for example, needs CD_MASK_MDEFORMVERT */
 
-                               if (calc_undeformed)
-                                       mask |= CD_MASK_ORCO;
+                               if (calc_undeformed) {
+                                       mask.vmask |= CD_MASK_ORCO;
+                               }
 
                                if (render) {
-                                       me_eval = mesh_create_eval_final_render(depsgraph, sce, ob, mask);
+                                       me_eval = mesh_create_eval_final_render(depsgraph, sce, ob, &mask);
                                }
                                else {
-                                       me_eval = mesh_create_eval_final_view(depsgraph, sce, ob, mask);
+                                       me_eval = mesh_create_eval_final_view(depsgraph, sce, ob, &mask);
                                }
 
                                tmpmesh = BKE_mesh_add(bmain, ((ID *)ob->data)->name + 2);
-                               BKE_mesh_nomain_to_mesh(me_eval, tmpmesh, ob, mask, true);
+                               BKE_mesh_nomain_to_mesh(me_eval, tmpmesh, ob, &mask, true);
 
                                /* Copy autosmooth settings from original mesh. */
                                Mesh *me = (Mesh *)ob->data;
@@ -1228,7 +1228,8 @@ static void shapekey_layers_to_keyblocks(Mesh *mesh_src, Mesh *mesh_dst, int act
 
 
 /* This is a Mesh-based copy of DM_to_mesh() */
-void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, Mesh *mesh_dst, Object *ob, CustomDataMask mask, bool take_ownership)
+void BKE_mesh_nomain_to_mesh(
+        Mesh *mesh_src, Mesh *mesh_dst, Object *ob, const CustomData_MeshMasks *mask, bool take_ownership)
 {
        /* mesh_src might depend on mesh_dst, so we need to do everything with a local copy */
        /* TODO(Sybren): the above claim came from DM_to_mesh(); check whether it is still true with Mesh */
@@ -1262,10 +1263,10 @@ void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, Mesh *mesh_dst, Object *ob, CustomD
        totpoly = tmp.totpoly = mesh_src->totpoly;
        tmp.totface = 0;
 
-       CustomData_copy(&mesh_src->vdata, &tmp.vdata, mask, alloctype, totvert);
-       CustomData_copy(&mesh_src->edata, &tmp.edata, mask, alloctype, totedge);
-       CustomData_copy(&mesh_src->ldata, &tmp.ldata, mask, alloctype, totloop);
-       CustomData_copy(&mesh_src->pdata, &tmp.pdata, mask, alloctype, totpoly);
+       CustomData_copy(&mesh_src->vdata, &tmp.vdata, mask->vmask, alloctype, totvert);
+       CustomData_copy(&mesh_src->edata, &tmp.edata, mask->emask, alloctype, totedge);
+       CustomData_copy(&mesh_src->ldata, &tmp.ldata, mask->lmask, alloctype, totloop);
+       CustomData_copy(&mesh_src->pdata, &tmp.pdata, mask->pmask, alloctype, totpoly);
        tmp.cd_flag = mesh_src->cd_flag;
        tmp.runtime.deformed_only = mesh_src->runtime.deformed_only;
 
@@ -1370,10 +1371,10 @@ void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, Mesh *mesh_dst, Object *ob, CustomD
 
        if (take_ownership) {
                if (alloctype == CD_ASSIGN) {
-                       CustomData_free_typemask(&mesh_src->vdata, mesh_src->totvert, ~mask);
-                       CustomData_free_typemask(&mesh_src->edata, mesh_src->totedge, ~mask);
-                       CustomData_free_typemask(&mesh_src->ldata, mesh_src->totloop, ~mask);
-                       CustomData_free_typemask(&mesh_src->pdata, mesh_src->totpoly, ~mask);
+                       CustomData_free_typemask(&mesh_src->vdata, mesh_src->totvert, ~mask->vmask);
+                       CustomData_free_typemask(&mesh_src->edata, mesh_src->totedge, ~mask->emask);
+                       CustomData_free_typemask(&mesh_src->ldata, mesh_src->totloop, ~mask->lmask);
+                       CustomData_free_typemask(&mesh_src->pdata, mesh_src->totpoly, ~mask->pmask);
                }
                BKE_id_free(NULL, mesh_src);
        }
index 29879be3d45f8eafb4d278126751ce2bcc80befc..a5aa198bc4eb177d5345533b09cc7385499a51cf 100644 (file)
@@ -40,6 +40,7 @@
 #include "BLI_math_base.h"
 #include "BLI_math_vector.h"
 
+#include "BKE_customdata.h"
 #include "BKE_deform.h"
 #include "BKE_mesh.h"
 
@@ -888,12 +889,15 @@ bool BKE_mesh_validate_all_customdata(
        bool is_valid = true;
        bool is_change_v, is_change_e, is_change_l, is_change_p;
        int tot_uvloop, tot_vcolloop;
-       CustomDataMask mask = check_meshmask ? CD_MASK_MESH : 0;
+       CustomData_MeshMasks mask = {0};
+       if (check_meshmask) {
+               mask = CD_MASK_MESH;
+       }
 
-       is_valid &= mesh_validate_customdata(vdata, mask, totvert, do_verbose, do_fixes, &is_change_v);
-       is_valid &= mesh_validate_customdata(edata, mask, totedge, do_verbose, do_fixes, &is_change_e);
-       is_valid &= mesh_validate_customdata(ldata, mask, totloop, do_verbose, do_fixes, &is_change_l);
-       is_valid &= mesh_validate_customdata(pdata, mask, totpoly, do_verbose, do_fixes, &is_change_p);
+       is_valid &= mesh_validate_customdata(vdata, mask.vmask, totvert, do_verbose, do_fixes, &is_change_v);
+       is_valid &= mesh_validate_customdata(edata, mask.emask, totedge, do_verbose, do_fixes, &is_change_e);
+       is_valid &= mesh_validate_customdata(ldata, mask.lmask, totloop, do_verbose, do_fixes, &is_change_l);
+       is_valid &= mesh_validate_customdata(pdata, mask.pmask, totpoly, do_verbose, do_fixes, &is_change_p);
 
        tot_uvloop = CustomData_number_of_layers(ldata, CD_MLOOPUV);
        tot_vcolloop = CustomData_number_of_layers(ldata, CD_MLOOPCOL);
index ab5e2eaf491b67287d7abaa71b9da0ee528be2dc..189bd8623c4f7cbe160274a5529b3404ac633148 100644 (file)
@@ -478,8 +478,8 @@ bool modifier_isEnabled(const struct Scene *scene, ModifierData *md, int require
 }
 
 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
-                                    CustomDataMask dataMask, int required_mode,
-                                    ModifierData *previewmd, CustomDataMask previewmask)
+                                    const CustomData_MeshMasks *dataMask, int required_mode,
+                                    ModifierData *previewmd, const CustomData_MeshMasks *previewmask)
 {
        CDMaskLink *dataMasks = NULL;
        CDMaskLink *curr, *prev;
@@ -492,10 +492,10 @@ CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierDat
 
                if (modifier_isEnabled(scene, md, required_mode)) {
                        if (mti->requiredDataMask)
-                               curr->mask = mti->requiredDataMask(ob, md);
+                                mti->requiredDataMask(ob, md, &curr->mask);
 
-                       if (previewmd == md) {
-                               curr->mask |= previewmask;
+                       if (previewmd == md && previewmask != NULL) {
+                               CustomData_MeshMasks_update(&curr->mask, previewmask);
                        }
                }
 
@@ -512,15 +512,10 @@ CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierDat
         */
        for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
                if (prev) {
-                       CustomDataMask prev_mask = prev->mask;
-                       CustomDataMask curr_mask = curr->mask;
-
-                       curr->mask = curr_mask | prev_mask;
+                       CustomData_MeshMasks_update(&curr->mask, &prev->mask);
                }
                else {
-                       CustomDataMask curr_mask = curr->mask;
-
-                       curr->mask = curr_mask | dataMask;
+                       CustomData_MeshMasks_update(&curr->mask, dataMask);
                }
        }
 
@@ -877,13 +872,13 @@ struct DerivedMesh *modifier_applyModifier_DM_deprecated(
        Mesh *mesh = NULL;
        if (dm != NULL) {
                mesh = BKE_id_new_nomain(ID_ME, NULL);
-               DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
+               DM_to_mesh(dm, mesh, ctx->object, &CD_MASK_EVERYTHING, false);
        }
 
        struct Mesh *new_mesh = mti->applyModifier(md, ctx, mesh);
 
        /* Make a DM that doesn't reference new_mesh so we can free the latter. */
-       DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE, CD_MASK_EVERYTHING);
+       DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE, &CD_MASK_EVERYTHING);
 
        if (new_mesh != mesh) {
                BKE_id_free(NULL, new_mesh);
index 422ce5ae19b3d86d2e61f68b218d1bb47254b508..774fde0af7d4c3a5293f75554df5ffeef627d31c 100644 (file)
@@ -280,7 +280,7 @@ Mesh *BKE_multires_create_mesh(
         Object *ob)
 {
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
-       Mesh *deformed_mesh = mesh_get_eval_deform(depsgraph, scene, ob_eval, CD_MASK_BAREMESH);
+       Mesh *deformed_mesh = mesh_get_eval_deform(depsgraph, scene, ob_eval, &CD_MASK_BAREMESH);
        ModifierEvalContext modifier_ctx = {
                .depsgraph = depsgraph,
                .object = ob_eval,
@@ -759,7 +759,7 @@ void multiresModifier_base_apply(MultiresModifierData *mmd, Scene *scene, Object
 
        /* generate highest level with displacements */
        cddm = CDDM_from_mesh(me);
-       DM_set_only_copy(cddm, CD_MASK_BAREMESH);
+       DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
        dispdm = multires_dm_create_local(scene, ob, cddm, totlvl, totlvl, 0, 0, MULTIRES_IGNORE_SIMPLIFY);
        cddm->release(cddm);
 
@@ -855,7 +855,7 @@ void multiresModifier_base_apply(MultiresModifierData *mmd, Scene *scene, Object
 
        /* subdivide the mesh to highest level without displacements */
        cddm = CDDM_from_mesh(me);
-       DM_set_only_copy(cddm, CD_MASK_BAREMESH);
+       DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
        origdm = subsurf_dm_create_local(
                scene, ob, cddm, totlvl, 0, 0, mmd->uv_smooth == SUBSURF_UV_SMOOTH_NONE,
                0, false, SUBSURF_IGNORE_SIMPLIFY);
@@ -898,7 +898,7 @@ static void multires_subdivide(
 
                /* create subsurf DM from original mesh at high level */
                cddm = CDDM_from_mesh(me);
-               DM_set_only_copy(cddm, CD_MASK_BAREMESH);
+               DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
                highdm = subsurf_dm_create_local(
                        NULL, ob, cddm, totlvl, simple, 0, mmd->uv_smooth == SUBSURF_UV_SMOOTH_NONE,
                        has_mask, false, SUBSURF_IGNORE_SIMPLIFY);
@@ -1220,7 +1220,7 @@ void multires_modifier_update_mdisps(struct DerivedMesh *dm, Scene *scene)
                        /* create subsurf DM from original mesh at high level */
                        if (ob->derivedDeform) cddm = CDDM_copy(ob->derivedDeform);
                        else cddm = CDDM_from_mesh(me);
-                       DM_set_only_copy(cddm, CD_MASK_BAREMESH);
+                       DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
 
                        highdm = subsurf_dm_create_local(
                                scene, ob, cddm, totlvl, mmd->simple, 0, mmd->uv_smooth == SUBSURF_UV_SMOOTH_NONE,
@@ -1284,7 +1284,7 @@ void multires_modifier_update_mdisps(struct DerivedMesh *dm, Scene *scene)
 
                        if (ob->derivedDeform) cddm = CDDM_copy(ob->derivedDeform);
                        else cddm = CDDM_from_mesh(me);
-                       DM_set_only_copy(cddm, CD_MASK_BAREMESH);
+                       DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
 
                        subdm = subsurf_dm_create_local(
                                scene, ob, cddm, mmd->totlvl, mmd->simple, 0, mmd->uv_smooth == SUBSURF_UV_SMOOTH_NONE,
index a1253d65294d0d4d149db99a763f1a972ad25a49..019757cc75a79d02c5ab9f48127a75ffc6e51995 100644 (file)
@@ -861,7 +861,7 @@ static Subdiv *multires_create_subdiv_for_reshape(
        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
        Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
        Mesh *deformed_mesh = mesh_get_eval_deform(
-               depsgraph, scene_eval, object_eval, CD_MASK_BAREMESH);
+               depsgraph, scene_eval, object_eval, &CD_MASK_BAREMESH);
        SubdivSettings subdiv_settings;
        BKE_multires_subdiv_settings_init(&subdiv_settings, mmd);
        Subdiv *subdiv = BKE_subdiv_new_from_mesh(&subdiv_settings, deformed_mesh);
@@ -965,7 +965,7 @@ bool multiresModifier_reshapeFromObject(
        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
        Object *src_eval = DEG_get_evaluated_object(depsgraph, src);
        Mesh *src_mesh_eval = mesh_get_eval_final(
-               depsgraph, scene_eval, src_eval, CD_MASK_BAREMESH);
+               depsgraph, scene_eval, src_eval, &CD_MASK_BAREMESH);
        int num_deformed_verts;
        float (*deformed_verts)[3] = BKE_mesh_vertexCos_get(
                src_mesh_eval, &num_deformed_verts);
index 60cf4d1b1d47cdf72e1c52d0c1da84ba91ce449a..304c9985f1079e90f5d4d110ab8123d4f016c088 100644 (file)
@@ -168,18 +168,20 @@ void BKE_object_handle_data_update(
                        }
 #endif
 
-                       uint64_t data_mask = scene->customdata_mask | CD_MASK_BAREMESH;
+                       CustomData_MeshMasks cddata_masks = scene->customdata_mask;
+                       CustomData_MeshMasks_update(&cddata_masks, &CD_MASK_BAREMESH);
 #ifdef WITH_FREESTYLE
                        /* make sure Freestyle edge/face marks appear in DM for render (see T40315) */
                        if (DEG_get_mode(depsgraph) != DAG_EVAL_VIEWPORT) {
-                               data_mask |= CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
+                               cddata_masks.emask |= CD_MASK_FREESTYLE_EDGE;
+                               cddata_masks.pmask |= CD_MASK_FREESTYLE_FACE;
                        }
 #endif
                        if (em) {
-                               makeDerivedMesh(depsgraph, scene, ob, em,  data_mask, false); /* was CD_MASK_BAREMESH */
+                               makeDerivedMesh(depsgraph, scene, ob, em,  &cddata_masks, false); /* was CD_MASK_BAREMESH */
                        }
                        else {
-                               makeDerivedMesh(depsgraph, scene, ob, NULL, data_mask, false);
+                               makeDerivedMesh(depsgraph, scene, ob, NULL, &cddata_masks, false);
                        }
                        break;
                }
index 2977a8bed16c081c88ec9ce1d548edc6f4e68257..b3999e6121660a336206ecc58dc66d8235207da7 100644 (file)
@@ -1100,7 +1100,7 @@ void BKE_sculpt_update_mesh_elements(
 
        ss->kb = (mmd == NULL) ? BKE_keyblock_from_object(ob) : NULL;
 
-       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene, ob_eval, CD_MASK_BAREMESH);
+       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene, ob_eval, &CD_MASK_BAREMESH);
 
        /* VWPaint require mesh info for loop lookup, so require sculpt mode here */
        if (mmd && ob->mode & OB_MODE_SCULPT) {
@@ -1397,7 +1397,7 @@ PBVH *BKE_sculpt_object_pbvh_ensure(Depsgraph *depsgraph, Object *ob)
                }
                else if (ob->type == OB_MESH) {
                        Mesh *me_eval_deform = mesh_get_eval_deform(
-                               depsgraph, DEG_get_evaluated_scene(depsgraph), object_eval, CD_MASK_BAREMESH);
+                               depsgraph, DEG_get_evaluated_scene(depsgraph), object_eval, &CD_MASK_BAREMESH);
                        pbvh = build_pbvh_from_regular_mesh(ob, me_eval_deform);
                }
        }
index 3146e3f9fd2c01241ee51191662c7c8d60ea3a6e..da2975d8efce8a8075472e99098ec231c8288087 100644 (file)
@@ -1625,39 +1625,40 @@ static void psys_particle_on_shape(int UNUSED(distr), int UNUSED(index),
 /*                     Particles on emitter                            */
 /************************************************/
 
-CustomDataMask psys_emitter_customdata_mask(ParticleSystem *psys)
+void psys_emitter_customdata_mask(ParticleSystem *psys, CustomData_MeshMasks *r_cddata_masks)
 {
-       CustomDataMask dataMask = 0;
        MTex *mtex;
        int i;
 
        if (!psys->part)
-               return 0;
+               return;
 
        for (i = 0; i < MAX_MTEX; i++) {
                mtex = psys->part->mtex[i];
                if (mtex && mtex->mapto && (mtex->texco & TEXCO_UV))
-                       dataMask |= CD_MASK_MTFACE;
+                       r_cddata_masks->fmask |= CD_MASK_MTFACE;
        }
 
        if (psys->part->tanfac != 0.0f)
-               dataMask |= CD_MASK_MTFACE;
+               r_cddata_masks->fmask |= CD_MASK_MTFACE;
 
        /* ask for vertexgroups if we need them */
        for (i = 0; i < PSYS_TOT_VG; i++) {
                if (psys->vgroup[i]) {
-                       dataMask |= CD_MASK_MDEFORMVERT;
+                       r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
                        break;
                }
        }
 
        /* particles only need this if they are after a non deform modifier, and
         * the modifier stack will only create them in that case. */
-       dataMask |= CD_MASK_ORIGSPACE_MLOOP | CD_MASK_ORIGINDEX;
-
-       dataMask |= CD_MASK_ORCO;
+       r_cddata_masks->lmask |= CD_MASK_ORIGSPACE_MLOOP;
+       /* XXX Check we do need all those? */
+       r_cddata_masks->vmask |= CD_MASK_ORIGINDEX;
+       r_cddata_masks->emask |= CD_MASK_ORIGINDEX;
+       r_cddata_masks->pmask |= CD_MASK_ORIGINDEX;
 
-       return dataMask;
+       r_cddata_masks->vmask |= CD_MASK_ORCO;
 }
 
 void psys_particle_on_emitter(ParticleSystemModifierData *psmd, int from, int index, int index_dmcache,
index 6947270d88e2b6b6ac2c017e637993175a276e5f..7dc772576c5fac75ede9609e4aca00f92751f1a2 100644 (file)
  * \ingroup bli
  */
 
-#include "DNA_meshdata_types.h"
-
 #include "MEM_guardedalloc.h"
 
+#include "BLI_utildefines.h"
+
 #include "BLI_bitmap.h"
 #include "BLI_math.h"
-#include "BLI_utildefines.h"
 #include "BLI_ghash.h"
 #include "BLI_task.h"
 
+#include "DNA_meshdata_types.h"
+
 #include "BKE_pbvh.h"
 #include "BKE_ccg.h"
 #include "BKE_subsurf.h"
index 26312be9d69fd5ec8e56f447ced13bc362e31871..bb01bfd587a57966e285b1fb0694e840cfa7e764 100644 (file)
@@ -32,6 +32,7 @@
 #include "BLI_bitmap.h"
 #include "BLI_task.h"
 
+#include "BKE_customdata.h"
 #include "BKE_mesh.h"
 #include "BKE_key.h"
 #include "BKE_subdiv.h"
index 709f3fef4fc7749926228badd90f8189274ad82e..8ac120ec79d00c65a3b6c1f93fc526f1d2dcc894 100644 (file)
@@ -32,6 +32,7 @@
 #include "BLI_alloca.h"
 #include "BLI_math_vector.h"
 
+#include "BKE_customdata.h"
 #include "BKE_mesh.h"
 #include "BKE_key.h"
 #include "BKE_subdiv.h"
@@ -224,7 +225,7 @@ static void vertex_interpolation_init(
                /* Allocate storage for loops corresponding to ptex corners. */
                CustomData_copy(&ctx->coarse_mesh->vdata,
                                &vertex_interpolation->vertex_data_storage,
-                               CD_MASK_EVERYTHING,
+                               CD_MASK_EVERYTHING.vmask,
                                CD_CALLOC,
                                4);
                /* Initialize indices. */
@@ -355,7 +356,7 @@ static void loop_interpolation_init(
                /* Allocate storage for loops corresponding to ptex corners. */
                CustomData_copy(&ctx->coarse_mesh->ldata,
                                &loop_interpolation->loop_data_storage,
-                               CD_MASK_EVERYTHING,
+                               CD_MASK_EVERYTHING.lmask,
                                CD_CALLOC,
                                4);
                /* Initialize indices. */
index 82ef725ef372a52df3fd8f59ed958ff8df89b897..e34382dc7525abbe54df132ce6853fd36129802c 100644 (file)
@@ -6640,7 +6640,9 @@ static void direct_link_scene(FileData *fd, Scene *sce)
 
        sce->depsgraph_hash = NULL;
        sce->fps_info = NULL;
-       sce->customdata_mask_modal = 0;
+
+       memset(&sce->customdata_mask, 0, sizeof(sce->customdata_mask));
+       memset(&sce->customdata_mask_modal, 0, sizeof(sce->customdata_mask_modal));
 
        BKE_sound_create_scene(sce);
 
index 6694e0506957e6bbb2b9146f548393520d412247..4226b111d165c1ba925a5bf71fc05c894722fea3 100644 (file)
@@ -2101,14 +2101,15 @@ static void write_grid_paint_mask(WriteData *wd, int count, GridPaintMask *grid_
 }
 
 static void write_customdata(
-        WriteData *wd, ID *id, int count, CustomData *data, CustomDataLayer *layers,
+        WriteData *wd, ID *id,
+        int count, CustomData *data, CustomDataLayer *layers, CustomDataMask cddata_mask,
         int partial_type, int partial_count)
 {
        int i;
 
        /* write external customdata (not for undo) */
        if (data->external && (wd->use_memfile == false)) {
-               CustomData_external_write(data, id, CD_MASK_MESH, count, 0);
+               CustomData_external_write(data, id, cddata_mask, count, 0);
        }
 
        writestruct_at_address(wd, DATA, CustomDataLayer, data->totlayer, data->layers, layers);
@@ -2209,12 +2210,12 @@ static void write_mesh(WriteData *wd, Mesh *mesh)
                        writedata(wd, DATA, sizeof(void *) * mesh->totcol, mesh->mat);
                        writedata(wd, DATA, sizeof(MSelect) * mesh->totselect, mesh->mselect);
 
-                       write_customdata(wd, &mesh->id, mesh->totvert, &mesh->vdata, vlayers, -1, 0);
-                       write_customdata(wd, &mesh->id, mesh->totedge, &mesh->edata, elayers, -1, 0);
+                       write_customdata(wd, &mesh->id, mesh->totvert, &mesh->vdata, vlayers, CD_MASK_MESH.vmask, -1, 0);
+                       write_customdata(wd, &mesh->id, mesh->totedge, &mesh->edata, elayers, CD_MASK_MESH.emask, -1, 0);
                        /* fdata is really a dummy - written so slots align */
-                       write_customdata(wd, &mesh->id, mesh->totface, &mesh->fdata, flayers, -1, 0);
-                       write_customdata(wd, &mesh->id, mesh->totloop, &mesh->ldata, llayers, -1, 0);
-                       write_customdata(wd, &mesh->id, mesh->totpoly, &mesh->pdata, players, -1, 0);
+                       write_customdata(wd, &mesh->id, mesh->totface, &mesh->fdata, flayers, CD_MASK_MESH.fmask, -1, 0);
+                       write_customdata(wd, &mesh->id, mesh->totloop, &mesh->ldata, llayers, CD_MASK_MESH.lmask, -1, 0);
+                       write_customdata(wd, &mesh->id, mesh->totpoly, &mesh->pdata, players, CD_MASK_MESH.pmask, -1, 0);
 
                        /* restore pointer */
                        mesh = old_mesh;
index a0eac488c77f01c26d3462c6f18b845a8d24dd76..fba71b20e7cc43e5850f42328cecf1494b311296 100644 (file)
@@ -662,10 +662,10 @@ void BM_mesh_copy_init_customdata(BMesh *bm_dst, BMesh *bm_src, const BMAllocTem
                allocsize = &bm_mesh_allocsize_default;
        }
 
-       CustomData_copy(&bm_src->vdata, &bm_dst->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
-       CustomData_copy(&bm_src->edata, &bm_dst->edata, CD_MASK_BMESH, CD_CALLOC, 0);
-       CustomData_copy(&bm_src->ldata, &bm_dst->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
-       CustomData_copy(&bm_src->pdata, &bm_dst->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
+       CustomData_copy(&bm_src->vdata, &bm_dst->vdata, CD_MASK_BMESH.vmask, CD_CALLOC, 0);
+       CustomData_copy(&bm_src->edata, &bm_dst->edata, CD_MASK_BMESH.emask, CD_CALLOC, 0);
+       CustomData_copy(&bm_src->ldata, &bm_dst->ldata, CD_MASK_BMESH.lmask, CD_CALLOC, 0);
+       CustomData_copy(&bm_src->pdata, &bm_dst->pdata, CD_MASK_BMESH.pmask, CD_CALLOC, 0);
 
        CustomData_bmesh_init_pool(&bm_dst->vdata, allocsize->totvert, BM_VERT);
        CustomData_bmesh_init_pool(&bm_dst->edata, allocsize->totedge, BM_EDGE);
index 95bfab466193e49490daf6bcb060d5e0e72be906..eead30bcd24bfa3695d00cddb197c2b1e4749cde 100644 (file)
@@ -32,6 +32,7 @@
 
 #include "DNA_meshdata_types.h"
 
+#include "BKE_customdata.h"
 #include "BKE_mesh.h"
 
 #include "bmesh.h"
index 46a0ed2bdddaca021aae54c31727719960cad251..c5557eb91c20b023f6fb883ef59318977d050b48 100644 (file)
@@ -195,15 +195,15 @@ void BM_mesh_bm_from_me(
        BMFace *f, **ftable = NULL;
        float (*keyco)[3] = NULL;
        int totloops, i;
-       const int64_t mask = CD_MASK_BMESH | params->cd_mask_extra;
-       const int64_t mask_loop_only = mask & ~CD_MASK_ORIGINDEX;
+       CustomData_MeshMasks mask = CD_MASK_BMESH;
+       CustomData_MeshMasks_update(&mask, &params->cd_mask_extra);
 
        if (!me || !me->totvert) {
                if (me && is_new) { /*no verts? still copy customdata layout*/
-                       CustomData_copy(&me->vdata, &bm->vdata, mask, CD_ASSIGN, 0);
-                       CustomData_copy(&me->edata, &bm->edata, mask, CD_ASSIGN, 0);
-                       CustomData_copy(&me->ldata, &bm->ldata, mask_loop_only, CD_ASSIGN, 0);
-                       CustomData_copy(&me->pdata, &bm->pdata, mask, CD_ASSIGN, 0);
+                       CustomData_copy(&me->vdata, &bm->vdata, mask.vmask, CD_ASSIGN, 0);
+                       CustomData_copy(&me->edata, &bm->edata, mask.emask, CD_ASSIGN, 0);
+                       CustomData_copy(&me->ldata, &bm->ldata, mask.lmask, CD_ASSIGN, 0);
+                       CustomData_copy(&me->pdata, &bm->pdata, mask.pmask, CD_ASSIGN, 0);
 
                        CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
                        CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
@@ -214,10 +214,10 @@ void BM_mesh_bm_from_me(
        }
 
        if (is_new) {
-               CustomData_copy(&me->vdata, &bm->vdata, mask, CD_CALLOC, 0);
-               CustomData_copy(&me->edata, &bm->edata, mask, CD_CALLOC, 0);
-               CustomData_copy(&me->ldata, &bm->ldata, mask_loop_only, CD_CALLOC, 0);
-               CustomData_copy(&me->pdata, &bm->pdata, mask, CD_CALLOC, 0);
+               CustomData_copy(&me->vdata, &bm->vdata, mask.vmask, CD_CALLOC, 0);
+               CustomData_copy(&me->edata, &bm->edata, mask.emask, CD_CALLOC, 0);
+               CustomData_copy(&me->ldata, &bm->ldata, mask.lmask, CD_CALLOC, 0);
+               CustomData_copy(&me->pdata, &bm->pdata, mask.pmask, CD_CALLOC, 0);
        }
 
        /* -------------------------------------------------------------------- */
@@ -604,11 +604,12 @@ void BM_mesh_bm_to_me(
        me->act_face = -1;
 
        {
-               const CustomDataMask mask = CD_MASK_MESH | params->cd_mask_extra;
-               CustomData_copy(&bm->vdata, &me->vdata, mask, CD_CALLOC, me->totvert);
-               CustomData_copy(&bm->edata, &me->edata, mask, CD_CALLOC, me->totedge);
-               CustomData_copy(&bm->ldata, &me->ldata, mask, CD_CALLOC, me->totloop);
-               CustomData_copy(&bm->pdata, &me->pdata, mask, CD_CALLOC, me->totpoly);
+               CustomData_MeshMasks mask = CD_MASK_MESH;
+               CustomData_MeshMasks_update(&mask, &params->cd_mask_extra);
+               CustomData_copy(&bm->vdata, &me->vdata, mask.vmask, CD_CALLOC, me->totvert);
+               CustomData_copy(&bm->edata, &me->edata, mask.emask, CD_CALLOC, me->totedge);
+               CustomData_copy(&bm->ldata, &me->ldata, mask.lmask, CD_CALLOC, me->totloop);
+               CustomData_copy(&bm->pdata, &me->pdata, mask.pmask, CD_CALLOC, me->totpoly);
        }
 
        CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
@@ -950,11 +951,11 @@ void BM_mesh_bm_to_me(
  *
  * \note Was `cddm_from_bmesh_ex` in 2.7x, removed `MFace` support.
  */
-void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const int64_t cd_mask_extra)
+void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks *cd_mask_extra)
 {
        /* must be an empty mesh. */
        BLI_assert(me->totvert == 0);
-       BLI_assert((cd_mask_extra & CD_MASK_SHAPEKEY) == 0);
+       BLI_assert(cd_mask_extra == NULL || (cd_mask_extra->vmask & CD_MASK_SHAPEKEY) == 0);
 
        me->totvert = bm->totvert;
        me->totedge = bm->totedge;
@@ -973,11 +974,15 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const int64_t cd_mask_extra)
 
        /* don't process shapekeys, we only feed them through the modifier stack as needed,
         * e.g. for applying modifiers or the like*/
-       const CustomDataMask mask = (CD_MASK_DERIVEDMESH | cd_mask_extra) & ~CD_MASK_SHAPEKEY;
-       CustomData_merge(&bm->vdata, &me->vdata, mask, CD_CALLOC, me->totvert);
-       CustomData_merge(&bm->edata, &me->edata, mask, CD_CALLOC, me->totedge);
-       CustomData_merge(&bm->ldata, &me->ldata, mask, CD_CALLOC, me->totloop);
-       CustomData_merge(&bm->pdata, &me->pdata, mask, CD_CALLOC, me->totpoly);
+       CustomData_MeshMasks mask = CD_MASK_DERIVEDMESH;
+       if (cd_mask_extra != NULL) {
+               CustomData_MeshMasks_update(&mask, cd_mask_extra);
+       }
+       mask.vmask &= ~CD_MASK_SHAPEKEY;
+       CustomData_merge(&bm->vdata, &me->vdata, mask.vmask, CD_CALLOC, me->totvert);
+       CustomData_merge(&bm->edata, &me->edata, mask.emask, CD_CALLOC, me->totedge);
+       CustomData_merge(&bm->ldata, &me->ldata, mask.lmask, CD_CALLOC, me->totloop);
+       CustomData_merge(&bm->pdata, &me->pdata, mask.pmask, CD_CALLOC, me->totpoly);
 
        BKE_mesh_update_customdata_pointers(me, false);
 
index 52d3b0b88083bb4f59f9f7a69a7f217adf06feb9..30a1e8bffd5ccdc813024cd33a8d935a753509ba 100644 (file)
@@ -24,6 +24,7 @@
  * \ingroup bmesh
  */
 
+struct CustomData_MeshMasks;
 struct Main;
 struct Mesh;
 
@@ -39,7 +40,7 @@ struct BMeshFromMeshParams {
        uint use_shapekey : 1;
        /* define the active shape key (index + 1) */
        int active_shapekey;
-       int64_t cd_mask_extra;
+       struct CustomData_MeshMasks cd_mask_extra;
 };
 void BM_mesh_bm_from_me(
         BMesh *bm, const struct Mesh *me,
@@ -49,7 +50,7 @@ ATTR_NONNULL(1, 3);
 struct BMeshToMeshParams {
        /** Update object hook indices & vertex parents. */
        uint calc_object_remap : 1;
-       int64_t cd_mask_extra;
+       struct CustomData_MeshMasks cd_mask_extra;
 };
 void BM_mesh_bm_to_me(
         struct Main *bmain, BMesh *bm, struct Mesh *me,
@@ -57,7 +58,7 @@ void BM_mesh_bm_to_me(
 ATTR_NONNULL(2, 3, 4);
 
 void BM_mesh_bm_to_me_for_eval(
-        BMesh *bm, struct Mesh *me, const int64_t cd_mask_extra)
+        BMesh *bm, struct Mesh *me, const struct CustomData_MeshMasks *cd_mask_extra)
 ATTR_NONNULL(1, 2);
 
 
index 65ce7ba5677c5d95267b0e8c3d4e0c3a47fd1a2a..306120e464f92f1acc3de40da70e31263e999733 100644 (file)
@@ -556,7 +556,7 @@ void MeshImporter::mesh_add_edges(Mesh *mesh, int len)
        totedge = mesh->totedge + len;
 
        /* update customdata  */
-       CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
+       CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH.emask, CD_DEFAULT, totedge);
        CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
 
        if (!CustomData_has_layer(&edata, CD_MEDGE))
index 406d4dabc88cdf6f393a2f9d3a89ae9e5063fd4a..37a4608fe297799f3a427d04573bc0929c6d20b9 100644 (file)
@@ -256,19 +256,19 @@ Mesh *bc_get_mesh_copy(
        bool apply_modifiers,
        bool triangulate)
 {
-       CustomDataMask mask = CD_MASK_MESH;
+       CustomData_MeshMasks mask = CD_MASK_MESH;
        Mesh *tmpmesh = NULL;
        if (apply_modifiers) {
 #if 0  /* Not supported by new system currently... */
                switch (export_mesh_type) {
                        case BC_MESH_TYPE_VIEW:
                        {
-                               dm = mesh_create_derived_view(depsgraph, scene, ob, mask);
+                               dm = mesh_create_derived_view(depsgraph, scene, ob, &mask);
                                break;
                        }
                        case BC_MESH_TYPE_RENDER:
                        {
-                               dm = mesh_create_derived_render(depsgraph, scene, ob, mask);
+                               dm = mesh_create_derived_render(depsgraph, scene, ob, &mask);
                                break;
                        }
                }
@@ -276,7 +276,7 @@ Mesh *bc_get_mesh_copy(
                Depsgraph *depsgraph = blender_context.get_depsgraph();
                Scene *scene_eval = blender_context.get_evaluated_scene();
                Object *ob_eval = blender_context.get_evaluated_object(ob);
-               tmpmesh = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, mask);
+               tmpmesh = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &mask);
 #endif
        }
        else {
index 3a44c46dcc51a061663b29d8f0ba56bb42ad8c92..62315391e95c2c0c451ff634248e95e118d23e2b 100644 (file)
@@ -35,6 +35,7 @@ struct Depsgraph;
 
 struct CacheFile;
 struct Collection;
+struct CustomData_MeshMasks;
 struct EffectorWeights;
 struct ID;
 struct Main;
@@ -161,7 +162,7 @@ void DEG_add_object_pointcache_relation(struct DepsNodeHandle *node_handle,
                                         const char *description);
 
 void DEG_add_special_eval_flag(struct DepsNodeHandle *handle, struct ID *id, uint32_t flag);
-void DEG_add_customdata_mask(struct DepsNodeHandle *handle, struct Object *object, uint64_t mask);
+void DEG_add_customdata_mask(struct DepsNodeHandle *handle, struct Object *object, const struct CustomData_MeshMasks *masks);
 
 struct ID *DEG_get_id_from_handle(struct DepsNodeHandle *node_handle);
 struct Depsgraph *DEG_get_graph_from_handle(struct DepsNodeHandle *node_handle);
index 1e544941e6468a680cc4d1340b345722d064668d..11732c55a9939ac1347909ead49cc1c0ab933ac3 100644 (file)
@@ -33,6 +33,7 @@ struct ID;
 
 struct BLI_Iterator;
 struct Base;
+struct CustomData_MeshMasks;
 struct Depsgraph;
 struct DupliObject;
 struct ListBase;
@@ -66,9 +67,10 @@ bool DEG_id_type_any_updated(const struct Depsgraph *depsgraph);
 /* Get additional evaluation flags for the given ID. */
 uint32_t DEG_get_eval_flags_for_id(const struct Depsgraph *graph, struct ID *id);
 
-/* Get additional mesh CustomDataMask flags for the given object. */
-uint64_t DEG_get_customdata_mask_for_object(const struct Depsgraph *graph,
-                                            struct Object *object);
+/* Get additional mesh CustomData_MeshMasks flags for the given object. */
+void DEG_get_customdata_mask_for_object(const struct Depsgraph *graph,
+                                        struct Object *object,
+                                        struct CustomData_MeshMasks *r_mask);
 
 /* Get scene the despgraph is created for. */
 struct Scene *DEG_get_evaluated_scene(const struct Depsgraph *graph);
index ca454610f1e7aeccd9c244c56f7af8f04c94312c..b6e516ee9b4cccb8fbdbb17fc65b4fe3d376f7a6 100644 (file)
@@ -203,7 +203,7 @@ void deg_graph_build_finalize(Main *bmain, Depsgraph *graph)
                        flag |= ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY;
                }
                /* Tag rebuild if the custom data mask changed. */
-               if (id_node->customdata_mask != id_node->previous_customdata_mask) {
+               if (id_node->customdata_masks != id_node->previous_customdata_masks) {
                        flag |= ID_RECALC_GEOMETRY;
                }
                if (!deg_copy_on_write_is_expanded(id_node->id_cow)) {
index 463f4fa09353bfc45b02e5f31436d78a687aec9c..dbf6b1d145164b572d84001575f406e927b8c58d 100644 (file)
@@ -154,14 +154,14 @@ IDNode *DepsgraphNodeBuilder::add_id_node(ID *id)
        ID *id_cow = NULL;
        IDComponentsMask previously_visible_components_mask = 0;
        uint32_t previous_eval_flags = 0;
-       uint64_t previous_customdata_mask = 0;
+       DEGCustomDataMeshMasks previous_customdata_masks;
        IDInfo *id_info = (IDInfo *)BLI_ghash_lookup(id_info_hash_, id);
        if (id_info != NULL) {
                id_cow = id_info->id_cow;
                previously_visible_components_mask =
                        id_info->previously_visible_components_mask;
                previous_eval_flags = id_info->previous_eval_flags;
-               previous_customdata_mask = id_info->previous_customdata_mask;
+               previous_customdata_masks = id_info->previous_customdata_masks;
                /* Tag ID info to not free the CoW ID pointer. */
                id_info->id_cow = NULL;
        }
@@ -169,7 +169,7 @@ IDNode *DepsgraphNodeBuilder::add_id_node(ID *id)
        id_node->previously_visible_components_mask =
                previously_visible_components_mask;
        id_node->previous_eval_flags = previous_eval_flags;
-       id_node->previous_customdata_mask = previous_customdata_mask;
+       id_node->previous_customdata_masks = previous_customdata_masks;
        /* Currently all ID nodes are supposed to have copy-on-write logic.
         *
         * NOTE: Zero number of components indicates that ID node was just created. */
@@ -339,7 +339,7 @@ void DepsgraphNodeBuilder::begin_build()
                id_info->previously_visible_components_mask =
                        id_node->visible_components_mask;
                id_info->previous_eval_flags = id_node->eval_flags;
-               id_info->previous_customdata_mask = id_node->customdata_mask;
+               id_info->previous_customdata_masks = id_node->customdata_masks;
                BLI_ghash_insert(id_info_hash_, id_node->id_orig, id_info);
                id_node->id_cow = NULL;
        }
index 0bf4c13d515f7526b34fb5afc99ca0eafa1c5055..d5d1ac2d33a96a16004d97ccbc159c436cc4bed9 100644 (file)
@@ -230,7 +230,7 @@ public:
                /* Special evaluation flag mask from the previous depsgraph. */
                uint32_t previous_eval_flags;
                /* Mesh CustomData mask from the previous depsgraph. */
-               uint64_t previous_customdata_mask;
+               DEGCustomDataMeshMasks previous_customdata_masks;
        };
 
 protected:
index 9aab90f88cf06a2c3eef805a56385a8384e28805..161d0a9cd9fbefc7ab1abc744a8bd5f64a64819e 100644 (file)
@@ -309,16 +309,18 @@ void DepsgraphRelationBuilder::add_modifier_to_transform_relation(
                transform_operation_node, geometry_operation_node, description);
 }
 
-void DepsgraphRelationBuilder::add_customdata_mask(Object *object, uint64_t mask)
+void DepsgraphRelationBuilder::add_customdata_mask(
+        Object *object,
+        const DEGCustomDataMeshMasks &customdata_masks)
 {
-       if (mask != 0 && object != NULL && object->type == OB_MESH) {
+       if (customdata_masks != DEGCustomDataMeshMasks() && object != NULL && object->type == OB_MESH) {
                DEG::IDNode *id_node = graph_->find_id_node(&object->id);
 
                if (id_node == NULL) {
                        BLI_assert(!"ID should always be valid");
                }
                else {
-                       id_node->customdata_mask |= mask;
+                       id_node->customdata_masks |= customdata_masks;
                }
        }
 }
@@ -864,7 +866,11 @@ void DepsgraphRelationBuilder::build_object_parent(Object *object)
                         * TODO(sergey): This optimization got lost at 2.8, so either verify
                         * we can get rid of this mask here, or bring the optimization
                         * back. */
-                       add_customdata_mask(object->parent, CD_MASK_ORIGINDEX);
+                       add_customdata_mask(object->parent,
+                                           DEGCustomDataMeshMasks::MaskVert(CD_MASK_ORIGINDEX) |
+                                           DEGCustomDataMeshMasks::MaskEdge(CD_MASK_ORIGINDEX) |
+                                           DEGCustomDataMeshMasks::MaskFace(CD_MASK_ORIGINDEX) |
+                                           DEGCustomDataMeshMasks::MaskPoly(CD_MASK_ORIGINDEX));
                        ComponentKey transform_key(parent_id, NodeType::TRANSFORM);
                        add_relation(transform_key, ob_key, "Vertex Parent TFM");
                        break;
@@ -1118,7 +1124,7 @@ void DepsgraphRelationBuilder::build_constraints(ID *id,
                                                target_transform_key, constraint_op_key, cti->name);
                                        add_relation(
                                                target_geometry_key, constraint_op_key, cti->name);
-                                       add_customdata_mask(ct->tar, CD_MASK_MDEFORMVERT);
+                                       add_customdata_mask(ct->tar, DEGCustomDataMeshMasks::MaskVert(CD_MASK_MDEFORMVERT));
                                }
                                else if (con->type == CONSTRAINT_TYPE_SHRINKWRAP) {
                                        bShrinkwrapConstraint *scon = (bShrinkwrapConstraint *) con->data;
@@ -1131,7 +1137,9 @@ void DepsgraphRelationBuilder::build_constraints(ID *id,
                                        if (ct->tar->type == OB_MESH && scon->shrinkType != MOD_SHRINKWRAP_NEAREST_VERTEX) {
                                                bool track = (scon->flag & CON_SHRINKWRAP_TRACK_NORMAL) != 0;
                                                if (track || BKE_shrinkwrap_needs_normals(scon->shrinkType, scon->shrinkMode)) {
-                                                       add_customdata_mask(ct->tar, CD_MASK_NORMAL | CD_MASK_CUSTOMLOOPNORMAL);
+                                                       add_customdata_mask(ct->tar,
+                                                                           DEGCustomDataMeshMasks::MaskVert(CD_MASK_NORMAL) |
+                                                                           DEGCustomDataMeshMasks::MaskLoop(CD_MASK_CUSTOMLOOPNORMAL));
                                                }
                                                if (scon->shrinkType == MOD_SHRINKWRAP_TARGET_PROJECT) {
                                                        add_special_eval_flag(&ct->tar->id, DAG_EVAL_NEED_SHRINKWRAP_BOUNDARY);
index fb76b469572fad474ae5f0619e648cb4f95c33a4..250593eeda06e98f2b8ca093d506d5dbef418bbd 100644 (file)
@@ -204,7 +204,8 @@ public:
        void add_modifier_to_transform_relation(const DepsNodeHandle *handle,
                                                const char *description);
 
-       void add_customdata_mask(Object *object, uint64_t mask);
+       void add_customdata_mask(Object *object,
+                                const DEGCustomDataMeshMasks &customdata_masks);
        void add_special_eval_flag(ID *object, uint32_t flag);
 
        void build_id(ID *id);
index 8742dc43651254b0867d7a846068bf85634f3f8c..fe88b532dca933c90c471482482fe983f3c953f0 100644 (file)
@@ -130,7 +130,7 @@ void DepsgraphRelationBuilder::build_ik_pose(Object *object,
                         * separately. */
                        ComponentKey target_key(&data->tar->id, NodeType::GEOMETRY);
                        add_relation(target_key, solver_key, con->name);
-                       add_customdata_mask(data->tar, CD_MASK_MDEFORMVERT);
+                       add_customdata_mask(data->tar, DEGCustomDataMeshMasks::MaskVert(CD_MASK_MDEFORMVERT));
                }
                else {
                        /* Standard Object Target. */
@@ -160,7 +160,7 @@ void DepsgraphRelationBuilder::build_ik_pose(Object *object,
                         * separately. */
                        ComponentKey target_key(&data->poletar->id, NodeType::GEOMETRY);
                        add_relation(target_key, solver_key, con->name);
-                       add_customdata_mask(data->poletar, CD_MASK_MDEFORMVERT);
+                       add_customdata_mask(data->poletar, DEGCustomDataMeshMasks::MaskVert(CD_MASK_MDEFORMVERT));
                }
                else {
                        ComponentKey target_key(&data->poletar->id, NodeType::TRANSFORM);
index 8480f152709e2d3149f2623a7faee8543eb62d38..ffd0f9da31a9342973e01b09f9a63a564854348c 100644 (file)
@@ -211,10 +211,12 @@ void DEG_add_special_eval_flag(struct DepsNodeHandle *node_handle,
 
 void DEG_add_customdata_mask(struct DepsNodeHandle *node_handle,
                              struct Object *object,
-                             uint64_t mask)
+                             const CustomData_MeshMasks *masks)
 {
        DEG::DepsNodeHandle *deg_node_handle = get_node_handle(node_handle);
-       deg_node_handle->builder->add_customdata_mask(object, mask);
+       deg_node_handle->builder->add_customdata_mask(
+                   object,
+                   DEG::DEGCustomDataMeshMasks(masks));
 }
 
 struct ID *DEG_get_id_from_handle(struct DepsNodeHandle *node_handle)
index a366b9b65687e430080d9f301aabd54950f7b18a..3b7f19e9916f53f51afca0fffe18ffab8a3d10c6 100644 (file)
@@ -29,6 +29,7 @@ extern "C" {
 #include <string.h> // XXX: memcpy
 
 #include "BLI_utildefines.h"
+#include "BKE_customdata.h"
 #include "BKE_idcode.h"
 #include "BKE_main.h"
 #include "BLI_listbase.h"
@@ -114,7 +115,7 @@ uint32_t DEG_get_eval_flags_for_id(const Depsgraph *graph, ID *id)
        return id_node->eval_flags;
 }
 
-uint64_t DEG_get_customdata_mask_for_object(const Depsgraph *graph, Object *ob)
+void DEG_get_customdata_mask_for_object(const Depsgraph *graph, Object *ob, CustomData_MeshMasks *r_mask)
 {
        if (graph == NULL) {
                /* Happens when converting objects to mesh from a python script
@@ -122,17 +123,21 @@ uint64_t DEG_get_customdata_mask_for_object(const Depsgraph *graph, Object *ob)
                 *
                 * Currently harmless because it's only called for temporary
                 * objects which are out of the DAG anyway. */
-               return 0;
+               return;
        }
 
        const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
        const DEG::IDNode *id_node = deg_graph->find_id_node(DEG_get_original_id(&ob->id));
        if (id_node == NULL) {
                /* TODO(sergey): Does it mean we need to check set scene? */
-               return 0;
+               return;
        }
 
-       return id_node->customdata_mask;
+       r_mask->vmask |= id_node->customdata_masks.vert_mask;
+       r_mask->emask |= id_node->customdata_masks.edge_mask;
+       r_mask->fmask |= id_node->customdata_masks.face_mask;
+       r_mask->lmask |= id_node->customdata_masks.loop_mask;
+       r_mask->pmask |= id_node->customdata_masks.poly_mask;
 }
 
 Scene *DEG_get_evaluated_scene(const Depsgraph *graph)
index 28d93cb91941fd41ee628245608c2b37b1317086..5be2cae10d74acb5b5f8220bf08c7723d1a76ac2 100644 (file)
 #include "BLI_utildefines.h"
 #include "BLI_ghash.h"
 
+#include "DNA_customdata_types.h"
+
 #include "DEG_depsgraph.h"
 
+#include "intern/depsgraph_type.h"
 #include "intern/node/deg_node.h"
 #include "intern/node/deg_node_component.h"
 #include "intern/node/deg_node_factory.h"
@@ -49,3 +52,12 @@ void DEG_register_node_types(void)
 void DEG_free_node_types(void)
 {
 }
+
+DEG::DEGCustomDataMeshMasks::DEGCustomDataMeshMasks(const CustomData_MeshMasks *other) :
+    vert_mask(other->vmask),
+    edge_mask(other->emask),
+    face_mask(other->fmask),
+    loop_mask(other->lmask),
+    poly_mask(other->pmask)
+{
+}
index 5233b6d018d0015671c6adce0a6103855112e9f1..d34b6d724cbe4b50133e0654712bb82d86cae88e 100644 (file)
@@ -39,6 +39,8 @@
 
 struct Depsgraph;
 
+struct CustomData_MeshMasks;
+
 namespace DEG {
 
 /* Commonly used types. */
@@ -70,4 +72,94 @@ enum eUpdateSource {
        DEG_UPDATE_SOURCE_VISIBILITY = (1 << 3),
 };
 
+/* C++ wrapper around DNA's CustomData_MeshMasks struct. */
+struct DEGCustomDataMeshMasks {
+       uint64_t vert_mask;
+       uint64_t edge_mask;
+       uint64_t face_mask;
+       uint64_t loop_mask;
+       uint64_t poly_mask;
+
+       DEGCustomDataMeshMasks()
+               : vert_mask(0),
+                 edge_mask(0),
+                 face_mask(0),
+                 loop_mask(0),
+                 poly_mask(0)
+       {
+       }
+
+       explicit DEGCustomDataMeshMasks(const CustomData_MeshMasks *other);
+
+       DEGCustomDataMeshMasks& operator|=(const DEGCustomDataMeshMasks& other)
+       {
+               this->vert_mask |= other.vert_mask;
+               this->edge_mask |= other.edge_mask;
+               this->face_mask |= other.face_mask;
+               this->loop_mask |= other.loop_mask;
+               this->poly_mask |= other.poly_mask;
+               return *this;
+       }
+
+       DEGCustomDataMeshMasks operator|(const DEGCustomDataMeshMasks& other) const
+       {
+               DEGCustomDataMeshMasks result;
+               result.vert_mask = this->vert_mask | other.vert_mask;
+               result.edge_mask = this->edge_mask | other.edge_mask;
+               result.face_mask = this->face_mask | other.face_mask;
+               result.loop_mask = this->loop_mask | other.loop_mask;
+               result.poly_mask = this->poly_mask | other.poly_mask;
+               return result;
+       }
+
+       bool operator==(const DEGCustomDataMeshMasks& other) const
+       {
+               return (this->vert_mask == other.vert_mask &&
+                       this->edge_mask == other.edge_mask &&
+                       this->face_mask == other.face_mask &&
+                       this->loop_mask == other.loop_mask &&
+                       this->poly_mask == other.poly_mask);
+       }
+
+       bool operator!=(const DEGCustomDataMeshMasks& other) const
+       {
+               return !(*this == other);
+       }
+
+       static DEGCustomDataMeshMasks MaskVert(const uint64_t vert_mask)
+       {
+               DEGCustomDataMeshMasks result;
+               result.vert_mask = vert_mask;
+               return result;
+       }
+
+       static DEGCustomDataMeshMasks MaskEdge(const uint64_t edge_mask)
+       {
+               DEGCustomDataMeshMasks result;
+               result.edge_mask = edge_mask;
+               return result;
+       }
+
+       static DEGCustomDataMeshMasks MaskFace(const uint64_t face_mask)
+       {
+               DEGCustomDataMeshMasks result;
+               result.face_mask = face_mask;
+               return result;
+       }
+
+       static DEGCustomDataMeshMasks MaskLoop(const uint64_t loop_mask)
+       {
+               DEGCustomDataMeshMasks result;
+               result.loop_mask = loop_mask;
+               return result;
+       }
+
+       static DEGCustomDataMeshMasks MaskPoly(const uint64_t poly_mask)
+       {
+               DEGCustomDataMeshMasks result;
+               result.poly_mask = poly_mask;
+               return result;
+       }
+};
+
 }  // namespace DEG
index f992ce33279674e24f2f5f8c0f49bb24182ce82d..d391f727d356df2457f7ac0e3f5e3e0ff657ef61 100644 (file)
@@ -109,8 +109,8 @@ void IDNode::init(const ID *id, const char *UNUSED(subdata))
        id_orig = (ID *)id;
        eval_flags = 0;
        previous_eval_flags = 0;
-       customdata_mask = 0;
-       previous_customdata_mask = 0;
+       customdata_masks = DEGCustomDataMeshMasks();
+       previous_customdata_masks = DEGCustomDataMeshMasks();
        linked_state = DEG_ID_LINKED_INDIRECTLY;
        is_directly_visible = true;
        is_collection_fully_expanded = false;
index 9c3ce7580ad33e65f4926f5bcbd0ae4ca97ebe9b..bbf671790c738b03c25300c0862d3ca951d19f1d 100644 (file)
@@ -84,8 +84,8 @@ struct IDNode : public Node {
        uint32_t previous_eval_flags;
 
        /* Extra customdata mask which needs to be evaluated for the mesh object. */
-       uint64_t customdata_mask;
-       uint64_t previous_customdata_mask;
+       DEGCustomDataMeshMasks customdata_masks;
+       DEGCustomDataMeshMasks previous_customdata_masks;
 
        eDepsNode_LinkedState_Type linked_state;
 
index ee0043f6ccf4087bc9f4845a952d0a6010742481..5608479905a569d2d96c82d0a7d4a98361dfa7c6 100644 (file)
@@ -370,7 +370,7 @@ static void add_verts_to_dgroups(
                /* if in weight paint mode, use final verts from evaluated mesh */
                Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
                Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
-               Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+               Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
 
                BKE_mesh_foreach_mapped_vert_coords_get(me_eval, verts, mesh->totvert);
                vertsfilled = 1;
index 2457d78f1d498f5d99faa61b902f9b29a3c6ef6c..131069bfb5fa59787997dc6ccdb5495ac9f4ab8d 100644 (file)
@@ -35,6 +35,7 @@ struct Base;
 struct BezTriple;
 struct BoundBox;
 struct Camera;
+struct CustomData_MeshMasks;
 struct Depsgraph;
 struct EditBone;
 struct GPUFX;
@@ -486,8 +487,12 @@ char ED_view3d_lock_view_from_index(int index);
 char ED_view3d_axis_view_opposite(char view);
 bool ED_view3d_lock(struct RegionView3D *rv3d);
 
-uint64_t ED_view3d_datamask(const struct bContext *C, const struct Scene *scene, const struct View3D *v3d);
-uint64_t ED_view3d_screen_datamask(const struct bContext *C, const struct Scene *scene, const struct bScreen *screen);
+void ED_view3d_datamask(
+        const struct bContext *C, const struct Scene *scene, const struct View3D *v3d,
+        struct CustomData_MeshMasks *r_cddata_masks);
+void ED_view3d_screen_datamask(
+        const struct bContext *C, const struct Scene *scene, const struct bScreen *screen,
+        struct CustomData_MeshMasks *r_cddata_masks);
 
 bool ED_view3d_offset_lock_check(const struct View3D *v3d, const struct RegionView3D *rv3d);
 void ED_view3d_persp_switch_from_camera(
index d42b4c97d332a680126fbe89223a8c90f8b1ca44..aca8fac8bf7c169fc5d4687ce4a21780a34309cc 100644 (file)
  * \ingroup edmesh
  */
 
+#include "BLI_math.h"
+#include "BLI_sys_types.h"
+
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 
-#include "BLI_math.h"
-
 #include "BLT_translation.h"
 
 #include "BKE_context.h"
index 45ce8e8b76a32992c1488e5223247e61653f9166..13fcb99f59b1be2773db3e8008551c0906ecf03c 100644 (file)
@@ -65,7 +65,7 @@ static LinkNode *knifeproject_poly_from_object(const bContext *C, Scene *scene,
                me_eval = ob_eval->runtime.mesh_eval;
                if (me_eval == NULL) {
                        Scene *scene_eval = (Scene *)DEG_get_evaluated_id(depsgraph, &scene->id);
-                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
                }
                me_eval_needs_free = false;
        }
index 83366987c7a62cb7b7ef37809dec197284f09320..273003c3ccd4c5fd4e6b033be26ad664f040da95 100644 (file)
@@ -3708,10 +3708,10 @@ static Base *mesh_separate_tagged(Main *bmain, Scene *scene, ViewLayer *view_lay
                &((struct BMeshCreateParams){.use_toolflags = true,}));
        BM_mesh_elem_toolflags_ensure(bm_new);  /* needed for 'duplicate' bmo */
 
-       CustomData_copy(&bm_old->vdata, &bm_new->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
-       CustomData_copy(&bm_old->edata, &bm_new->edata, CD_MASK_BMESH, CD_CALLOC, 0);
-       CustomData_copy(&bm_old->ldata, &bm_new->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
-       CustomData_copy(&bm_old->pdata, &bm_new->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
+       CustomData_copy(&bm_old->vdata, &bm_new->vdata, CD_MASK_BMESH.vmask, CD_CALLOC, 0);
+       CustomData_copy(&bm_old->edata, &bm_new->edata, CD_MASK_BMESH.emask, CD_CALLOC, 0);
+       CustomData_copy(&bm_old->ldata, &bm_new->ldata, CD_MASK_BMESH.lmask, CD_CALLOC, 0);
+       CustomData_copy(&bm_old->pdata, &bm_new->pdata, CD_MASK_BMESH.pmask, CD_CALLOC, 0);
 
        CustomData_bmesh_init_pool(&bm_new->vdata, bm_mesh_allocsize_default.totvert, BM_VERT);
        CustomData_bmesh_init_pool(&bm_new->edata, bm_mesh_allocsize_default.totedge, BM_EDGE);
index 16aeba781180b010c8340b096fe12a88466d2c00..e22addd614e8b8526efff81208f833a12eb34e98 100644 (file)
@@ -509,7 +509,7 @@ static void *undomesh_from_editmesh(UndoMesh *um, BMEditMesh *em, Key *key)
                NULL, em->bm, &um->me, (&(struct BMeshToMeshParams){
                    /* Undo code should not be manipulating 'G_MAIN->object' hooks/vertex-parent. */
                    .calc_object_remap = false,
-                   .cd_mask_extra = CD_MASK_SHAPE_KEYINDEX,
+                   .cd_mask_extra = {.vmask=CD_MASK_SHAPE_KEYINDEX},
                }));
 
        um->selectmode = em->selectmode;
index ea64adbffa3c864fcaf1f8cd93efe4d7f84c798e..3d880fc0bfe41dc69c0667ffb731b70b7fce91f9 100644 (file)
@@ -911,7 +911,7 @@ static void mesh_add_verts(Mesh *mesh, int len)
                return;
 
        totvert = mesh->totvert + len;
-       CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
+       CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH.vmask, CD_DEFAULT, totvert);
        CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);
 
        if (!CustomData_has_layer(&vdata, CD_MVERT))
@@ -944,7 +944,7 @@ static void mesh_add_edges(Mesh *mesh, int len)
        totedge = mesh->totedge + len;
 
        /* update customdata  */
-       CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
+       CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH.emask, CD_DEFAULT, totedge);
        CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
 
        if (!CustomData_has_layer(&edata, CD_MEDGE))
@@ -974,7 +974,7 @@ static void mesh_add_tessfaces(Mesh *mesh, int len)
        totface = mesh->totface + len;   /* new face count */
 
        /* update customdata */
-       CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
+       CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH.fmask, CD_DEFAULT, totface);
        CustomData_copy_data(&mesh->fdata, &fdata, 0, 0, mesh->totface);
 
        if (!CustomData_has_layer(&fdata, CD_MFACE))
@@ -1003,7 +1003,7 @@ static void mesh_add_loops(Mesh *mesh, int len)
        totloop = mesh->totloop + len;   /* new face count */
 
        /* update customdata */
-       CustomData_copy(&mesh->ldata, &ldata, CD_MASK_MESH, CD_DEFAULT, totloop);
+       CustomData_copy(&mesh->ldata, &ldata, CD_MASK_MESH.lmask, CD_DEFAULT, totloop);
        CustomData_copy_data(&mesh->ldata, &ldata, 0, 0, mesh->totloop);
 
        if (!CustomData_has_layer(&ldata, CD_MLOOP))
@@ -1028,7 +1028,7 @@ static void mesh_add_polys(Mesh *mesh, int len)
        totpoly = mesh->totpoly + len;   /* new face count */
 
        /* update customdata */
-       CustomData_copy(&mesh->pdata, &pdata, CD_MASK_MESH, CD_DEFAULT, totpoly);
+       CustomData_copy(&mesh->pdata, &pdata, CD_MASK_MESH.pmask, CD_DEFAULT, totpoly);
        CustomData_copy_data(&mesh->pdata, &pdata, 0, 0, mesh->totpoly);
 
        if (!CustomData_has_layer(&pdata, CD_MPOLY))
index b316e054250d6462d6a74d108cf891c86e24445b..2b8535f868bad8ca81890d518eb583be5d7b324d 100644 (file)
@@ -97,7 +97,7 @@ static void join_mesh_single(
                ((Mesh *)ob_dst->data)->cd_flag |= me->cd_flag;
 
                /* standard data */
-               CustomData_merge(&me->vdata, vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
+               CustomData_merge(&me->vdata, vdata, CD_MASK_MESH.vmask, CD_DEFAULT, totvert);
                CustomData_copy_data_named(&me->vdata, vdata, 0, *vertofs, me->totvert);
 
                /* vertex groups */
@@ -191,7 +191,7 @@ static void join_mesh_single(
        }
 
        if (me->totedge) {
-               CustomData_merge(&me->edata, edata, CD_MASK_MESH, CD_DEFAULT, totedge);
+               CustomData_merge(&me->edata, edata, CD_MASK_MESH.emask, CD_DEFAULT, totedge);
                CustomData_copy_data_named(&me->edata, edata, 0, *edgeofs, me->totedge);
 
                for (a = 0; a < me->totedge; a++, medge++) {
@@ -213,7 +213,7 @@ static void join_mesh_single(
                        }
                }
 
-               CustomData_merge(&me->ldata, ldata, CD_MASK_MESH, CD_DEFAULT, totloop);
+               CustomData_merge(&me->ldata, ldata, CD_MASK_MESH.lmask, CD_DEFAULT, totloop);
                CustomData_copy_data_named(&me->ldata, ldata, 0, *loopofs, me->totloop);
 
                for (a = 0; a < me->totloop; a++, mloop++) {
@@ -237,7 +237,7 @@ static void join_mesh_single(
                        }
                }
 
-               CustomData_merge(&me->pdata, pdata, CD_MASK_MESH, CD_DEFAULT, totpoly);
+               CustomData_merge(&me->pdata, pdata, CD_MASK_MESH.pmask, CD_DEFAULT, totpoly);
                CustomData_copy_data_named(&me->pdata, pdata, 0, *polyofs, me->totpoly);
 
                for (a = 0; a < me->totpoly; a++, mpoly++) {
@@ -665,7 +665,7 @@ int join_mesh_shapes_exec(bContext *C, wmOperator *op)
                                Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
                                Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob_iter);
 
-                               me_deformed = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+                               me_deformed = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
 
                                if (!me_deformed) {
                                        continue;
@@ -1087,7 +1087,7 @@ bool ED_mesh_pick_face_vert(bContext *C, Object *ob, const int mval[2], unsigned
                struct ARegion *ar = CTX_wm_region(C);
 
                /* derived mesh to find deformed locations */
-               Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
+               Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH_ORIGINDEX);
 
                int v_idx_best = ORIGINDEX_NONE;
 
@@ -1216,7 +1216,7 @@ bool ED_mesh_pick_vert(bContext *C, Object *ob, const int mval[2], unsigned int
                Object *ob_eval = DEG_get_evaluated_object(vc.depsgraph, ob);
 
                /* derived mesh to find deformed locations */
-               Mesh *me_eval = mesh_get_eval_final(vc.depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+               Mesh *me_eval = mesh_get_eval_final(vc.depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
                ARegion *ar = vc.ar;
                RegionView3D *rv3d = ar->regiondata;
 
index 0e6505ab712ff4bbd92364ff03fab51e77127219..d131534b5ca5c45b87a8425ba442fc51df363f7e 100644 (file)
@@ -1886,8 +1886,8 @@ static int convert_exec(bContext *C, wmOperator *op)
                        DEG_id_tag_update(&base->object->id, ID_RECALC_GEOMETRY);
                }
 
-               uint64_t customdata_mask_prev = scene->customdata_mask;
-               scene->customdata_mask |= CD_MASK_MESH;
+               CustomData_MeshMasks customdata_mask_prev = scene->customdata_mask;
+               CustomData_MeshMasks_update(&scene->customdata_mask, &CD_MASK_MESH);
                BKE_scene_graph_update_tagged(depsgraph, bmain);
                scene->customdata_mask = customdata_mask_prev;
        }
@@ -1966,9 +1966,9 @@ static int convert_exec(bContext *C, wmOperator *op)
                         */
                        Scene *scene_eval = (Scene *)DEG_get_evaluated_id(depsgraph, &scene->id);
                        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
-                       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_MESH);
+                       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
                        me_eval = BKE_mesh_copy_for_eval(me_eval, false);
-                       BKE_mesh_nomain_to_mesh(me_eval, newob->data, newob, CD_MASK_MESH, true);
+                       BKE_mesh_nomain_to_mesh(me_eval, newob->data, newob, &CD_MASK_MESH, true);
                        BKE_object_free_modifiers(newob, 0);   /* after derivedmesh calls! */
                }
                else if (ob->type == OB_FONT) {
index 9835d09ec3a00750d470a6cb28bced22eaa765cd..ac1f31d0b48d0484aa9f2f0737815502529b3346 100644 (file)
@@ -226,7 +226,7 @@ static DerivedMesh *multiresbake_create_loresdm(Scene *scene, Object *ob, int *l
        MultiresModifierData tmp_mmd = *mmd;
        DerivedMesh *cddm = CDDM_from_mesh(me);
 
-       DM_set_only_copy(cddm, CD_MASK_BAREMESH);
+       DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
 
        if (mmd->lvl == 0) {
                dm = CDDM_copy(cddm);
@@ -252,13 +252,13 @@ static DerivedMesh *multiresbake_create_hiresdm(Scene *scene, Object *ob, int *l
        DerivedMesh *cddm = CDDM_from_mesh(me);
        DerivedMesh *dm;
 
-       DM_set_only_copy(cddm, CD_MASK_BAREMESH);
+       DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
 
        /* TODO: DM_set_only_copy wouldn't set mask for loop and poly data,
         *       but we really need BAREMESH only to save lots of memory
         */
-       CustomData_set_only_copy(&cddm->loopData, CD_MASK_BAREMESH);
-       CustomData_set_only_copy(&cddm->polyData, CD_MASK_BAREMESH);
+       CustomData_set_only_copy(&cddm->loopData, CD_MASK_BAREMESH.lmask);
+       CustomData_set_only_copy(&cddm->polyData, CD_MASK_BAREMESH.pmask);
 
        *lvl = mmd->totlvl;
        *simple = mmd->simple != 0;
index 34f758900e91c8202de656f4bd9fc2477c59d496..8ca0b9c3c918a2c254a3fdbe43c0997da84ff35f 100644 (file)
@@ -135,7 +135,9 @@ static const EnumPropertyItem *dt_layers_select_src_itemf(
                        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
                        Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
 
-                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, CD_MASK_BAREMESH | CD_MASK_MLOOPUV);
+                       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
+                       cddata_masks.lmask |= CD_MASK_MLOOPUV;
+                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
                        num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPUV);
 
                        RNA_enum_item_add_separator(&item, &totitem);
@@ -157,7 +159,9 @@ static const EnumPropertyItem *dt_layers_select_src_itemf(
                        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
                        Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
 
-                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, CD_MASK_BAREMESH | CD_MASK_MLOOPCOL);
+                       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
+                       cddata_masks.lmask |= CD_MASK_MLOOPCOL;
+                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
                        num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPCOL);
 
                        RNA_enum_item_add_separator(&item, &totitem);
index c72910762342804dfb7529e57e624fb13684715f..6ea6617191f4b93b55a552dd3ef34fd7539c7e24 100644 (file)
@@ -96,7 +96,7 @@ static void modifier_skin_customdata_delete(struct Object *ob);
 static void object_force_modifier_update_for_bind(Depsgraph *depsgraph, Scene *scene, Object *ob)
 {
        if (ob->type == OB_MESH) {
-               Mesh *me_eval = mesh_create_eval_final_view(depsgraph, scene, ob, 0);
+               Mesh *me_eval = mesh_create_eval_final_view(depsgraph, scene, ob, &CD_MASK_BAREMESH);
                BKE_id_free(NULL, me_eval);
        }
        else if (ob->type == OB_LATTICE) {
@@ -637,7 +637,7 @@ static int modifier_apply_obdata(ReportList *reports, Depsgraph *depsgraph, Scen
                                return 0;
                        }
 
-                       BKE_mesh_nomain_to_mesh(mesh_applied, me, ob, CD_MASK_MESH, true);
+                       BKE_mesh_nomain_to_mesh(mesh_applied, me, ob, &CD_MASK_MESH, true);
 
                        if (md->type == eModifierType_Multires)
                                multires_customdata_delete(me);
@@ -1353,7 +1353,7 @@ static int multires_external_save_exec(bContext *C, wmOperator *op)
                BLI_path_rel(path, BKE_main_blendfile_path(bmain));
 
        CustomData_external_add(&me->ldata, &me->id, CD_MDISPS, me->totloop, path);
-       CustomData_external_write(&me->ldata, &me->id, CD_MASK_MESH, me->totloop, 0);
+       CustomData_external_write(&me->ldata, &me->id, CD_MASK_MESH.lmask, me->totloop, 0);
 
        return OPERATOR_FINISHED;
 }
@@ -1748,7 +1748,7 @@ static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain,
        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, skin_ob);
 
-       me_eval_deform = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+       me_eval_deform = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
        mvert = me_eval_deform->mvert;
 
        /* add vertex weights to original mesh */
index a515911819693ac8672ff88271b9844f824f395d..22b7e49093efb2f6c35b6cbb698dc60952e64ad9 100644 (file)
@@ -153,7 +153,7 @@ static int vertex_parent_set_exec(bContext *C, wmOperator *op)
 
                /* derivedMesh might be needed for solving parenting,
                 * so re-create it here */
-               makeDerivedMesh(depsgraph, scene, obedit, em, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX, false);
+               makeDerivedMesh(depsgraph, scene, obedit, em, &CD_MASK_BAREMESH_ORIGINDEX, false);
 
                BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
                        if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
index f3181f227b22d7ebff463c5f641ad5847a2c9165..c0e022df62929cfdaffab67b14754ea175dc116d 100644 (file)
@@ -1289,7 +1289,7 @@ static void moveCloserToDistanceFromPlane(
        float originalDistToBe = distToBe;
        do {
                wasChange = false;
-               me_deform = mesh_get_eval_deform(depsgraph, scene, ob, CD_MASK_BAREMESH);
+               me_deform = mesh_get_eval_deform(depsgraph, scene, ob, &CD_MASK_BAREMESH);
                m = me_deform->mvert[index];
                copy_v3_v3(oldPos, m.co);
                distToStart = dot_v3v3(norm, oldPos) + d;
@@ -1329,7 +1329,7 @@ static void moveCloserToDistanceFromPlane(
                                if (dw->weight > 1) {
                                        dw->weight = 1;
                                }
-                               me_deform = mesh_get_eval_deform(depsgraph, scene, ob, CD_MASK_BAREMESH);
+                               me_deform = mesh_get_eval_deform(depsgraph, scene, ob, &CD_MASK_BAREMESH);
                                m = me_deform->mvert[index];
                                getVerticalAndHorizontalChange(norm, d, coord, oldPos, distToStart, m.co, changes, dists, i);
                                dw->weight = oldw;
@@ -1459,7 +1459,7 @@ static void vgroup_fix(const bContext *C, Scene *scene, Object *ob, float distTo
                                MVert *p = MEM_callocN(sizeof(MVert) * (count), "deformedPoints");
                                int k;
 
-                               Mesh *me_deform = mesh_get_eval_deform(depsgraph, scene, ob, CD_MASK_BAREMESH);
+                               Mesh *me_deform = mesh_get_eval_deform(depsgraph, scene, ob, &CD_MASK_BAREMESH);
                                k = count;
                                while (k--) {
                                        p[k] = me_deform->mvert[verts[k]];
index 0c08fc6fb29e6197f882077a2b2dcb7f87f4c482..b2f314a66ec000084a655fd33751300b443d1d72 100644 (file)
@@ -3593,9 +3593,9 @@ static int particle_intersect_mesh(Depsgraph *depsgraph, Scene *UNUSED(scene), O
                Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
                Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
 
-               mesh = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+               mesh = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
                if (mesh == NULL) {
-                       mesh = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+                       mesh = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
                }
 
                psys_enable_all(ob);
index e0903a9d7c5956d6e5bf178c081681b5908b2042..ac304f1aeec5210531cfd8f30891fdaf43aa324b 100644 (file)
@@ -51,7 +51,6 @@
 #include "BKE_report.h"
 
 #include "DEG_depsgraph.h"
-#include "DEG_depsgraph_query.h"
 #include "DEG_depsgraph_build.h"
 
 #include "RNA_access.h"
@@ -1030,7 +1029,7 @@ static bool copy_particle_systems_to_object(const bContext *C,
        ParticleSystem *psys_start = NULL, *psys, *psys_from;
        ParticleSystem **tmp_psys;
        Mesh *final_mesh;
-       CustomDataMask cdmask;
+       CustomData_MeshMasks cdmask = {0};
        int i, totpsys;
 
        if (ob_to->type != OB_MESH)
@@ -1052,7 +1051,6 @@ static bool copy_particle_systems_to_object(const bContext *C,
 
        tmp_psys = MEM_mallocN(sizeof(ParticleSystem *) * totpsys, "temporary particle system array");
 
-       cdmask = 0;
        for (psys_from = PSYS_FROM_FIRST, i = 0;
             psys_from;
             psys_from = PSYS_FROM_NEXT(psys_from), ++i)
@@ -1063,7 +1061,7 @@ static bool copy_particle_systems_to_object(const bContext *C,
                if (psys_start == NULL)
                        psys_start = psys;
 
-               cdmask |= psys_emitter_customdata_mask(psys);
+               psys_emitter_customdata_mask(psys, &cdmask);
        }
        /* to iterate source and target psys in sync,
         * we need to know where the newly added psys start
@@ -1071,8 +1069,7 @@ static bool copy_particle_systems_to_object(const bContext *C,
        psys_start = totpsys > 0 ? tmp_psys[0] : NULL;
 
        /* Get the evaluated mesh (psys and their modifiers have not been appended yet) */
-       Object *ob_to_eval = DEG_get_evaluated_object(depsgraph, ob_to);
-       final_mesh = mesh_get_eval_final(depsgraph, scene, ob_to_eval, cdmask);
+       final_mesh = mesh_get_eval_final(depsgraph, scene, ob_to, &cdmask);
 
        /* now append psys to the object and make modifiers */
        for (i = 0, psys_from = PSYS_FROM_FIRST;
@@ -1085,7 +1082,6 @@ static bool copy_particle_systems_to_object(const bContext *C,
 
                /* append to the object */
                BLI_addtail(&ob_to->particlesystem, psys);
-               psys_unique_name(ob_to, psys, "");
 
                /* add a particle system modifier for each system */
                md = modifier_new(eModifierType_ParticleSystem);
@@ -1093,7 +1089,7 @@ static bool copy_particle_systems_to_object(const bContext *C,
                /* push on top of the stack, no use trying to reproduce old stack order */
                BLI_addtail(&ob_to->modifiers, md);
 
-               BLI_strncpy(md->name, psys->name, sizeof(md->name));
+               BLI_snprintf(md->name, sizeof(md->name), "ParticleSystem %i", i);
                modifier_unique_name(&ob_to->modifiers, (ModifierData *)psmd);
 
                psmd->psys = psys;
index d4312b3d18a36b05eca28779e66d4bf6c59f7303..feadc88e1d7eb6f3198883ccde452a069d96a3e9 100644 (file)
@@ -42,6 +42,7 @@
 
 #include "BKE_camera.h"
 #include "BKE_context.h"
+#include "BKE_customdata.h"
 #include "BKE_global.h"
 #include "BKE_image.h"
 #include "BKE_main.h"
@@ -603,11 +604,12 @@ static bool screen_opengl_render_init(bContext *C, wmOperator *op)
                oglrender->rv3d = oglrender->ar->regiondata;
 
                /* MUST be cleared on exit */
-               oglrender->scene->customdata_mask_modal = ED_view3d_datamask(C, oglrender->scene, oglrender->v3d);
+               memset(&oglrender->scene->customdata_mask_modal, 0, sizeof(oglrender->scene->customdata_mask_modal));
+               ED_view3d_datamask(C, oglrender->scene, oglrender->v3d, &oglrender->scene->customdata_mask_modal);
 
                /* apply immediately in case we're rendering from a script,
                 * running notifiers again will overwrite */
-               oglrender->scene->customdata_mask |= oglrender->scene->customdata_mask_modal;
+               CustomData_MeshMasks_update(&oglrender->scene->customdata_mask, &oglrender->scene->customdata_mask_modal);
        }
 
        /* create render */
@@ -738,7 +740,7 @@ static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
                MEM_freeN(oglrender->seq_data.ibufs_arr);
        }
 
-       oglrender->scene->customdata_mask_modal = 0;
+       memset(&oglrender->scene->customdata_mask_modal, 0, sizeof(oglrender->scene->customdata_mask_modal));
 
        CTX_wm_area_set(C, oglrender->prevsa);
        CTX_wm_region_set(C, oglrender->prevar);
index 6da33ad8b72268f29f02225416e23bf1d3392b3e..e39abd591cf84ea827553fe3ae9b5978f5921e48 100644 (file)
@@ -61,6 +61,7 @@
 #include "BKE_colorband.h"
 #include "BKE_context.h"
 #include "BKE_colortools.h"
+#include "BKE_customdata.h"
 #include "BKE_idprop.h"
 #include "BKE_image.h"
 #include "BKE_library.h"
@@ -3780,17 +3781,26 @@ static bool proj_paint_state_mesh_eval_init(const bContext *C, ProjPaintState *p
                return false;
        }
 
+       CustomData_MeshMasks cddata_masks = scene_eval->customdata_mask;
+       cddata_masks.fmask |= CD_MASK_MTFACE;
+       cddata_masks.lmask |= CD_MASK_MLOOPUV;
+
        /* Workaround for subsurf selection, try the display mesh first */
        if (ps->source == PROJ_SRC_IMAGE_CAM) {
                /* using render mesh, assume only camera was rendered from */
                ps->me_eval = mesh_create_eval_final_render(
-                            depsgraph, scene_eval, ob_eval, scene_eval->customdata_mask | CD_MASK_MLOOPUV | CD_MASK_MTFACE);
+                            depsgraph, scene_eval, ob_eval, &cddata_masks);
                ps->me_eval_free = true;
        }
        else {
+               if (ps->do_face_sel) {
+                       cddata_masks.vmask |= CD_MASK_ORIGINDEX;
+                       cddata_masks.emask |= CD_MASK_ORIGINDEX;
+                       cddata_masks.pmask |= CD_MASK_ORIGINDEX;
+               }
                ps->me_eval = mesh_get_eval_final(
                        depsgraph, scene_eval, ob_eval,
-                       scene_eval->customdata_mask | CD_MASK_MLOOPUV | CD_MASK_MTFACE | (ps->do_face_sel ? CD_MASK_ORIGINDEX : 0));
+                       &cddata_masks);
                ps->me_eval_free = false;
        }
 
index ca26d2050e4e82dd0aa84b495096e2eb6ff11607..9246c852b3a3132248faed369c0ceec1812302cb 100644 (file)
@@ -33,6 +33,7 @@
 #include "DNA_object_types.h"
 
 #include "BKE_context.h"
+#include "BKE_customdata.h"
 #include "BKE_mesh_iterators.h"
 #include "BKE_mesh_runtime.h"
 
@@ -103,7 +104,9 @@ static void vpaint_proj_dm_map_cosnos_init(
        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
        Mesh *me = ob->data;
-       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
+
+       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH_ORIGINDEX;
+       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &cddata_masks);
 
        memset(vp_handle->vcosnos, 0, sizeof(*vp_handle->vcosnos) * me->totvert);
        BKE_mesh_foreach_mapped_vert(me_eval, vpaint_proj_dm_map_cosnos_init__map_cb, vp_handle, MESH_FOREACH_USE_NORMAL);
@@ -168,7 +171,9 @@ static void vpaint_proj_dm_map_cosnos_update(
        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
        Mesh *me = ob->data;
-       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
+
+       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH_ORIGINDEX;
+       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &cddata_masks);
 
        /* quick sanity check - we shouldn't have to run this if there are no modifiers */
        BLI_assert(BLI_listbase_is_empty(&ob->modifiers) == false);
index 5db016108861221f2021d5dae2bd4f9b78bb0fac..aa3f424f81658d066953092f00e12b4798b93c65 100644 (file)
@@ -788,7 +788,11 @@ static int paint_weight_gradient_exec(bContext *C, wmOperator *op)
        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
 
-       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, scene->customdata_mask | CD_MASK_ORIGINDEX);
+       CustomData_MeshMasks cddata_masks = scene->customdata_mask;
+       cddata_masks.vmask |= CD_MASK_ORIGINDEX;
+       cddata_masks.emask |= CD_MASK_ORIGINDEX;
+       cddata_masks.pmask |= CD_MASK_ORIGINDEX;
+       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &cddata_masks);
        if (data.is_init) {
                data.vert_visit = BLI_BITMAP_NEW(me->totvert, __func__);
 
index 800d9e6d56201d9f2ef3f38c1aa2da9a109d0464..7bce2464ef74dacad680b93fc0500cc67e26a302 100644 (file)
@@ -5532,13 +5532,13 @@ void sculpt_dynamic_topology_disable_ex(
                me->totpoly = unode->bm_enter_totpoly;
                me->totedge = unode->bm_enter_totedge;
                me->totface = 0;
-               CustomData_copy(&unode->bm_enter_vdata, &me->vdata, CD_MASK_MESH,
+               CustomData_copy(&unode->bm_enter_vdata, &me->vdata, CD_MASK_MESH.vmask,
                                CD_DUPLICATE, unode->bm_enter_totvert);
-               CustomData_copy(&unode->bm_enter_edata, &me->edata, CD_MASK_MESH,
+               CustomData_copy(&unode->bm_enter_edata, &me->edata, CD_MASK_MESH.emask,
                                CD_DUPLICATE, unode->bm_enter_totedge);
-               CustomData_copy(&unode->bm_enter_ldata, &me->ldata, CD_MASK_MESH,
+               CustomData_copy(&unode->bm_enter_ldata, &me->ldata, CD_MASK_MESH.lmask,
                                CD_DUPLICATE, unode->bm_enter_totloop);
-               CustomData_copy(&unode->bm_enter_pdata, &me->pdata, CD_MASK_MESH,
+               CustomData_copy(&unode->bm_enter_pdata, &me->pdata, CD_MASK_MESH.pmask,
                                CD_DUPLICATE, unode->bm_enter_totpoly);
 
                BKE_mesh_update_customdata_pointers(me, false);
index 53329c4cf78cc34064f0e2f3dc7fc1b05e798fb5..8c934b6a16add3b15cf16436feafe5b81365a1fa 100644 (file)
@@ -845,13 +845,13 @@ static SculptUndoNode *sculpt_undo_bmesh_push(Object *ob,
                         * dynamic-topology immediately does topological edits
                         * (converting polys to triangles) that the BMLog can't
                         * fully restore from */
-                       CustomData_copy(&me->vdata, &unode->bm_enter_vdata, CD_MASK_MESH,
+                       CustomData_copy(&me->vdata, &unode->bm_enter_vdata, CD_MASK_MESH.vmask,
                                        CD_DUPLICATE, me->totvert);
-                       CustomData_copy(&me->edata, &unode->bm_enter_edata, CD_MASK_MESH,
+                       CustomData_copy(&me->edata, &unode->bm_enter_edata, CD_MASK_MESH.emask,
                                        CD_DUPLICATE, me->totedge);
-                       CustomData_copy(&me->ldata, &unode->bm_enter_ldata, CD_MASK_MESH,
+                       CustomData_copy(&me->ldata, &unode->bm_enter_ldata, CD_MASK_MESH.lmask,
                                        CD_DUPLICATE, me->totloop);
-                       CustomData_copy(&me->pdata, &unode->bm_enter_pdata, CD_MASK_MESH,
+                       CustomData_copy(&me->pdata, &unode->bm_enter_pdata, CD_MASK_MESH.pmask,
                                        CD_DUPLICATE, me->totpoly);
                        unode->bm_enter_totvert = me->totvert;
                        unode->bm_enter_totedge = me->totedge;
index 0afdd36dbb635256d5fefe03ca9c167f20dd52eb..a52fd89d2842ed11f1709c27b300ff2ce0550c92 100644 (file)
@@ -879,40 +879,37 @@ void ED_view3d_draw_depth_gpencil(
 
 /* *********************** customdata **************** */
 
-CustomDataMask ED_view3d_datamask(const bContext *C, const Scene *UNUSED(scene), const View3D *v3d)
+void ED_view3d_datamask(
+        const bContext *C, const Scene *UNUSED(scene), const View3D *v3d, CustomData_MeshMasks *r_cddata_masks)
 {
-       CustomDataMask mask = 0;
        const int drawtype = view3d_effective_drawtype(v3d);
 
        if (ELEM(drawtype, OB_TEXTURE, OB_MATERIAL)) {
-               mask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
+               r_cddata_masks->lmask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
 
                if (drawtype == OB_MATERIAL)
-                       mask |= CD_MASK_ORCO;
+                       r_cddata_masks->vmask |= CD_MASK_ORCO;
        }
 
        if ((CTX_data_mode_enum(C) == CTX_MODE_EDIT_MESH) &&
            (v3d->overlay.edit_flag & V3D_OVERLAY_EDIT_WEIGHT))
        {
-               mask |= CD_MASK_MDEFORMVERT;
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
        }
-
-       return mask;
 }
 
 /* goes over all modes and view3d settings */
-CustomDataMask ED_view3d_screen_datamask(const bContext *C, const Scene *scene, const bScreen *screen)
+void ED_view3d_screen_datamask(
+        const bContext *C, const Scene *scene, const bScreen *screen, CustomData_MeshMasks *r_cddata_masks)
 {
-       CustomDataMask mask = CD_MASK_BAREMESH;
+       CustomData_MeshMasks_update(r_cddata_masks, &CD_MASK_BAREMESH);
 
        /* check if we need tfaces & mcols due to view mode */
        for (const ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
                if (sa->spacetype == SPACE_VIEW3D) {
-                       mask |= ED_view3d_datamask(C, scene, sa->spacedata.first);
+                       ED_view3d_datamask(C, scene, sa->spacedata.first, r_cddata_masks);
                }
        }
-
-       return mask;
 }
 
 /**
index 93cdecec557e124edcd720694a7793fc27aba798..0054680281b214f9efc1e47ede241bdd822404e3 100644 (file)
@@ -115,7 +115,7 @@ void meshobject_foreachScreenVert(
        Scene *scene_eval = DEG_get_evaluated_scene(vc->depsgraph);
        Object *ob_eval = DEG_get_evaluated_object(vc->depsgraph, vc->obact);
 
-       me = mesh_get_eval_deform(vc->depsgraph, scene_eval, ob_eval, CD_MASK_BAREMESH);
+       me = mesh_get_eval_deform(vc->depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
 
        ED_view3d_check_mats_rv3d(vc->rv3d);
 
@@ -155,7 +155,7 @@ void mesh_foreachScreenVert(
 {
        foreachScreenVert_userData data;
 
-       Mesh *me = editbmesh_get_eval_cage_from_orig(vc->depsgraph, vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+       Mesh *me = editbmesh_get_eval_cage_from_orig(vc->depsgraph, vc->scene, vc->obedit, vc->em, &CD_MASK_BAREMESH);
 
        ED_view3d_check_mats_rv3d(vc->rv3d);
 
@@ -208,7 +208,7 @@ void mesh_foreachScreenEdge(
 {
        foreachScreenEdge_userData data;
 
-       Mesh *me = editbmesh_get_eval_cage_from_orig(vc->depsgraph, vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+       Mesh *me = editbmesh_get_eval_cage_from_orig(vc->depsgraph, vc->scene, vc->obedit, vc->em, &CD_MASK_BAREMESH);
 
        ED_view3d_check_mats_rv3d(vc->rv3d);
 
@@ -253,7 +253,7 @@ void mesh_foreachScreenFace(
 {
        foreachScreenFace_userData data;
 
-       Mesh *me = editbmesh_get_eval_cage_from_orig(vc->depsgraph, vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+       Mesh *me = editbmesh_get_eval_cage_from_orig(vc->depsgraph, vc->scene, vc->obedit, vc->em, &CD_MASK_BAREMESH);
        ED_view3d_check_mats_rv3d(vc->rv3d);
 
        data.vc = *vc;
index d64d0a3cbfd3bdc0d5300f1aca8b6e80b3b8e17c..104b27965a59597465d05b682121c1fc52063a5d 100644 (file)
@@ -23,6 +23,8 @@
 
 #include <stdio.h>
 
+#include "BLI_utildefines.h"
+
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 #include "DNA_gpencil_types.h"
index 4bacfd15751fa44815f78a0570e78877ab3fbfa6..91412044e0eac4429b8d1ecc188df4e8ad37e6c9 100644 (file)
@@ -190,6 +190,19 @@ typedef enum CustomDataType {
 #define CD_MASK_TESSLOOPNORMAL  (1LL << CD_TESSLOOPNORMAL)
 #define CD_MASK_CUSTOMLOOPNORMAL (1LL << CD_CUSTOMLOOPNORMAL)
 
+/** Data types that may be defined for all mesh elements types. */
+#define CD_MASK_GENERIC_DATA (CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR)
+
+
+typedef struct CustomData_MeshMasks {
+       uint64_t vmask;
+       uint64_t emask;
+       uint64_t fmask;
+       uint64_t pmask;
+       uint64_t lmask;
+} CustomData_MeshMasks;
+
+
 /* CustomData.flag */
 enum {
        /* Indicates layer should not be copied by CustomData_from_template or CustomData_copy_data */
index eac8b82d6ea8c7be5756e90c53f75bfdc08135dc..3b09801b4b76ea0e479d3e000ebb15eac121a8bb 100644 (file)
@@ -28,6 +28,7 @@
 #include "DNA_object_enums.h"
 
 #include "DNA_defs.h"
+#include "DNA_customdata_types.h"
 #include "DNA_listBase.h"
 #include "DNA_ID.h"
 #include "DNA_action_types.h" /* bAnimVizSettings */
@@ -122,13 +123,15 @@ typedef struct LodLevel {
  * TODO(sergey): Consider moving it to more appropriate place. */
 struct ObjectBBoneDeform;
 
+struct CustomData_MeshMasks;
+
 /* Not saved in file! */
 typedef struct Object_Runtime {
        /**
         * The custom data layer mask that was last used
         * to calculate mesh_eval and mesh_deform_eval.
         */
-       uint64_t last_data_mask;
+       CustomData_MeshMasks last_data_mask;
 
        /** Did last modifier stack generation need mapping support? */
        char last_need_mapping;
index 5e1f43043899c4461ff32b5cbc1f3582a3ce6364..2607ca5f3331a636cc8020c73320642db5242efb 100644 (file)
@@ -34,6 +34,7 @@ extern "C" {
 #endif
 
 #include "DNA_color_types.h"  /* color management */
+#include "DNA_customdata_types.h"  /* Scene's runtime cddata masks. */
 #include "DNA_vec_types.h"
 #include "DNA_listBase.h"
 #include "DNA_ID.h"
@@ -50,6 +51,7 @@ struct Brush;
 struct Collection;
 struct ColorSpace;
 struct CurveMapping;
+struct CustomData_MeshMasks;
 struct Editing;
 struct Image;
 struct MovieClip;
@@ -1752,10 +1754,9 @@ typedef struct Scene {
        void *_pad8;
        /* XXX. runtime flag for drawing, actually belongs in the window,
         * only used by BKE_object_handle_update() */
-       uint64_t customdata_mask;
+       struct CustomData_MeshMasks customdata_mask;
        /* XXX. same as above but for temp operator use (gl renders) */
-       uint64_t customdata_mask_modal;
-
+       struct CustomData_MeshMasks customdata_mask_modal;
 
        /* Color Management */
        ColorManagedViewSettings view_settings;
index 31c7853315121bab4939d3016a2b9c9bc610ad95..f9f94560452eddeb7699dfd62024bc5baf629ab0 100644 (file)
@@ -937,7 +937,9 @@ static const EnumPropertyItem *rna_DataTransferModifier_layers_select_src_itemf(
                        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
                        Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
 
-                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, CD_MASK_BAREMESH | CD_MASK_MLOOPUV);
+                       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
+                       cddata_masks.lmask |= CD_MASK_MLOOPUV;
+                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
                        num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPUV);
 
                        RNA_enum_item_add_separator(&item, &totitem);
@@ -959,7 +961,9 @@ static const EnumPropertyItem *rna_DataTransferModifier_layers_select_src_itemf(
                        Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
                        Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
 
-                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, CD_MASK_BAREMESH | CD_MASK_MLOOPCOL);
+                       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
+                       cddata_masks.lmask |= CD_MASK_MLOOPCOL;
+                       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
                        num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPCOL);
 
                        RNA_enum_item_add_separator(&item, &totitem);
index e58beaaa42d70478748cc6582a14ce864d1bcc3d..4a474dde5854dd73cfad72b195cc2d994f3478fd 100644 (file)
@@ -65,14 +65,10 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
        tamd->prevCos = NULL;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md), CustomData_MeshMasks *r_cddata_masks)
 {
-       CustomDataMask dataMask = 0;
-
        /* ask for vertexgroups */
-       dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
 }
 
 static bool isDisabled(const struct Scene *UNUSED(scene), ModifierData *md, bool UNUSED(useRenderParams))
index 0b28f51a338b14d08ff9ffd1ad8cc7076adccd52..3450e74534137c8a2832e34025f8c17fcf5fb6da 100644 (file)
@@ -69,15 +69,14 @@ static void copyData(const ModifierData *md_src, ModifierData *md_dst, const int
        modifier_copyData_generic(md_src, md_dst, flag);
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        BevelModifierData *bmd = (BevelModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (bmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (bmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 /*
@@ -117,7 +116,8 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
                    .add_key_index = false,
                    .use_shapekey = false,
                    .active_shapekey = 0,
-                   .cd_mask_extra = CD_MASK_ORIGINDEX,
+                    /* XXX We probably can use CD_MASK_BAREMESH_ORIGDINDEX here instead (also for other modifiers cases)? */
+                   .cd_mask_extra = {.vmask=CD_MASK_ORIGINDEX, .emask=CD_MASK_ORIGINDEX, .pmask=CD_MASK_ORIGINDEX},
                });
 
        if ((bmd->lim_flags & MOD_BEVEL_VGROUP) && bmd->defgrp_name[0])
@@ -188,7 +188,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
                      harden_normals, face_strength_mode,
                      miter_outer, miter_inner, spread, mesh->smoothresh);
 
-       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
 
        BLI_assert(bm->vtoolflagpool == NULL &&
                   bm->etoolflagpool == NULL &&
index b81536ff9476a5ab246b957250052cc23a14aa7b..a90ddde7946c9e8a20a24a00a068ac22b424ef6b 100644 (file)
@@ -301,7 +301,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
                                MEM_freeN(looptris);
                        }
 
-                       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+                       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
 
                        BM_mesh_free(bm);
 
@@ -321,13 +321,11 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
        return result;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md), CustomData_MeshMasks *r_cddata_masks)
 {
-       CustomDataMask dataMask = CD_MASK_MTFACE | CD_MASK_MEDGE;
-
-       dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       r_cddata_masks->emask |= CD_MASK_MEDGE;
+       r_cddata_masks->fmask |= CD_MASK_MTFACE;
 }
 
 ModifierTypeInfo modifierType_Boolean = {
index 4aac71dd58d894fadfcc99f9b1f6876a7c30c2c5..f408a22aadf16ecf9c66d23742b426ec8d33ade2 100644 (file)
@@ -66,15 +66,14 @@ static bool isDisabled(const struct Scene *UNUSED(scene), ModifierData *md, bool
        return false;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        CastModifierData *cmd = (CastModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (cmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (cmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static void foreachObjectLink(
index 54dcf796036bcffece5d76b4b62d5635995c9d85..41f35faac1b536dbfa4dde55ecbefe63608b6e71 100644 (file)
@@ -127,18 +127,17 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
        DEG_add_modifier_to_transform_relation(ctx->node, "Cloth Modifier");
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
-       CustomDataMask dataMask = 0;
        ClothModifierData *clmd = (ClothModifierData *)md;
 
-       if (cloth_uses_vgroup(clmd))
-               dataMask |= CD_MASK_MDEFORMVERT;
-
-       if (clmd->sim_parms->shapekey_rest != 0)
-               dataMask |= CD_MASK_CLOTH_ORCO;
+       if (cloth_uses_vgroup(clmd)) {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 
-       return dataMask;
+       if (clmd->sim_parms->shapekey_rest != 0) {
+               r_cddata_masks->vmask |= CD_MASK_CLOTH_ORCO;
+       }
 }
 
 static void copyData(const ModifierData *md, ModifierData *target, const int flag)
index fa5e68fa630793ab3150604b5457dd34c2a97f8e..cc6177b9bc8ce1c226d6bd503f04e56fc464c210 100644 (file)
@@ -105,15 +105,14 @@ static void freeData(ModifierData *md)
 }
 
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        CorrectiveSmoothModifierData *csmd = (CorrectiveSmoothModifierData *)md;
-       CustomDataMask dataMask = 0;
+
        /* ask for vertex groups if we need them */
-       if (csmd->defgrp_name[0]) {
-               dataMask |= CD_MASK_MDEFORMVERT;
+       if (csmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
        }
-       return dataMask;
 }
 
 
index 4a8b6de9981793887517737f73db0cf0e60332a3..f3a5e280947f57086581196d5ff758111da2b7ed 100644 (file)
@@ -50,15 +50,14 @@ static void initData(ModifierData *md)
        cmd->defaxis = MOD_CURVE_POSX;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void  requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        CurveModifierData *cmd = (CurveModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (cmd->name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (cmd->name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static bool isDisabled(const Scene *UNUSED(scene), ModifierData *md, bool UNUSED(userRenderParams))
index d7b18074b09429318083a4728724c3760084e0e4..3e461476eac3ca5bd439c80763fc7f41985d83ad 100644 (file)
@@ -75,19 +75,16 @@ static void initData(ModifierData *md)
        dtmd->flags              = MOD_DATATRANSFER_OBSRC_TRANSFORM;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        DataTransferModifierData *dtmd = (DataTransferModifierData *) md;
-       CustomDataMask dataMask = 0;
 
-       if (dtmd->defgrp_name[0]) {
+       if (dtmd->defgrp_name[0] != '\0') {
                /* We need vertex groups! */
-               dataMask |= CD_MASK_MDEFORMVERT;
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
        }
 
-       dataMask |= BKE_object_data_transfer_dttypes_to_cdmask(dtmd->data_types);
-
-       return dataMask;
+       BKE_object_data_transfer_dttypes_to_cdmask(dtmd->data_types, r_cddata_masks);
 }
 
 static bool dependsOnNormals(ModifierData *md)
@@ -123,10 +120,11 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
 {
        DataTransferModifierData *dtmd = (DataTransferModifierData *) md;
        if (dtmd->ob_source != NULL) {
-               CustomDataMask mask = BKE_object_data_transfer_dttypes_to_cdmask(dtmd->data_types);
+               CustomData_MeshMasks cddata_masks = {0};
+               BKE_object_data_transfer_dttypes_to_cdmask(dtmd->data_types, &cddata_masks);
 
                DEG_add_object_relation(ctx->node, dtmd->ob_source, DEG_OB_COMP_GEOMETRY, "DataTransfer Modifier");
-               DEG_add_customdata_mask(ctx->node, dtmd->ob_source, mask);
+               DEG_add_customdata_mask(ctx->node, dtmd->ob_source, &cddata_masks);
 
                if (dtmd->flags & MOD_DATATRANSFER_OBSRC_TRANSFORM) {
                        DEG_add_object_relation(ctx->node, dtmd->ob_source, DEG_OB_COMP_TRANSFORM, "DataTransfer Modifier");
index fbc3529c221260d9da54e12fcfa00f6115c3834b..52289ef107e536d48e9c1109fb49e5fe53fe65fc 100644 (file)
@@ -57,17 +57,14 @@ static void initData(ModifierData *md)
        dmd->defgrp_factor = 1.0;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        DecimateModifierData *dmd = (DecimateModifierData *) md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (dmd->defgrp_name[0] && (dmd->defgrp_factor > 0.0f)) {
-               dataMask |= CD_MASK_MDEFORMVERT;
+       if (dmd->defgrp_name[0] != '\0' && (dmd->defgrp_factor > 0.0f)) {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
        }
-
-       return dataMask;
 }
 
 static DecimateModifierData *getOriginalModifierData(
@@ -166,7 +163,7 @@ static Mesh *applyModifier(
                &(struct BMeshCreateParams){0},
                &(struct BMeshFromMeshParams){
                    .calc_face_normal = calc_face_normal,
-                   .cd_mask_extra = CD_MASK_ORIGINDEX,
+                   .cd_mask_extra = {.vmask=CD_MASK_ORIGINDEX, .emask=CD_MASK_ORIGINDEX, .pmask=CD_MASK_ORIGINDEX},
                });
 
        switch (dmd->mode) {
@@ -199,7 +196,7 @@ static Mesh *applyModifier(
 
        updateFaceCount(ctx, dmd, bm->totface);
 
-       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
        BLI_assert(bm->vtoolflagpool == NULL &&
                   bm->etoolflagpool == NULL &&
                   bm->ftoolflagpool == NULL);  /* make sure we never alloc'd these */
index fc619837cb73b8ca696b58bddd301a7198d4afb1..87b25982d816f481c83e3d0eaa760959456d412d 100644 (file)
@@ -65,22 +65,23 @@ static void initData(ModifierData *md)
        dmd->space = MOD_DISP_SPACE_LOCAL;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        DisplaceModifierData *dmd = (DisplaceModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (dmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
+       if (dmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 
        /* ask for UV coordinates if we need them */
-       if (dmd->texmapping == MOD_DISP_MAP_UV) dataMask |= CD_MASK_MTFACE;
+       if (dmd->texmapping == MOD_DISP_MAP_UV) {
+               r_cddata_masks->fmask |= CD_MASK_MTFACE;
+       }
 
        if (dmd->direction == MOD_DISP_DIR_CLNOR) {
-               dataMask |= CD_MASK_CUSTOMLOOPNORMAL;
+               r_cddata_masks->lmask |= CD_MASK_CUSTOMLOOPNORMAL;
        }
-
-       return dataMask;
 }
 
 static bool dependsOnTime(ModifierData *md)
index 3fea556c3e490fcdd586b027efaa9af0ba07c9a0..b84e46e145c082612c0af674f5159493e6dee549 100644 (file)
@@ -64,10 +64,9 @@ static void freeData(ModifierData *md)
        dynamicPaint_Modifier_free(pmd);
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        if (pmd->canvas) {
                DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
@@ -76,21 +75,20 @@ static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
                        if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ ||
                            surface->init_color_type == MOD_DPAINT_INITIAL_TEXTURE)
                        {
-                               dataMask |= CD_MASK_MLOOPUV;
+                               r_cddata_masks->lmask |= CD_MASK_MLOOPUV;
                        }
                        /* mcol */
                        if (surface->type == MOD_DPAINT_SURFACE_T_PAINT ||
                            surface->init_color_type == MOD_DPAINT_INITIAL_VERTEXCOLOR)
                        {
-                               dataMask |= CD_MASK_MLOOPCOL;
+                               r_cddata_masks->lmask |= CD_MASK_MLOOPCOL;
                        }
                        /* CD_MDEFORMVERT */
                        if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
-                               dataMask |= CD_MASK_MDEFORMVERT;
+                               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
                        }
                }
        }
-       return dataMask;
 }
 
 static Mesh *applyModifier(
index 548790ef78f12e6a3ded1eba00aa496127f99cf7..70c1ec5a59bac771f3340cdfacdadcc8365bda95 100644 (file)
@@ -60,7 +60,7 @@ static Mesh *doEdgeSplit(Mesh *mesh, EdgeSplitModifierData *emd)
                    .add_key_index = false,
                    .use_shapekey = false,
                    .active_shapekey = 0,
-                   .cd_mask_extra = CD_MASK_ORIGINDEX,
+                   .cd_mask_extra = {.vmask=CD_MASK_ORIGINDEX, .emask=CD_MASK_ORIGINDEX, .pmask=CD_MASK_ORIGINDEX},
                });
 
        if (do_split_angle) {
@@ -100,7 +100,7 @@ static Mesh *doEdgeSplit(Mesh *mesh, EdgeSplitModifierData *emd)
 
        /* BM_mesh_validate(bm); */ /* for troubleshooting */
 
-       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
        BM_mesh_free(bm);
 
        result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
index 5c5612f29a4172a806b9a67485bbd7db0e26dee2..3a0449a4e523f1b0c184f93bef867fc8bf3afac4 100644 (file)
@@ -76,15 +76,13 @@ static bool dependsOnTime(ModifierData *UNUSED(md))
 {
        return true;
 }
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        ExplodeModifierData *emd = (ExplodeModifierData *) md;
-       CustomDataMask dataMask = 0;
 
-       if (emd->vgroup)
-               dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (emd->vgroup) {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static void createFacepa(
index 0646f634e0d40fcb966cd314e4245c0c91addb8d..e911dbc4b5abab2eb0c845679a449b26a8eb7dea 100644 (file)
@@ -67,16 +67,20 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
        thmd->indexar = MEM_dupallocN(hmd->indexar);
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        HookModifierData *hmd = (HookModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (hmd->name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-       if (hmd->indexar) dataMask |= CD_MASK_ORIGINDEX;
-
-       return dataMask;
+       if (hmd->name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
+       if (hmd->indexar != NULL) {
+               /* TODO check which origindex are actually needed? */
+               r_cddata_masks->vmask |= CD_MASK_ORIGINDEX;
+               r_cddata_masks->emask |= CD_MASK_ORIGINDEX;
+               r_cddata_masks->pmask |= CD_MASK_ORIGINDEX;
+       }
 }
 
 static void freeData(ModifierData *md)
index 827d555e9000d707878c6a7e442cc04cbd5363f3..db76b0fd0c24052928040bb3632b4ede4f7db290 100644 (file)
@@ -716,12 +716,13 @@ static bool isDisabled(const struct Scene *UNUSED(scene), ModifierData *md, bool
        return 1;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        LaplacianDeformModifierData *lmd = (LaplacianDeformModifierData *)md;
-       CustomDataMask dataMask = 0;
-       if (lmd->anchor_grp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-       return dataMask;
+
+       if (lmd->anchor_grp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static void deformVerts(
index ee9f4ad8af7405e19a6b9a383d4808c80ce6d1f1..a6670f313ce5be1f00f91a01367de06cc5817e0c 100644 (file)
@@ -69,7 +69,7 @@ struct BLaplacianSystem {
 };
 typedef struct BLaplacianSystem LaplacianSystem;
 
-static CustomDataMask required_data_mask(Object *ob, ModifierData *md);
+static void required_data_mask(Object *ob, ModifierData *md, CustomData_MeshMasks *r_cddata_masks);
 static bool is_disabled(const struct Scene *UNUSED(scene), ModifierData *md, bool useRenderParams);
 static float compute_volume(const float center[3], float (*vertexCos)[3], const MPoly *mpoly, int numPolys, const MLoop *mloop);
 static LaplacianSystem *init_laplacian_system(int a_numEdges, int a_numPolys, int a_numLoops, int a_numVerts);
@@ -476,15 +476,14 @@ static bool is_disabled(const struct Scene *UNUSED(scene), ModifierData *md, boo
        return 0;
 }
 
-static CustomDataMask required_data_mask(Object *UNUSED(ob), ModifierData *md)
+static void required_data_mask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        LaplacianSmoothModifierData *smd = (LaplacianSmoothModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (smd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (smd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static void deformVerts(
index ba3624be71e828a66204bbd4ad981633f59c353f..46a9c4f0a476b1b280be283c58b863c02c6e4626 100644 (file)
@@ -47,15 +47,14 @@ static void initData(ModifierData *md)
        lmd->strength = 1.0f;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        LatticeModifierData *lmd = (LatticeModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (lmd->name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (lmd->name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static bool isDisabled(const struct Scene *UNUSED(scene), ModifierData *md, bool UNUSED(userRenderParams))
index 3440f37516dbef3a826e0d67c9651c8f0e3e9bc4..6d8317ffe77e8bc38745b9144dc6d93f749e32a3 100644 (file)
@@ -49,9 +49,9 @@
 
 #include "BLI_strict_flags.h"
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md), CustomData_MeshMasks *r_cddata_masks)
 {
-       return CD_MASK_MDEFORMVERT;
+       r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
 }
 
 static void foreachObjectLink(
index 1717e554798096c1e2540dd711d6118745d07f67..e59a6ae9add9c4e9b8194140370db459ba0cd394 100644 (file)
@@ -89,15 +89,14 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
        if (mmd->bindcos) tmmd->bindcos = MEM_dupallocN(mmd->bindcos);  /* deprecated */
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        MeshDeformModifierData *mmd = (MeshDeformModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (mmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (mmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static bool isDisabled(const struct Scene *UNUSED(scene), ModifierData *md, bool UNUSED(useRenderParams))
@@ -303,7 +302,7 @@ static void meshdeformModifier_do(
        if (cagemesh == NULL && mmd->bindcagecos == NULL && ob == DEG_get_original_object(ob)) {
                /* Special case, binding happens outside of depsgraph evaluation, so we can build our own
                 * target mesh if needed. */
-               cagemesh = mesh_create_eval_final_view(ctx->depsgraph, DEG_get_input_scene(ctx->depsgraph), mmd->object, 0);
+               cagemesh = mesh_create_eval_final_view(ctx->depsgraph, DEG_get_input_scene(ctx->depsgraph), mmd->object, &CD_MASK_BAREMESH);
                free_cagemesh = cagemesh != NULL;
        }
 #endif
index 3f02268c04c6997b6b0d582bdbf2832ff50dbb7f..cb4243a6150ef252b015e7323682e9d00d4270ed 100644 (file)
@@ -95,7 +95,7 @@ static Mesh *doBiscetOnMirrorPlane(
                &(struct BMeshCreateParams){0},
                &(struct BMeshFromMeshParams){
                        .calc_face_normal = true,
-                       .cd_mask_extra = CD_MASK_ORIGINDEX,
+                       .cd_mask_extra = {.vmask=CD_MASK_ORIGINDEX, .emask=CD_MASK_ORIGINDEX, .pmask=CD_MASK_ORIGINDEX},
                });
 
        /* Define bisecting plane (aka mirror plane). */
@@ -122,7 +122,7 @@ static Mesh *doBiscetOnMirrorPlane(
                }
        }
 
-       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
        BM_mesh_free(bm);
 
        return result;
index 8da49fb663217d0558f0ac045b371cbfce68fb37..d838d203ed572e3a503c24bdf5bc217112295175 100644 (file)
@@ -499,17 +499,16 @@ static void initData(ModifierData *md)
        enmd->mix_limit = M_PI;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        NormalEditModifierData *enmd = (NormalEditModifierData *)md;
-       CustomDataMask dataMask = CD_MASK_CUSTOMLOOPNORMAL;
+
+       r_cddata_masks->lmask |= CD_MASK_CUSTOMLOOPNORMAL;
 
        /* Ask for vertexgroups if we need them. */
-       if (enmd->defgrp_name[0]) {
-               dataMask |= (CD_MASK_MDEFORMVERT);
+       if (enmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
        }
-
-       return dataMask;
 }
 
 static bool dependsOnNormals(ModifierData *UNUSED(md))
index cf8e51d46940c72ee8eb163fb43d232db1669c98..50ec32bd605e46b16d59a91afdc8636a493d2ca4 100644 (file)
@@ -150,22 +150,17 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
 }
 
 #ifdef WITH_OCEANSIM
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        OceanModifierData *omd = (OceanModifierData *)md;
-       CustomDataMask dataMask = 0;
 
-       if (omd->flag & MOD_OCEAN_GENERATE_FOAM)
-               dataMask |= CD_MASK_MCOL;
-
-       return dataMask;
+       if (omd->flag & MOD_OCEAN_GENERATE_FOAM) {
+               r_cddata_masks->fmask |= CD_MASK_MCOL;  /* XXX Should be loop cddata I guess? */
+       }
 }
 #else /* WITH_OCEANSIM */
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md), CustomData_MeshMasks *UNUSED(r_cddata_masks))
 {
-       /* unused */
-       (void)md;
-       return 0;
 }
 #endif /* WITH_OCEANSIM */
 
index d219375b187a429cab4a05568f0c6f0e81337327..a9d8db493b832d1094094326b73d64c9d7dfe670 100644 (file)
@@ -63,19 +63,15 @@ static void initData(ModifierData *md)
        STRNCPY(pimd->value_layer_name, "");
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        ParticleInstanceModifierData *pimd = (ParticleInstanceModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        if (pimd->index_layer_name[0] != '\0' ||
            pimd->value_layer_name[0] != '\0')
        {
-               dataMask |= CD_MASK_MLOOPCOL;
+               r_cddata_masks->lmask |= CD_MASK_MLOOPCOL;
        }
-
-       return dataMask;
-
 }
 
 static bool isDisabled(const struct Scene *scene, ModifierData *md, bool useRenderParams)
index 2360d3e3713347e83533bd1ecee270ab43abb421..08a195066943d60adb22af0f8c09578e4442745d 100644 (file)
@@ -81,10 +81,11 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
        tpsmd->totdmvert = tpsmd->totdmedge = tpsmd->totdmface = 0;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        ParticleSystemModifierData *psmd = (ParticleSystemModifierData *) md;
-       return psys_emitter_customdata_mask(psmd->psys);
+
+       psys_emitter_customdata_mask(psmd->psys, r_cddata_masks);
 }
 
 /* saves the current emitter state for a particle system and calculates particles */
@@ -154,7 +155,7 @@ static void deformVerts(
 
                        if (em) {
                                /* In edit mode get directly from the edit mesh. */
-                               psmd->mesh_original = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, 0);
+                               psmd->mesh_original = BKE_mesh_from_bmesh_for_eval_nomain(em->bm, NULL);
                        }
                        else {
                                /* Otherwise get regular mesh. */
index 4af838df02ada247a56061e2baeb297f5c38d755..7b33df5bf860e95526b06c8a76cb5acc19123c16 100644 (file)
@@ -54,22 +54,20 @@ static void initData(ModifierData *md)
        smd->auxTarget  = NULL;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        ShrinkwrapModifierData *smd = (ShrinkwrapModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (smd->vgroup_name[0])
-               dataMask |= CD_MASK_MDEFORMVERT;
+       if (smd->vgroup_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 
        if ((smd->shrinkType == MOD_SHRINKWRAP_PROJECT) &&
            (smd->projAxis == MOD_SHRINKWRAP_PROJECT_OVER_NORMAL))
        {
-               dataMask |= CD_MASK_MVERT;
+               r_cddata_masks->vmask |= CD_MASK_MVERT;  /* XXX Really? These should always be present, always... */
        }
-
-       return dataMask;
 }
 
 static bool isDisabled(const struct Scene *UNUSED(scene), ModifierData *md, bool UNUSED(useRenderParams))
@@ -136,16 +134,17 @@ static void deformVertsEM(
 static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
 {
        ShrinkwrapModifierData *smd = (ShrinkwrapModifierData *)md;
-       CustomDataMask mask = 0;
+       CustomData_MeshMasks mask = {0};
 
        if (BKE_shrinkwrap_needs_normals(smd->shrinkType, smd->shrinkMode)) {
-               mask |= CD_MASK_NORMAL | CD_MASK_CUSTOMLOOPNORMAL;
+               mask.vmask |= CD_MASK_NORMAL;
+               mask.lmask |= CD_MASK_NORMAL | CD_MASK_CUSTOMLOOPNORMAL;
        }
 
        if (smd->target != NULL) {
                DEG_add_object_relation(ctx->node, smd->target, DEG_OB_COMP_TRANSFORM, "Shrinkwrap Modifier");
                DEG_add_object_relation(ctx->node, smd->target, DEG_OB_COMP_GEOMETRY, "Shrinkwrap Modifier");
-               DEG_add_customdata_mask(ctx->node, smd->target, mask);
+               DEG_add_customdata_mask(ctx->node, smd->target, &mask);
                if (smd->shrinkType == MOD_SHRINKWRAP_TARGET_PROJECT) {
                        DEG_add_special_eval_flag(ctx->node, &smd->target->id, DAG_EVAL_NEED_SHRINKWRAP_BOUNDARY);
                }
@@ -153,7 +152,7 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
        if (smd->auxTarget != NULL) {
                DEG_add_object_relation(ctx->node, smd->auxTarget, DEG_OB_COMP_TRANSFORM, "Shrinkwrap Modifier");
                DEG_add_object_relation(ctx->node, smd->auxTarget, DEG_OB_COMP_GEOMETRY, "Shrinkwrap Modifier");
-               DEG_add_customdata_mask(ctx->node, smd->auxTarget, mask);
+               DEG_add_customdata_mask(ctx->node, smd->auxTarget, &mask);
                if (smd->shrinkType == MOD_SHRINKWRAP_TARGET_PROJECT) {
                        DEG_add_special_eval_flag(ctx->node, &smd->auxTarget->id, DAG_EVAL_NEED_SHRINKWRAP_BOUNDARY);
                }
index f53f320d93f4c796ff627eaa6919a6b3885ada45..cc36cfbf9eb36f97de2bb72084e7c86f8a8842d4 100644 (file)
@@ -344,16 +344,14 @@ static void initData(ModifierData *md)
        smd->limit[1] =  1.0f;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        SimpleDeformModifierData *smd = (SimpleDeformModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (smd->vgroup_name[0])
-               dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (smd->vgroup_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static void foreachObjectLink(
index 75c485b879f2e8664a2de9214f9f1631ea020c2f..7ba7882d0d0984f859e1c587c4b0a5c92f58be03 100644 (file)
@@ -1875,7 +1875,7 @@ static Mesh *base_skin(Mesh *origmesh,
        if (!bm)
                return NULL;
 
-       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
        BM_mesh_free(bm);
 
        result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
@@ -1926,10 +1926,9 @@ static Mesh *applyModifier(ModifierData *md,
        return result;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob),
-                                       ModifierData *UNUSED(md))
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md), CustomData_MeshMasks *r_cddata_masks)
 {
-       return CD_MASK_MVERT_SKIN | CD_MASK_MDEFORMVERT;
+       r_cddata_masks->vmask |= CD_MASK_MVERT_SKIN | CD_MASK_MDEFORMVERT;
 }
 
 ModifierTypeInfo modifierType_Skin = {
index 5269d651c6de6ac35f3dd2c067f59f4e23b5ba54..905e8a18e1b9bd84ba6c85c2c50516052f57fdcf 100644 (file)
@@ -75,22 +75,20 @@ static void freeData(ModifierData *md)
        smokeModifier_free(smd);
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        SmokeModifierData *smd  = (SmokeModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        if (smd && (smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
                if (smd->flow->source == MOD_SMOKE_FLOW_SOURCE_MESH) {
                        /* vertex groups */
                        if (smd->flow->vgroup_density)
-                               dataMask |= CD_MASK_MDEFORMVERT;
+                               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
                        /* uv layer */
                        if (smd->flow->texture_type == MOD_SMOKE_FLOW_TEXTURE_MAP_UV)
-                               dataMask |= CD_MASK_MTFACE;
+                               r_cddata_masks->fmask |= CD_MASK_MTFACE;
                }
        }
-       return dataMask;
 }
 
 static Mesh *applyModifier(
index 65d93f0c608966f9fc11d06a7d01b7f2d416a5e0..2b9339842fa758f15fdc30158d4548ec57c69a44 100644 (file)
@@ -64,15 +64,14 @@ static bool isDisabled(const struct Scene *UNUSED(scene), ModifierData *md, bool
        return 0;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        SmoothModifierData *smd = (SmoothModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (smd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (smd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static void smoothModifier_do(
index 1425269b642580ff05b1a953ece950dda4e54cb9..e449403eb70d424e70f935e92c4a44c64961f550 100644 (file)
@@ -167,15 +167,14 @@ static void initData(ModifierData *md)
        smd->flag = MOD_SOLIDIFY_RIM;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        SolidifyModifierData *smd = (SolidifyModifierData *) md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (smd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (smd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 /* specific function for solidify - define locally */
index d1e5a3e31f01329acab2d8c54397253223985cae..554545077fabb321e31a47016154248945c5ae85 100644 (file)
@@ -1153,7 +1153,7 @@ static void surfacedeformModifier_do(
        if (target == NULL && smd->verts == NULL && ob == DEG_get_original_object(ob)) {
                /* Special case, binding happens outside of depsgraph evaluation, so we can build our own
                 * target mesh if needed. */
-               target = mesh_create_eval_final_view(ctx->depsgraph, DEG_get_input_scene(ctx->depsgraph), smd->target, 0);
+               target = mesh_create_eval_final_view(ctx->depsgraph, DEG_get_input_scene(ctx->depsgraph), smd->target, CD_MASK_BAREMESH);
                free_target = target != NULL;
        }
 #endif
index 94910fbe80e6a83ebd7bb8ea5b2bfac178b96712..1d28d28286babfd1d459f35d6dc204d890c463f5 100644 (file)
@@ -40,7 +40,7 @@ static Mesh *triangulate_mesh(Mesh *mesh, const int quad_method, const int ngon_
        BMesh *bm;
        int total_edges, i;
        MEdge *me;
-       CustomDataMask cddata_masks = CD_MASK_ORIGINDEX;
+       CustomData_MeshMasks cddata_masks = {.vmask=CD_MASK_ORIGINDEX, .emask=CD_MASK_ORIGINDEX, .pmask=CD_MASK_ORIGINDEX};
 
        bool keep_clnors = (flag & MOD_TRIANGULATE_KEEP_CUSTOMLOOP_NORMALS) != 0;
 
@@ -48,7 +48,7 @@ static Mesh *triangulate_mesh(Mesh *mesh, const int quad_method, const int ngon_
                BKE_mesh_calc_normals_split(mesh);
                /* We need that one to 'survive' to/from BMesh conversions. */
                CustomData_clear_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
-               cddata_masks |= CD_MASK_NORMAL;  /* TODO: once D4421 is in, only request CD_NORMAL on loop data... */
+               cddata_masks.lmask |= CD_MASK_NORMAL;
        }
 
        bm = BKE_mesh_to_bmesh_ex(
@@ -61,7 +61,7 @@ static Mesh *triangulate_mesh(Mesh *mesh, const int quad_method, const int ngon_
 
        BM_mesh_triangulate(bm, quad_method, ngon_method, false, NULL, NULL, NULL);
 
-       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, cddata_masks);
+       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, &cddata_masks);
        BM_mesh_free(bm);
 
 
index 2d6e995403e5d3e2821e8b6f99f54ae52d9401e7..245186bbc028ebced43f8787134fd701b12cabd7 100644 (file)
@@ -179,7 +179,7 @@ Mesh *MOD_deform_mesh_eval_get(
        }
        else if (ob->type == OB_MESH) {
                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 {
                        /* TODO(sybren): after modifier conversion of DM to Mesh is done, check whether
index 670cceb1ed57ac6b7674ddb6045b124e1d288068..26c7ec7ed13df695d3ada6628053ea4c3a29f406 100644 (file)
@@ -57,14 +57,10 @@ static void initData(ModifierData *md)
        umd->scalex = umd->scaley = 1.0f;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md), CustomData_MeshMasks *r_cddata_masks)
 {
-       CustomDataMask dataMask = 0;
-
        /* ask for UV coordinates */
-       dataMask |= CD_MLOOPUV;
-
-       return dataMask;
+       r_cddata_masks->lmask |= CD_MLOOPUV;
 }
 
 static void foreachObjectLink(
index 8bf950ff1752ee0e4c6b434f8c7a530ebac4f965..d4f17b742f12ce07f0d6fb907cfb54d2f5af5bd5 100644 (file)
@@ -62,16 +62,14 @@ static void initData(ModifierData *md)
        copy_v2_fl(umd->center, 0.5f);
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        UVWarpModifierData *umd = (UVWarpModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (umd->vgroup_name[0])
-               dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (umd->vgroup_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static void matrix_from_obj_pchan(float mat[4][4], Object *ob, const char *bonename)
index 9276b7df9b3750815a2486986bf379602b52f227..adda5df61ea68dc452e2415a3402da73b194d315 100644 (file)
@@ -69,19 +69,19 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
        twmd->curfalloff = curvemapping_copy(wmd->curfalloff);
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        WarpModifierData *wmd = (WarpModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (wmd->defgrp_name[0]) dataMask |= (CD_MASK_MDEFORMVERT);
-       dataMask |= (CD_MASK_MDEFORMVERT);
+       if (wmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 
        /* ask for UV coordinates if we need them */
-       if (wmd->texmapping == MOD_DISP_MAP_UV) dataMask |= (1 << CD_MTFACE);
-
-       return dataMask;
+       if (wmd->texmapping == MOD_DISP_MAP_UV) {
+               r_cddata_masks->fmask |= CD_MASK_MTFACE;
+       }
 }
 
 static bool dependsOnTime(ModifierData *md)
index dce7881992537db88a7a981f9c7f0619555459fa..80ac323c82f41c920132ea7b49f54ae1f5ac14b7 100644 (file)
@@ -119,21 +119,19 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
        }
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        WaveModifierData *wmd = (WaveModifierData *)md;
-       CustomDataMask dataMask = 0;
-
 
        /* ask for UV coordinates if we need them */
-       if (wmd->texture && wmd->texmapping == MOD_DISP_MAP_UV)
-               dataMask |= CD_MASK_MTFACE;
+       if (wmd->texture && wmd->texmapping == MOD_DISP_MAP_UV) {
+               r_cddata_masks->fmask |= CD_MASK_MTFACE;
+       }
 
        /* ask for vertexgroups if we need them */
-       if (wmd->defgrp_name[0])
-               dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
+       if (wmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static bool dependsOnNormals(ModifierData *md)
index 6321d1ac3cb3e009d61ce52c835bbeb691f99c1f..9eda072b7d303e990f093438608ccabb932d1cc5 100644 (file)
@@ -602,20 +602,19 @@ static void initData(ModifierData *md)
        wnmd->flag = 0;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        WeightedNormalModifierData *wnmd = (WeightedNormalModifierData *)md;
-       CustomDataMask dataMask = CD_MASK_CUSTOMLOOPNORMAL;
 
-       if (wnmd->defgrp_name[0]) {
-               dataMask |= CD_MASK_MDEFORMVERT;
+       r_cddata_masks->lmask = CD_MASK_CUSTOMLOOPNORMAL;
+
+       if (wnmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
        }
 
        if (wnmd->flag & MOD_WEIGHTEDNORMAL_FACE_INFLUENCE) {
-               dataMask |= CD_MASK_PROP_INT;
+               r_cddata_masks->pmask |= CD_MASK_PROP_INT;
        }
-
-       return dataMask;
 }
 
 static bool dependsOnNormals(ModifierData *UNUSED(md))
index 8723136078e8a49d97baa1f87d11d49f590c2322..32d058e56598a55dc5811994c591e87580de1738 100644 (file)
@@ -84,21 +84,19 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
        twmd->cmap_curve = curvemapping_copy(wmd->cmap_curve);
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        WeightVGEditModifierData *wmd = (WeightVGEditModifierData *) md;
-       CustomDataMask dataMask = 0;
 
        /* We need vertex groups! */
-       dataMask |= CD_MASK_MDEFORMVERT;
+       r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
 
        /* Ask for UV coordinates if we need them. */
-       if (wmd->mask_tex_mapping == MOD_DISP_MAP_UV)
-               dataMask |= CD_MASK_MTFACE;
+       if (wmd->mask_tex_mapping == MOD_DISP_MAP_UV) {
+               r_cddata_masks->fmask |= CD_MASK_MTFACE;
+       }
 
        /* No need to ask for CD_PREVIEW_MLOOPCOL... */
-
-       return dataMask;
 }
 
 static bool dependsOnTime(ModifierData *md)
index f54efc0e4ddef1cb716f7ce5988aa8745326f16e..495d235b40685e731d321e75017d795ce191fbfc 100644 (file)
@@ -119,21 +119,19 @@ static void initData(ModifierData *md)
        wmd->mask_tex_mapping       = MOD_DISP_MAP_LOCAL;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        WeightVGMixModifierData *wmd = (WeightVGMixModifierData *) md;
-       CustomDataMask dataMask = 0;
 
        /* We need vertex groups! */
-       dataMask |= CD_MASK_MDEFORMVERT;
+       r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
 
        /* Ask for UV coordinates if we need them. */
-       if (wmd->mask_tex_mapping == MOD_DISP_MAP_UV)
-               dataMask |= CD_MASK_MTFACE;
+       if (wmd->mask_tex_mapping == MOD_DISP_MAP_UV) {
+               r_cddata_masks->fmask |= CD_MASK_MTFACE;
+       }
 
        /* No need to ask for CD_PREVIEW_MLOOPCOL... */
-
-       return dataMask;
 }
 
 static bool dependsOnTime(ModifierData *md)
index 8df4b1df780820b187ad782ff593cf00a940af52..2e2e4fe963d3755f86886e6d023703cf48b046cb 100644 (file)
@@ -288,21 +288,19 @@ static void initData(ModifierData *md)
        wmd->max_dist             = 1.0f; /* vert arbitrary distance, but don't use 0 */
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        WeightVGProximityModifierData *wmd = (WeightVGProximityModifierData *) md;
-       CustomDataMask dataMask = 0;
 
        /* We need vertex groups! */
-       dataMask |= CD_MASK_MDEFORMVERT;
+       r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
 
        /* Ask for UV coordinates if we need them. */
-       if (wmd->mask_tex_mapping == MOD_DISP_MAP_UV)
-               dataMask |= CD_MASK_MTFACE;
+       if (wmd->mask_tex_mapping == MOD_DISP_MAP_UV) {
+               r_cddata_masks->fmask |= CD_MASK_MTFACE;
+       }
 
        /* No need to ask for CD_PREVIEW_MLOOPCOL... */
-
-       return dataMask;
 }
 
 static bool dependsOnTime(ModifierData *md)
index 39c932e8afa5c715dfe76009ce9f10fbb5454201..b91362334566c0c0a7d34831d3134183ba029d38 100644 (file)
@@ -39,16 +39,14 @@ static void initData(ModifierData *md)
        wmd->crease_weight = 1.0f;
 }
 
-static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
 {
        WireframeModifierData *wmd = (WireframeModifierData *)md;
-       CustomDataMask dataMask = 0;
 
        /* ask for vertexgroups if we need them */
-       if (wmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
-
-       return dataMask;
-
+       if (wmd->defgrp_name[0] != '\0') {
+               r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
+       }
 }
 
 static bool dependsOnNormals(ModifierData *UNUSED(md))
@@ -71,7 +69,7 @@ static Mesh *WireframeModifier_do(WireframeModifierData *wmd, Object *ob, Mesh *
                    .add_key_index = false,
                    .use_shapekey = false,
                    .active_shapekey = 0,
-                   .cd_mask_extra = CD_MASK_ORIGINDEX,
+                   .cd_mask_extra = {.vmask=CD_MASK_ORIGINDEX, .emask=CD_MASK_ORIGINDEX, .pmask=CD_MASK_ORIGINDEX},
                });
 
        BM_mesh_wireframe(
@@ -89,7 +87,7 @@ static Mesh *WireframeModifier_do(WireframeModifierData *wmd, Object *ob, Mesh *
               MAX2(ob->totcol - 1, 0),
               false);
 
-       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, 0);
+       result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
        BM_mesh_free(bm);
 
        result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
index 540c3aa0516a32e2b4f603389e67d9f2aaf06273..b371b482eceaa3823135fd94f1ccc15771a068ee 100644 (file)
@@ -941,7 +941,7 @@ static PyObject *bpy_bmesh_from_object(BPy_BMesh *self, PyObject *args, PyObject
        bool use_deform = true;
        bool use_cage   = false;
        bool use_fnorm  = true;
-       const int mask = CD_MASK_BMESH;
+       CustomData_MeshMasks data_masks = CD_MASK_BMESH;
 
        BPY_BM_CHECK_OBJ(self);
 
@@ -976,15 +976,15 @@ static PyObject *bpy_bmesh_from_object(BPy_BMesh *self, PyObject *args, PyObject
                                return NULL;
                        }
                        else {
-                               me_eval = mesh_create_eval_final_render(depsgraph, scene_eval, ob_eval, mask);
+                               me_eval = mesh_create_eval_final_render(depsgraph, scene_eval, ob_eval, &data_masks);
                        }
                }
                else {
                        if (use_cage) {
-                               me_eval = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, mask);
+                               me_eval = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, &data_masks);
                        }
                        else {
-                               me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, mask);
+                               me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &data_masks);
                        }
                }
        }
@@ -996,10 +996,10 @@ static PyObject *bpy_bmesh_from_object(BPy_BMesh *self, PyObject *args, PyObject
                        return NULL;
                }
                else if (use_render) {
-                       me_eval = mesh_create_eval_no_deform_render(depsgraph, scene_eval, ob, NULL, mask);
+                       me_eval = mesh_create_eval_no_deform_render(depsgraph, scene_eval, ob, NULL, &data_masks);
                }
                else {
-                       me_eval = mesh_create_eval_no_deform(depsgraph, scene_eval, ob, NULL, mask);
+                       me_eval = mesh_create_eval_no_deform(depsgraph, scene_eval, ob, NULL, &data_masks);
                }
        }
 
index d695e1b689d1dceab0e727fab3394d6ecaab7336..9b972f5fc91b69fadab4910efc1f6d4b652d6d36 100644 (file)
@@ -1045,7 +1045,7 @@ static Mesh *bvh_get_mesh(
 {
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
        /* we only need minimum mesh data for topology and vertex locations */
-       CustomDataMask mask = CD_MASK_BAREMESH;
+       CustomData_MeshMasks data_masks = CD_MASK_BAREMESH;
        const bool use_render = DEG_get_mode(depsgraph) == DAG_EVAL_RENDER;
        *r_free_mesh = false;
 
@@ -1059,15 +1059,15 @@ static Mesh *bvh_get_mesh(
                        }
                        else {
                                *r_free_mesh = true;
-                               return mesh_create_eval_final_render(depsgraph, scene, ob, mask);
+                               return mesh_create_eval_final_render(depsgraph, scene, ob, &data_masks);
                        }
                }
                else if (ob_eval != NULL) {
                        if (use_cage) {
-                               return mesh_get_eval_deform(depsgraph, scene, ob_eval, mask);  /* ob->derivedDeform */
+                               return mesh_get_eval_deform(depsgraph, scene, ob_eval, &data_masks);  /* ob->derivedDeform */
                        }
                        else {
-                               return mesh_get_eval_final(depsgraph, scene, ob_eval, mask);  /* ob->derivedFinal */
+                               return mesh_get_eval_final(depsgraph, scene, ob_eval, &data_masks);  /* ob->derivedFinal */
                        }
                }
                else {
@@ -1086,7 +1086,7 @@ static Mesh *bvh_get_mesh(
                        }
                        else {
                                *r_free_mesh = true;
-                               return mesh_create_eval_no_deform_render(depsgraph, scene, ob, NULL, mask);
+                               return mesh_create_eval_no_deform_render(depsgraph, scene, ob, NULL, &data_masks);
                        }
                }
                else {
@@ -1097,7 +1097,7 @@ static Mesh *bvh_get_mesh(
                        }
                        else {
                                *r_free_mesh = true;
-                               return mesh_create_eval_no_deform(depsgraph, scene, ob, NULL, mask);
+                               return mesh_create_eval_no_deform(depsgraph, scene, ob, NULL, &data_masks);
                        }
                }
        }
index 48bb0db24db0fee44edde50057128ed73f5bd22a..06d51fb161dd6ee8c2c21ea22b1c41af19aa0ade 100644 (file)
@@ -363,18 +363,21 @@ static void pointdensity_cache_object(PointDensity *pd,
 {
        float *data_color;
        int i;
-       CustomDataMask mask = CD_MASK_BAREMESH | CD_MASK_MTFACE | CD_MASK_MCOL;
        MVert *mvert = NULL, *mv;
        Mesh *mesh = ob->data;
 
+#if 0  /* UNUSED */
+       CustomData_MeshMasks mask = CD_MASK_BAREMESH;
+       mask.fmask |= CD_MASK_MTFACE | CD_MASK_MCOL;