Merge branch 'master' into blender2.8
authorCampbell Barton <ideasman42@gmail.com>
Sat, 12 May 2018 06:21:07 +0000 (08:21 +0200)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 12 May 2018 06:22:03 +0000 (08:22 +0200)
49 files changed:
1  2 
build_files/cmake/platform/platform_apple.cmake
source/blender/modifiers/intern/MOD_armature.c
source/blender/modifiers/intern/MOD_array.c
source/blender/modifiers/intern/MOD_build.c
source/blender/modifiers/intern/MOD_cast.c
source/blender/modifiers/intern/MOD_cloth.c
source/blender/modifiers/intern/MOD_collision.c
source/blender/modifiers/intern/MOD_correctivesmooth.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_fluidsim.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_meshcache.c
source/blender/modifiers/intern/MOD_meshdeform.c
source/blender/modifiers/intern/MOD_meshsequencecache.c
source/blender/modifiers/intern/MOD_mirror.c
source/blender/modifiers/intern/MOD_multires.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_remesh.c
source/blender/modifiers/intern/MOD_screw.c
source/blender/modifiers/intern/MOD_shapekey.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_softbody.c
source/blender/modifiers/intern/MOD_subsurf.c
source/blender/modifiers/intern/MOD_surface.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_util.h
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_weightvg_util.c
source/blender/modifiers/intern/MOD_weightvg_util.h
source/blender/modifiers/intern/MOD_weightvgedit.c
source/blender/modifiers/intern/MOD_weightvgproximity.c

@@@ -111,10 -121,12 +111,11 @@@ static void updateDepsgraph(ModifierDat
        DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Armature Modifier");
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         Mesh *mesh,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *mesh,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
        ArmatureModifierData *amd = (ArmatureModifierData *) md;
  
@@@ -159,28 -171,29 +160,29 @@@ static void deformMatricesEM
          float (*defMats)[3][3], int numVerts)
  {
        ArmatureModifierData *amd = (ArmatureModifierData *) md;
 -      DerivedMesh *dm = derivedData;
 +      Mesh *mesh_src = get_mesh(ctx->object, em, mesh, NULL, false, false);
  
 -      if (!derivedData) dm = CDDM_from_editbmesh(em, false, false);
 -
 -      armature_deform_verts(amd->object, ob, dm, vertexCos, defMats, numVerts,
 +      armature_deform_verts(amd->object, ctx->object, mesh_src, vertexCos, defMats, numVerts,
                              amd->deformflag, NULL, amd->defgrp_name);
  
 -      if (!derivedData) dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
- static void deformMatrices(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
-                            float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
+ static void deformMatrices(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
+         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
  {
        ArmatureModifierData *amd = (ArmatureModifierData *) md;
 -      DerivedMesh *dm = derivedData;
 +      Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
 -      if (!derivedData) dm = CDDM_from_mesh((Mesh *)ob->data);
 -
 -      armature_deform_verts(amd->object, ob, dm, vertexCos, defMats, numVerts,
 +      armature_deform_verts(amd->object, ctx->object, mesh_src, vertexCos, defMats, numVerts,
                              amd->deformflag, NULL, amd->defgrp_name);
  
 -      if (!derivedData) dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
  ModifierTypeInfo modifierType_Armature = {
@@@ -742,11 -791,13 +742,12 @@@ static Mesh *arrayModifier_doArray
  }
  
  
- static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                            Mesh *mesh)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *dm,
 -        ModifierApplyFlag flag)
++static Mesh *applyModifier(
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *mesh)
  {
        ArrayModifierData *amd = (ArrayModifierData *) md;
 -      return arrayModifier_doArray(amd, md->scene, ob, dm, flag);
 +      return arrayModifier_doArray(amd, ctx, mesh);
  }
  
  
@@@ -65,10 -66,13 +65,11 @@@ static bool dependsOnTime(ModifierData 
        return true;
  }
  
- static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                            struct Mesh *mesh)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *UNUSED(ob),
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++static Mesh *applyModifier(
++        ModifierData *md, const ModifierEvalContext *ctx,
++        struct Mesh *mesh)
  {
 -      DerivedMesh *dm = derivedData;
 -      DerivedMesh *result;
 +      Mesh *result;
        BuildModifierData *bmd = (BuildModifierData *) md;
        int i, j, k;
        int numFaces_dst, numEdges_dst, numLoops_dst = 0;
@@@ -422,26 -434,27 +422,27 @@@ static void cuboid_do
        }
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         Mesh *mesh,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *mesh,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
 -      DerivedMesh *dm = NULL;
        CastModifierData *cmd = (CastModifierData *)md;
 +      Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
 -      dm = get_dm(ob, NULL, derivedData, NULL, false, false);
 +      BLI_assert(mesh_src->totvert == numVerts);
  
        if (cmd->type == MOD_CAST_TYPE_CUBOID) {
 -              cuboid_do(cmd, ob, dm, vertexCos, numVerts);
 +              cuboid_do(cmd, ctx->object, mesh_src, vertexCos, numVerts);
        }
        else { /* MOD_CAST_TYPE_SPHERE or MOD_CAST_TYPE_CYLINDER */
 -              sphere_do(cmd, ob, dm, vertexCos, numVerts);
 +              sphere_do(cmd, ctx->object, mesh_src, vertexCos, numVerts);
        }
  
 -      if (dm != derivedData)
 -              dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
  static void deformVertsEM(
@@@ -69,9 -72,9 +69,10 @@@ static void initData(ModifierData *md
        cloth_init(clmd);
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         DerivedMesh *derivedData, float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData, float (*vertexCos)[3],
 -        int numVerts, ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *derivedData, float (*vertexCos)[3],
++        int numVerts)
  {
        DerivedMesh *dm;
        ClothModifierData *clmd = (ClothModifierData *) md;
@@@ -95,10 -95,12 +95,11 @@@ static bool dependsOnTime(ModifierData 
        return true;
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         DerivedMesh *derivedData,
-                         float (*vertexCos)[3],
-                         int UNUSED(numVerts))
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         DerivedMesh *derivedData,
+         float (*vertexCos)[3],
 -        int UNUSED(numVerts),
 -        ModifierApplyFlag UNUSED(flag))
++        int UNUSED(numVerts))
  {
        CollisionModifierData *collmd = (CollisionModifierData *) md;
        DerivedMesh *dm = NULL;
@@@ -79,11 -77,13 +79,12 @@@ static CustomDataMask requiredDataMask(
        return dataMask;
  }
  
- static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                            Mesh *meshData)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++static Mesh *applyModifier(
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *meshData)
  {
        DecimateModifierData *dmd = (DecimateModifierData *) md;
 -      DerivedMesh *dm = derivedData, *result = NULL;
 +      Mesh *mesh = meshData, *result = NULL;
        BMesh *bm;
        bool calc_face_normal;
        float *vweights = NULL;
@@@ -99,8 -97,16 +99,9 @@@ static CustomDataMask requiredDataMask(
        return dataMask;
  }
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *dm)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *dm,
 -        ModifierApplyFlag flag)
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *dm)
  {
        DynamicPaintModifierData *pmd = (DynamicPaintModifierData *) md;
  
@@@ -153,10 -181,14 +155,11 @@@ static void foreachIDLink
                        }
                }
        }
 -      if (pmd->brush) {
 -              walk(userData, ob, (ID **)&pmd->brush->mat, IDWALK_CB_USER);
 -      }
  }
  
- static void foreachTexLink(ModifierData *UNUSED(md), Object *UNUSED(ob),
-                            TexWalkFunc UNUSED(walk), void *UNUSED(userData))
+ static void foreachTexLink(
+         ModifierData *UNUSED(md), Object *UNUSED(ob),
+         TexWalkFunc UNUSED(walk), void *UNUSED(userData))
  {
        //walk(userData, ob, md, ""); /* re-enable when possible */
  }
@@@ -124,11 -112,11 +124,12 @@@ static void initData(ModifierData *md
        emd->flags = MOD_EDGESPLIT_FROMANGLE | MOD_EDGESPLIT_FROMFLAG;
  }
  
- static Mesh *applyModifier(ModifierData *md,
-                            const ModifierEvalContext *ctx,
-                            Mesh *mesh)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *UNUSED(ob), DerivedMesh *dm,
 -        ModifierApplyFlag UNUSED(flag))
++static Mesh *applyModifier(
++        ModifierData *md,
++        const ModifierEvalContext *ctx,
++        Mesh *mesh)
  {
 -      DerivedMesh *result;
 +      Mesh *result;
        EdgeSplitModifierData *emd = (EdgeSplitModifierData *) md;
  
        if (!(emd->flags & (MOD_EDGESPLIT_FROMANGLE | MOD_EDGESPLIT_FROMFLAG)))
@@@ -995,8 -995,10 +996,9 @@@ static ParticleSystemModifierData *find
        }
        return psmd;
  }
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *derivedData)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *derivedData)
  {
        DerivedMesh *dm = derivedData;
        ExplodeModifierData *emd = (ExplodeModifierData *) md;
@@@ -85,8 -85,10 +85,9 @@@ static void copyData(const ModifierDat
  
  
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *dm)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *dm,
 -        ModifierApplyFlag flag)
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *dm)
  {
        FluidsimModifierData *fluidmd = (FluidsimModifierData *) md;
        DerivedMesh *result = NULL;
@@@ -251,8 -264,9 +251,9 @@@ static void hook_co_apply(struct HookDa
        }
  }
  
- static void deformVerts_do(HookModifierData *hmd, Object *ob, Mesh *mesh, 
-                            float (*vertexCos)[3], int numVerts)
+ static void deformVerts_do(
 -        HookModifierData *hmd, Object *ob, DerivedMesh *dm,
++        HookModifierData *hmd, Object *ob, Mesh *mesh,
+         float (*vertexCos)[3], int numVerts)
  {
        bPoseChannel *pchan = BKE_pose_channel_find_name(hmd->object->pose, hmd->subtarget);
        float dmat[4][4];
        }
  }
  
- static void deformVerts(struct ModifierData *md, const struct ModifierEvalContext *ctx, struct Mesh *mesh, 
-                         float (*vertexCos)[3], int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
 -        float (*vertexCos)[3], int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        struct ModifierData *md, const struct ModifierEvalContext *ctx, struct Mesh *mesh,
++        float (*vertexCos)[3], int numVerts)
  {
 -      HookModifierData *hmd = (HookModifierData *) md;
 -      DerivedMesh *dm = derivedData;
 -      /* We need a valid dm for meshes when a vgroup is set... */
 -      if (!dm && ob->type == OB_MESH && hmd->name[0] != '\0')
 -              dm = get_dm(ob, NULL, dm, NULL, false, false);
 +      HookModifierData *hmd = (HookModifierData *)md;
 +      Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
 -      deformVerts_do(hmd, ob, dm, vertexCos, numVerts);
 +      deformVerts_do(hmd, ctx->object, mesh_src, vertexCos, numVerts);
  
 -      if (derivedData != dm)
 -              dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
- static void deformVertsEM(struct ModifierData *md, const struct ModifierEvalContext *ctx,
-                           struct BMEditMesh *editData,
-                           struct Mesh *mesh, float (*vertexCos)[3], int numVerts)
+ static void deformVertsEM(
 -        ModifierData *md, Object *ob, struct BMEditMesh *editData,
 -        DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
++        struct ModifierData *md, const struct ModifierEvalContext *ctx,
++        struct BMEditMesh *editData,
++        struct Mesh *mesh, float (*vertexCos)[3], int numVerts)
  {
 -      HookModifierData *hmd = (HookModifierData *) md;
 -      DerivedMesh *dm = derivedData;
 -      /* We need a valid dm for meshes when a vgroup is set... */
 -      if (!dm && ob->type == OB_MESH && hmd->name[0] != '\0')
 -              dm = get_dm(ob, editData, dm, NULL, false, false);
 +      HookModifierData *hmd = (HookModifierData *)md;
 +      Mesh *mesh_src = get_mesh(ctx->object, editData, mesh, NULL, false, false);
  
 -      deformVerts_do(hmd, ob, dm, vertexCos, numVerts);
 +      deformVerts_do(hmd, ctx->object, mesh_src, vertexCos, numVerts);
  
 -      if (derivedData != dm)
 -              dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
 -
  ModifierTypeInfo modifierType_Hook = {
        /* name */              "Hook",
        /* structName */        "HookModifierData",
@@@ -514,8 -509,9 +514,9 @@@ static bool isValidVertexGroup(Laplacia
        return  (dvert != NULL);
  }
  
- static void initSystem(LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh,
-                        float (*vertexCos)[3], int numVerts)
+ static void initSystem(
 -        LaplacianDeformModifierData *lmd, Object *ob, DerivedMesh *dm,
++        LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh,
+         float (*vertexCos)[3], int numVerts)
  {
        int i;
        int defgrp_index;
@@@ -729,14 -725,15 +730,15 @@@ static CustomDataMask requiredDataMask(
        return dataMask;
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
-                         float (*vertexCos)[3], int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
 -        float (*vertexCos)[3], int numVerts, ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
++        float (*vertexCos)[3], int numVerts)
  {
 -      DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, false, false);
 +      Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
 -      LaplacianDeformModifier_do((LaplacianDeformModifierData *)md, ob, dm, vertexCos, numVerts);
 -      if (dm != derivedData) {
 -              dm->release(dm);
 +      LaplacianDeformModifier_do((LaplacianDeformModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
        }
  }
  
@@@ -498,10 -495,11 +498,11 @@@ static CustomDataMask required_data_mas
        return dataMask;
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
-                         float (*vertexCos)[3], int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
 -        float (*vertexCos)[3], int numVerts, ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
++        float (*vertexCos)[3], int numVerts)
  {
 -      DerivedMesh *dm;
 +      Mesh *mesh_src;
  
        if (numVerts == 0)
                return;
@@@ -93,34 -103,33 +93,35 @@@ static void updateDepsgraph(ModifierDat
        DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Lattice Modifier");
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         struct Mesh *mesh,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx,
++        struct Mesh *mesh,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
        LatticeModifierData *lmd = (LatticeModifierData *) md;
 -
 +      struct Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
        modifier_vgroup_cache(md, vertexCos); /* if next modifier needs original vertices */
 -      
 -      lattice_deform_verts(lmd->object, ob, derivedData,
 +
 +      lattice_deform_verts(lmd->object, ctx->object, mesh_src,
                             vertexCos, numVerts, lmd->name, lmd->strength);
 -}
 +
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }}
  
  static void deformVertsEM(
 -        ModifierData *md, Object *ob, struct BMEditMesh *em,
 -        DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
 +        ModifierData *md, const ModifierEvalContext *ctx, struct BMEditMesh *em,
 +        struct Mesh *mesh, float (*vertexCos)[3], int numVerts)
  {
 -      DerivedMesh *dm = derivedData;
 +      struct Mesh *mesh_src = get_mesh(ctx->object, em, mesh, NULL, false, false);
  
 -      if (!derivedData) dm = CDDM_from_editbmesh(em, false, false);
 +      deformVerts(md, ctx, mesh_src, vertexCos, numVerts);
  
 -      deformVerts(md, ob, dm, vertexCos, numVerts, 0);
 -
 -      if (!derivedData) dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
  
@@@ -263,10 -263,12 +263,11 @@@ static void meshcache_do
        }
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         DerivedMesh *derivedData,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         DerivedMesh *derivedData,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
        MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
  
@@@ -408,38 -419,39 +408,40 @@@ static void meshdeformModifier_do
        /* release cage derivedmesh */
        MEM_freeN(dco);
        MEM_freeN(cagecos);
 -      cagedm->release(cagedm);
 +      if (free_cagemesh) BKE_id_free(NULL, cagemesh);
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         Mesh *mesh,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *mesh,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
 -      DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, false, false);
 +      Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
        modifier_vgroup_cache(md, vertexCos); /* if next modifier needs original vertices */
  
 -      meshdeformModifier_do(md, ob, dm, vertexCos, numVerts);
 +      meshdeformModifier_do(md, ctx->object, mesh, vertexCos, numVerts);
  
 -      if (dm && dm != derivedData)
 -              dm->release(dm);
 +      if (mesh_src && mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
- static void deformVertsEM(ModifierData *md, const ModifierEvalContext *ctx,
-                           struct BMEditMesh *UNUSED(editData),
-                           Mesh *mesh,
-                           float (*vertexCos)[3],
-                           int numVerts)
+ static void deformVertsEM(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         struct BMEditMesh *UNUSED(editData),
 -        DerivedMesh *derivedData,
++        Mesh *mesh,
+         float (*vertexCos)[3],
+         int numVerts)
  {
 -      DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, false, false);
 +      Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
 -      meshdeformModifier_do(md, ob, dm, vertexCos, numVerts);
 +      meshdeformModifier_do(md, ctx->object, mesh, vertexCos, numVerts);
  
 -      if (dm && dm != derivedData)
 -              dm->release(dm);
 +      if (mesh_src && mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
  #define MESHDEFORM_MIN_INFLUENCE 0.00001f
@@@ -87,8 -88,10 +87,9 @@@ static bool isDisabled(ModifierData *md
        return (mcmd->cache_file == NULL) || (mcmd->object_path[0] == '\0');
  }
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *dm)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *dm,
 -        ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *dm)
  {
  #ifdef WITH_ALEMBIC
        MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
@@@ -78,10 -88,11 +78,11 @@@ static void updateDepsgraph(ModifierDat
        DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Mirror Modifier");
  }
  
- static Mesh *doMirrorOnAxis(MirrorModifierData *mmd,
-                             Object *ob,
-                             const Mesh *mesh,
-                             int axis)
 -static DerivedMesh *doMirrorOnAxis(
++static Mesh *doMirrorOnAxis(
+         MirrorModifierData *mmd,
+         Object *ob,
 -        DerivedMesh *dm,
++        const Mesh *mesh,
+         int axis)
  {
        const float tolerance_sq = mmd->tolerance * mmd->tolerance;
        const bool do_vtargetmap = (mmd->flag & MOD_MIR_NO_MERGE) == 0;
        return result;
  }
  
- static Mesh *mirrorModifier__doMirror(MirrorModifierData *mmd,
-                                       Object *ob, Mesh *mesh)
 -static DerivedMesh *mirrorModifier__doMirror(
++static Mesh *mirrorModifier__doMirror(
+         MirrorModifierData *mmd,
 -        Object *ob, DerivedMesh *dm)
++        Object *ob, Mesh *mesh)
  {
 -      DerivedMesh *result = dm;
 +      Mesh *result = mesh;
  
        /* check which axes have been toggled and mirror accordingly */
        if (mmd->flag & MOD_MIR_AXIS_X) {
        return result;
  }
  
- static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                            Mesh *mesh)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++static Mesh *applyModifier(
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *mesh)
  {
 -      DerivedMesh *result;
 +      Mesh *result;
        MirrorModifierData *mmd = (MirrorModifierData *) md;
  
 -      result = mirrorModifier__doMirror(mmd, ob, derivedData);
 +      result = mirrorModifier__doMirror(mmd, ctx->object, mesh);
  
 -      if (result != derivedData)
 -              result->dirty |= DM_DIRTY_NORMALS;
 -      
 +      if (result != mesh) {
 +              result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
 +      }
        return result;
  }
  
@@@ -58,8 -58,9 +58,9 @@@ static void initData(ModifierData *md
        mmd->totlvl = 0;
  }
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *dm)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob, DerivedMesh *dm,
 -        ModifierApplyFlag flag)
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *dm)
  {
        MultiresModifierData *mmd = (MultiresModifierData *)md;
        DerivedMesh *result;
@@@ -553,8 -556,10 +555,9 @@@ static DerivedMesh *doOcean
  }
  #endif /* WITH_OCEANSIM */
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *derivedData)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *derivedData)
  {
        DerivedMesh *result;
  
@@@ -194,8 -210,10 +195,9 @@@ static void store_float_in_vcol(MLoopCo
        vcol->a = 1.0f;
  }
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *derivedData)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *derivedData)
  {
        DerivedMesh *dm = derivedData, *result;
        ParticleInstanceModifierData *pimd = (ParticleInstanceModifierData *) md;
@@@ -99,10 -99,12 +99,11 @@@ static CustomDataMask requiredDataMask(
  }
  
  /* saves the current emitter state for a particle system and calculates particles */
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         DerivedMesh *derivedData,
-                         float (*vertexCos)[3],
-                         int UNUSED(numVerts))
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         DerivedMesh *derivedData,
+         float (*vertexCos)[3],
 -        int UNUSED(numVerts),
 -        ModifierApplyFlag flag)
++        int UNUSED(numVerts))
  {
        DerivedMesh *dm = derivedData;
        ParticleSystemModifierData *psmd = (ParticleSystemModifierData *) md;
@@@ -133,9 -133,11 +133,10 @@@ static void dualcon_add_quad(void *outp
        output->curface++;
  }
  
- static DerivedMesh *applyModifier(ModifierData *md,
-                                   const ModifierEvalContext *UNUSED(ctx),
-                                   DerivedMesh *dm)
+ static DerivedMesh *applyModifier(
+         ModifierData *md,
 -        Object *UNUSED(ob),
 -        DerivedMesh *dm,
 -        ModifierApplyFlag UNUSED(flag))
++        const ModifierEvalContext *UNUSED(ctx),
++        DerivedMesh *dm)
  {
        RemeshModifierData *rmd;
        DualConOutput *output;
  
  #else /* !WITH_MOD_REMESH */
  
- static DerivedMesh *applyModifier(ModifierData *UNUSED(md),
-                                   const ModifierEvalContext *UNUSED(ctx),
-                                   DerivedMesh *derivedData)
+ static DerivedMesh *applyModifier(
 -        ModifierData *UNUSED(md), Object *UNUSED(ob),
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++        ModifierData *UNUSED(md),
++        const ModifierEvalContext *UNUSED(ctx),
++        DerivedMesh *derivedData)
  {
        return derivedData;
  }
@@@ -177,13 -176,15 +177,14 @@@ static void initData(ModifierData *md
        ltmd->merge_dist = 0.01f;
  }
  
- static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                            Mesh *meshData)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag flag)
++static Mesh *applyModifier(
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *meshData)
  {
 -      DerivedMesh *dm = derivedData;
 -      DerivedMesh *result;
 +      Mesh *mesh = meshData;
 +      Mesh *result;
        ScrewModifierData *ltmd = (ScrewModifierData *) md;
 -      const bool use_render_params = (flag & MOD_APPLY_RENDER) != 0;
 +      const bool use_render_params = (ctx->flag & MOD_APPLY_RENDER) != 0;
        
        int *origindex;
        int mpoly_index = 0;
  
  #include "MOD_modifiertypes.h"
  
- static void deformVerts(ModifierData *UNUSED(md), const ModifierEvalContext *ctx,
-                         DerivedMesh *UNUSED(derivedData),
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *UNUSED(md), Object *ob,
++        ModifierData *UNUSED(md), const ModifierEvalContext *ctx,
+         DerivedMesh *UNUSED(derivedData),
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
 -      Key *key = BKE_key_from_object(ob);
 +      Key *key = BKE_key_from_object(ctx->object);
  
        if (key && key->block.first) {
                int deformedVerts_tot;
        }
  }
  
- static void deformMatrices(ModifierData *md, const ModifierEvalContext *ctx, DerivedMesh *derivedData,
-                            float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
+ static void deformMatrices(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx, DerivedMesh *derivedData,
+         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
  {
 -      Key *key = BKE_key_from_object(ob);
 -      KeyBlock *kb = BKE_keyblock_from_object(ob);
 +      Key *key = BKE_key_from_object(ctx->object);
 +      KeyBlock *kb = BKE_keyblock_from_object(ctx->object);
        float scale[3][3];
  
        (void)vertexCos; /* unused */
                        copy_m3_m3(defMats[a], scale);
        }
  
 -      deformVerts(md, ob, derivedData, vertexCos, numVerts, 0);
 +      deformVerts(md, ctx, derivedData, vertexCos, numVerts);
  }
  
- static void deformVertsEM(ModifierData *md, const ModifierEvalContext *ctx,
-                           struct BMEditMesh *UNUSED(editData),
-                           DerivedMesh *derivedData,
-                           float (*vertexCos)[3],
-                           int numVerts)
+ static void deformVertsEM(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         struct BMEditMesh *UNUSED(editData),
+         DerivedMesh *derivedData,
+         float (*vertexCos)[3],
+         int numVerts)
  {
 -      Key *key = BKE_key_from_object(ob);
 +      Key *key = BKE_key_from_object(ctx->object);
  
        if (key && key->type == KEY_RELATIVE)
 -              deformVerts(md, ob, derivedData, vertexCos, numVerts, 0);
 +              deformVerts(md, ctx, derivedData, vertexCos, numVerts);
  }
  
- static void deformMatricesEM(ModifierData *UNUSED(md), const ModifierEvalContext *ctx,
-                              struct BMEditMesh *UNUSED(editData),
-                              DerivedMesh *UNUSED(derivedData),
-                              float (*vertexCos)[3],
-                              float (*defMats)[3][3],
-                              int numVerts)
+ static void deformMatricesEM(
 -        ModifierData *UNUSED(md), Object *ob,
++        ModifierData *UNUSED(md), const ModifierEvalContext *ctx,
+         struct BMEditMesh *UNUSED(editData),
+         DerivedMesh *UNUSED(derivedData),
+         float (*vertexCos)[3],
+         float (*defMats)[3][3],
+         int numVerts)
  {
 -      Key *key = BKE_key_from_object(ob);
 -      KeyBlock *kb = BKE_keyblock_from_object(ob);
 +      Key *key = BKE_key_from_object(ctx->object);
 +      KeyBlock *kb = BKE_keyblock_from_object(ctx->object);
        float scale[3][3];
  
        (void)vertexCos; /* unused */
@@@ -97,39 -96,57 +97,41 @@@ static void foreachObjectLink(ModifierD
        walk(userData, ob, &smd->auxTarget, IDWALK_CB_NOP);
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         Mesh *mesh,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *mesh,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag flag)
++        int numVerts)
  {
 -      DerivedMesh *dm = derivedData;
 -      CustomDataMask dataMask = requiredDataMask(ob, md);
 -      bool forRender = (flag & MOD_APPLY_RENDER) != 0;
 +      Mesh *mesh_src = mesh;
  
 -      /* ensure we get a CDDM with applied vertex coords */
 -      if (dataMask) {
 -              dm = get_cddm(ob, NULL, dm, vertexCos, dependsOnNormals(md));
 +      if (mesh_src == NULL) {
 +              mesh_src = ctx->object->data;
        }
  
 -      shrinkwrapModifier_deform((ShrinkwrapModifierData *)md, ob, dm, vertexCos, numVerts, forRender);
 +      BLI_assert(mesh_src->totvert == numVerts);
  
 -      if (dm != derivedData)
 -              dm->release(dm);
 +      shrinkwrapModifier_deform((ShrinkwrapModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts, ctx);
  }
  
- static void deformVertsEM(ModifierData *md, const ModifierEvalContext *ctx,
-                           struct BMEditMesh *editData, Mesh *mesh,
-                           float (*vertexCos)[3], int numVerts)
+ static void deformVertsEM(
 -        ModifierData *md, Object *ob, struct BMEditMesh *editData, DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx,
++        struct BMEditMesh *editData, Mesh *mesh,
+         float (*vertexCos)[3], int numVerts)
  {
 -      DerivedMesh *dm = derivedData;
 -      CustomDataMask dataMask = requiredDataMask(ob, md);
 +      Mesh *mesh_src = mesh;
  
 -      /* ensure we get a CDDM with applied vertex coords */
 -      if (dataMask) {
 -              dm = get_cddm(ob, editData, dm, vertexCos, dependsOnNormals(md));
 +      if (mesh_src == NULL) {
 +              mesh_src = BKE_bmesh_to_mesh_nomain(editData->bm, &(struct BMeshToMeshParams){0});
        }
  
 -      shrinkwrapModifier_deform((ShrinkwrapModifierData *)md, ob, dm, vertexCos, numVerts, false);
 -
 -      if (dm != derivedData)
 -              dm->release(dm);
 -}
 -
 -static void updateDepgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
 -{
 -      ShrinkwrapModifierData *smd = (ShrinkwrapModifierData *) md;
 +      BLI_assert(mesh_src->totvert == numVerts);
  
 -      if (smd->target)
 -              dag_add_relation(ctx->forest, dag_get_node(ctx->forest, smd->target), ctx->obNode,
 -                               DAG_RL_OB_DATA | DAG_RL_DATA_DATA, "Shrinkwrap Modifier");
 +      shrinkwrapModifier_deform((ShrinkwrapModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts, ctx);
  
 -      if (smd->auxTarget)
 -              dag_add_relation(ctx->forest, dag_get_node(ctx->forest, smd->auxTarget), ctx->obNode,
 -                               DAG_RL_OB_DATA | DAG_RL_DATA_DATA, "Shrinkwrap Modifier");
 +      if (!mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
  static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
@@@ -186,10 -183,12 +186,11 @@@ static void simpleDeform_bend(const flo
  
  
  /* simple deform modifier */
- static void SimpleDeformModifier_do(SimpleDeformModifierData *smd, struct Object *ob, struct Mesh *mesh,
-                                     float (*vertexCos)[3], int numVerts)
+ static void SimpleDeformModifier_do(
 -        SimpleDeformModifierData *smd, struct Object *ob, struct DerivedMesh *dm,
++        SimpleDeformModifierData *smd, struct Object *ob, struct Mesh *mesh,
+         float (*vertexCos)[3], int numVerts)
  {
        const float base_limit[2] = {0.0f, 0.0f};
 -
        int i;
        float smd_limit[2], smd_factor;
        SpaceTransform *transf = NULL, tmp_transf;
@@@ -379,33 -386,46 +380,35 @@@ static void updateDepsgraph(ModifierDat
        }
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         struct Mesh *mesh,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
++        ModifierData *md, const ModifierEvalContext *ctx,
++        struct Mesh *mesh,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
 -      DerivedMesh *dm = derivedData;
 -      CustomDataMask dataMask = requiredDataMask(ob, md);
 -
 -      /* we implement requiredDataMask but thats not really useful since
 -       * mesh_calc_modifiers pass a NULL derivedData */
 -      if (dataMask)
 -              dm = get_dm(ob, NULL, dm, NULL, false, false);
 +      Mesh *mesh_src = get_mesh(ctx->object, NULL, mesh, NULL, false, false);
  
 -      SimpleDeformModifier_do((SimpleDeformModifierData *)md, ob, dm, vertexCos, numVerts);
 +      SimpleDeformModifier_do((SimpleDeformModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts);
  
 -      if (dm != derivedData)
 -              dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
- static void deformVertsEM(ModifierData *md, const ModifierEvalContext *ctx,
-                           struct BMEditMesh *editData,
-                           struct Mesh *mesh,
-                           float (*vertexCos)[3],
-                           int numVerts)
+ static void deformVertsEM(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         struct BMEditMesh *editData,
 -        DerivedMesh *derivedData,
++        struct Mesh *mesh,
+         float (*vertexCos)[3],
+         int numVerts)
  {
 -      DerivedMesh *dm = derivedData;
 -      CustomDataMask dataMask = requiredDataMask(ob, md);
 -
 -      /* we implement requiredDataMask but thats not really useful since
 -       * mesh_calc_modifiers pass a NULL derivedData */
 -      if (dataMask)
 -              dm = get_dm(ob, editData, dm, NULL, false, false);
 +      Mesh *mesh_src = get_mesh(ctx->object, editData, mesh, NULL, false, false);
  
 -      SimpleDeformModifier_do((SimpleDeformModifierData *)md, ob, dm, vertexCos, numVerts);
 +      SimpleDeformModifier_do((SimpleDeformModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts);
  
 -      if (dm != derivedData)
 -              dm->release(dm);
 +      if (mesh_src != mesh) {
 +              BKE_id_free(NULL, mesh_src);
 +      }
  }
  
  
@@@ -102,8 -101,10 +102,9 @@@ static CustomDataMask requiredDataMask(
        return dataMask;
  }
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *dm)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *dm,
 -        ModifierApplyFlag flag)
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *dm)
  {
        SmokeModifierData *smd = (SmokeModifierData *) md;
  
@@@ -209,19 -206,17 +209,20 @@@ static void smoothModifier_do
        MEM_freeN(uctmp);
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
-                         float (*vertexCos)[3], int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
 -        float (*vertexCos)[3], int numVerts, ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
++        float (*vertexCos)[3], int numVerts)
  {
 -      DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, false, false);
 +      Mesh *mesh_src = mesh;
  
 -      smoothModifier_do((SmoothModifierData *)md, ob, dm,
 -                        vertexCos, numVerts);
 +      if (mesh_src == NULL) {
 +              mesh_src = ctx->object->data;
 +      }
  
 -      if (dm != derivedData)
 -              dm->release(dm);
 +      BLI_assert(mesh_src->totvert == numVerts);
 +
 +      smoothModifier_do((SmoothModifierData *)md, ctx->object, mesh_src,
 +                        vertexCos, numVerts);
  }
  
  static void deformVertsEM(
  
  #include "MOD_modifiertypes.h"
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         DerivedMesh *UNUSED(derivedData),
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         DerivedMesh *UNUSED(derivedData),
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
 -      sbObjectStep(md->scene, ob, (float)md->scene->r.cfra, vertexCos, numVerts);
 +      sbObjectStep(ctx->depsgraph, md->scene, ctx->object, (float)md->scene->r.cfra, vertexCos, numVerts);
  }
  
  static bool dependsOnTime(ModifierData *UNUSED(md))
@@@ -99,8 -97,10 +99,9 @@@ static bool isDisabled(ModifierData *md
        return get_render_subsurf_level(&md->scene->r, levels, useRenderParams != 0) == 0;
  }
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *derivedData)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag flag)
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *derivedData)
  {
        SubsurfModifierData *smd = (SubsurfModifierData *) md;
        SubsurfFlags subsurf_flags = 0;
@@@ -82,10 -82,12 +82,11 @@@ static bool dependsOnTime(ModifierData 
        return true;
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         DerivedMesh *derivedData,
-                         float (*vertexCos)[3],
-                         int UNUSED(numVerts))
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         DerivedMesh *derivedData,
+         float (*vertexCos)[3],
 -        int UNUSED(numVerts),
 -        ModifierApplyFlag UNUSED(flag))
++        int UNUSED(numVerts))
  {
        SurfaceModifierData *surmd = (SurfaceModifierData *) md;
        
@@@ -908,15 -916,16 +909,16 @@@ static void bindVert
        freeBindData(bwdata);
  }
  
- static bool surfacedeformBind(SurfaceDeformModifierData *smd, float (*vertexCos)[3],
-                               unsigned int numverts, unsigned int tnumpoly, unsigned int tnumverts, Mesh *target)
+ static bool surfacedeformBind(
+         SurfaceDeformModifierData *smd, float (*vertexCos)[3],
 -        unsigned int numverts, unsigned int tnumpoly, unsigned int tnumverts, DerivedMesh *tdm)
++        unsigned int numverts, unsigned int tnumpoly, unsigned int tnumverts, Mesh *target)
  {
        BVHTreeFromMesh treeData = {NULL};
 -      const MVert *mvert = tdm->getVertArray(tdm);
 -      const MPoly *mpoly = tdm->getPolyArray(tdm);
 -      const MEdge *medge = tdm->getEdgeArray(tdm);
 -      const MLoop *mloop = tdm->getLoopArray(tdm);
 -      unsigned int tnumedges = tdm->getNumEdges(tdm);
 +      const MVert *mvert = target->mvert;
 +      const MPoly *mpoly = target->mpoly;
 +      const MEdge *medge = target->medge;
 +      const MLoop *mloop = target->mloop;
 +      unsigned int tnumedges = target->totedge;
        int adj_result;
        SDefAdjacencyArray *vert_edges;
        SDefAdjacency *adj_array;
@@@ -79,14 -74,16 +79,15 @@@ static void initData(ModifierData *md
        tmd->ngon_method = MOD_TRIANGULATE_NGON_BEAUTY;
  }
  
- static Mesh *applyModifier(ModifierData *md,
-                            const ModifierEvalContext *UNUSED(ctx),
-                            Mesh *mesh)
 -static DerivedMesh *applyModifier(
++static Mesh *applyModifier(
+         ModifierData *md,
 -        Object *UNUSED(ob),
 -        DerivedMesh *dm,
 -        ModifierApplyFlag UNUSED(flag))
++        const ModifierEvalContext *UNUSED(ctx),
++        Mesh *mesh)
  {
        TriangulateModifierData *tmd = (TriangulateModifierData *)md;
 -      DerivedMesh *result;
 -      if (!(result = triangulate_dm(dm, tmd->quad_method, tmd->ngon_method))) {
 -              return dm;
 +      Mesh *result;
 +      if (!(result = triangulate_mesh(mesh, tmd->quad_method, tmd->ngon_method))) {
 +              return mesh;
        }
  
        return result;
@@@ -70,92 -65,11 +70,93 @@@ void modifier_init_texture(const Scene 
        }
  }
  
- void get_texture_coords(MappingInfoModifierData *dmd, Object *ob,
-                         DerivedMesh *dm,
-                         float (*co)[3], float (*texco)[3],
-                         int numVerts)
 +/* TODO to be renamed to get_texture_coords once we are done with moving modifiers to Mesh. */
 +/** \param cos may be NULL, in which case we use directly mesh vertices' coordinates. */
 +void get_texture_coords_mesh(
 +        MappingInfoModifierData *dmd,
 +        Object *ob,
 +        Mesh *mesh,
 +        float (*cos)[3],
 +        float (*r_texco)[3])
 +{
 +      const int numVerts = mesh->totvert;
 +      int i;
 +      int texmapping = dmd->texmapping;
 +      float mapob_imat[4][4];
 +
 +      if (texmapping == MOD_DISP_MAP_OBJECT) {
 +              if (dmd->map_object)
 +                      invert_m4_m4(mapob_imat, dmd->map_object->obmat);
 +              else /* if there is no map object, default to local */
 +                      texmapping = MOD_DISP_MAP_LOCAL;
 +      }
 +
 +      /* UVs need special handling, since they come from faces */
 +      if (texmapping == MOD_DISP_MAP_UV) {
 +              if (CustomData_has_layer(&mesh->ldata, CD_MLOOPUV)) {
 +                      MPoly *mpoly = mesh->mpoly;
 +                      MPoly *mp;
 +                      MLoop *mloop = mesh->mloop;
 +                      BLI_bitmap *done = BLI_BITMAP_NEW(numVerts, __func__);
 +                      const int numPolys = mesh->totpoly;
 +                      char uvname[MAX_CUSTOMDATA_LAYER_NAME];
 +                      MLoopUV *mloop_uv;
 +
 +                      CustomData_validate_layer_name(&mesh->ldata, CD_MLOOPUV, dmd->uvlayer_name, uvname);
 +                      mloop_uv = CustomData_get_layer_named(&mesh->ldata, CD_MLOOPUV, uvname);
 +
 +                      /* verts are given the UV from the first face that uses them */
 +                      for (i = 0, mp = mpoly; i < numPolys; ++i, ++mp) {
 +                              unsigned int fidx = mp->totloop - 1;
 +
 +                              do {
 +                                      unsigned int lidx = mp->loopstart + fidx;
 +                                      unsigned int vidx = mloop[lidx].v;
 +
 +                                      if (!BLI_BITMAP_TEST(done, vidx)) {
 +                                              /* remap UVs from [0, 1] to [-1, 1] */
 +                                              r_texco[vidx][0] = (mloop_uv[lidx].uv[0] * 2.0f) - 1.0f;
 +                                              r_texco[vidx][1] = (mloop_uv[lidx].uv[1] * 2.0f) - 1.0f;
 +                                              BLI_BITMAP_ENABLE(done, vidx);
 +                                      }
 +
 +                              } while (fidx--);
 +                      }
 +
 +                      MEM_freeN(done);
 +                      return;
 +              }
 +              else {
 +                      /* if there are no UVs, default to local */
 +                      texmapping = MOD_DISP_MAP_LOCAL;
 +              }
 +      }
 +
 +      MVert *mv = mesh->mvert;
 +      for (i = 0; i < numVerts; ++i, ++mv, ++r_texco) {
 +              switch (texmapping) {
 +                      case MOD_DISP_MAP_LOCAL:
 +                              copy_v3_v3(*r_texco, cos != NULL ? *cos : mv->co);
 +                              break;
 +                      case MOD_DISP_MAP_GLOBAL:
 +                              mul_v3_m4v3(*r_texco, ob->obmat, cos != NULL ? *cos : mv->co);
 +                              break;
 +                      case MOD_DISP_MAP_OBJECT:
 +                              mul_v3_m4v3(*r_texco, ob->obmat, cos != NULL ? *cos : mv->co);
 +                              mul_m4_v3(mapob_imat, *r_texco);
 +                              break;
 +              }
 +              if (cos != NULL) {
 +                      cos++;
 +              }
 +      }
 +}
 +
+ void get_texture_coords(
+         MappingInfoModifierData *dmd, Object *ob,
+         DerivedMesh *dm,
+         float (*co)[3], float (*texco)[3],
+         int numVerts)
  {
        int i;
        int texmapping = dmd->texmapping;
@@@ -289,52 -204,6 +291,53 @@@ DerivedMesh *get_dm
        return dm;
  }
  
- Mesh *get_mesh(Object *ob, struct BMEditMesh *em, Mesh *mesh,
-                float (*vertexCos)[3], bool use_normals, bool use_orco)
 +/* returns a mesh if mesh == NULL, for deforming modifiers that need it */
++Mesh *get_mesh(
++        Object *ob, struct BMEditMesh *em, Mesh *mesh,
++        float (*vertexCos)[3], bool use_normals, bool use_orco)
 +{
 +      if (mesh) {
 +              /* pass */
 +      }
 +      else if (ob->type == OB_MESH) {
 +              struct BMeshToMeshParams bmtmp = {0};
 +              if (em) mesh = BKE_bmesh_to_mesh_nomain(em->bm, &bmtmp);
 +              else {
 +                      /* TODO(sybren): after modifier conversion of DM to Mesh is done, check whether
 +                       * we really need a copy here. Maybe the CoW ob->data can be directly used. */
 +                      BKE_id_copy_ex(
 +                              NULL, ob->data, (ID **)&mesh,
 +                              LIB_ID_CREATE_NO_MAIN |
 +                              LIB_ID_CREATE_NO_USER_REFCOUNT |
 +                              LIB_ID_CREATE_NO_DEG_TAG,
 +                              false);
 +              }
 +
 +              /* TODO(sybren): after modifier conversion of DM to Mesh is done, check whether
 +               * we really need vertexCos here. */
 +              if (vertexCos) {
 +                      BKE_mesh_apply_vert_coords(mesh, vertexCos);
 +                      mesh->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
 +              }
 +
 +              if (use_orco) {
 +                      CustomData_add_layer(&mesh->vdata, CD_ORCO, CD_ASSIGN, BKE_mesh_orco_verts_get(ob), mesh->totvert);
 +              }
 +      }
 +      else if (ELEM(ob->type, OB_FONT, OB_CURVE, OB_SURF)) {
 +              /* TODO(sybren): get evaluated mesh from depsgraph once that's properly generated for curves. */
 +              mesh = BKE_mesh_new_nomain_from_curve(ob);
 +      }
 +
 +      if (use_normals) {
 +              if (LIKELY(mesh)) {
 +                      BKE_mesh_ensure_normals(mesh);
 +              }
 +      }
 +
 +      return mesh;
 +}
 +
  /* Get derived mesh for other object, which is used as an operand for the modifier,
   * i.e. second operand for boolean modifier.
   */
@@@ -42,26 -41,19 +42,32 @@@ struct Scene
  struct Tex;
  
  void modifier_init_texture(const struct Scene *scene, struct Tex *texture);
- void get_texture_coords(struct MappingInfoModifierData *dmd, struct Object *ob, struct DerivedMesh *dm,
-                         float (*co)[3], float (*texco)[3], int numVerts);
+ void get_texture_coords(
+         struct MappingInfoModifierData *dmd, struct Object *ob, struct DerivedMesh *dm,
+         float (*co)[3], float (*texco)[3], int numVerts);
 +void get_texture_coords_mesh(
 +        struct MappingInfoModifierData *dmd,
 +        struct Object *ob,
 +        struct Mesh *mesh,
 +        float (*cos)[3],
 +        float (*r_texco)[3]);
  void modifier_vgroup_cache(struct ModifierData *md, float (*vertexCos)[3]);
- struct DerivedMesh *get_cddm(struct Object *ob, struct BMEditMesh *em, struct DerivedMesh *dm,
-                              float (*vertexCos)[3], bool use_normals);
- struct DerivedMesh *get_dm(struct Object *ob, struct BMEditMesh *em, struct DerivedMesh *dm,
-                            float (*vertexCos)[3], bool use_normals, bool use_orco);
- struct Mesh *get_mesh(struct Object *ob, struct BMEditMesh *em, struct Mesh *mesh,
-                       float (*vertexCos)[3], bool use_normals, bool use_orco);
+ struct DerivedMesh *get_cddm(
+         struct Object *ob, struct BMEditMesh *em, struct DerivedMesh *dm,
+         float (*vertexCos)[3], bool use_normals);
+ struct DerivedMesh *get_dm(
+         struct Object *ob, struct BMEditMesh *em, struct DerivedMesh *dm,
+         float (*vertexCos)[3], bool use_normals, bool use_orco);
++struct Mesh *get_mesh(
++        struct Object *ob, struct BMEditMesh *em, struct Mesh *mesh,
++        float (*vertexCos)[3], bool use_normals, bool use_orco);
  struct DerivedMesh *get_dm_for_modifier(struct Object *ob, ModifierApplyFlag flag);
- void modifier_get_vgroup(struct Object *ob, struct DerivedMesh *dm,
-                          const char *name, struct MDeformVert **dvert, int *defgrp_index);
- void modifier_get_vgroup_mesh(struct Object *ob, struct Mesh *mesh,
-                               const char *name, struct MDeformVert **dvert, int *defgrp_index);
 +
+ void modifier_get_vgroup(
+         struct Object *ob, struct DerivedMesh *dm,
+         const char *name, struct MDeformVert **dvert, int *defgrp_index);
++void modifier_get_vgroup_mesh(
++        struct Object *ob, struct Mesh *mesh,
++        const char *name, struct MDeformVert **dvert, int *defgrp_index);
  
  #endif /* __MOD_UTIL_H__ */
@@@ -87,12 -88,13 +88,13 @@@ static void foreachObjectLink
                walk(userData, ob, &umd->projectors[i], IDWALK_CB_NOP);
  }
  
- static void foreachIDLink(ModifierData *md, Object *ob,
-                           IDWalkFunc walk, void *userData)
+ static void foreachIDLink(
+         ModifierData *md, Object *ob,
+         IDWalkFunc walk, void *userData)
  {
 +#if 0
        UVProjectModifierData *umd = (UVProjectModifierData *) md;
 -
 -      walk(userData, ob, (ID **)&umd->image, IDWALK_CB_USER);
 +#endif
  
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
  }
@@@ -115,8 -132,9 +117,9 @@@ typedef struct Projector 
        void *uci;              /* optional uv-project info (panorama projection) */
  } Projector;
  
- static Mesh *uvprojectModifier_do(UVProjectModifierData *umd,
-                                   Object *ob, Mesh *mesh)
 -static DerivedMesh *uvprojectModifier_do(
++static Mesh *uvprojectModifier_do(
+         UVProjectModifierData *umd,
 -        Object *ob, DerivedMesh *dm)
++        Object *ob, Mesh *mesh)
  {
        float (*coords)[3], (*co)[3];
        MLoopUV *mloop_uv;
        }
  
        /* Mark tessellated CD layers as dirty. */
 -      dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
 +      mesh->runtime.cd_dirty_vert |= CD_MASK_TESSLOOPNORMAL;
  
 -      return dm;
 +      return mesh;
  }
  
- static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                            Mesh *mesh)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++static Mesh *applyModifier(
++        ModifierData *md, const ModifierEvalContext *ctx,
++        Mesh *mesh)
  {
 -      DerivedMesh *result;
 +      Mesh *result;
        UVProjectModifierData *umd = (UVProjectModifierData *) md;
  
 -      result = uvprojectModifier_do(umd, ob, derivedData);
 +      result = uvprojectModifier_do(umd, ctx->object, mesh);
  
        return result;
  }
@@@ -137,8 -140,10 +138,9 @@@ static void uv_warp_compute
        }
  }
  
- static DerivedMesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx,
-                                   DerivedMesh *dm)
+ static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob,
 -        DerivedMesh *dm,
 -        ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx,
++        DerivedMesh *dm)
  {
        UVWarpModifierData *umd = (UVWarpModifierData *) md;
        int numPolys, numLoops;
@@@ -222,9 -227,32 +224,10 @@@ static void foreachObjectLink(ModifierD
        walk(userData, ob, &umd->object_src, IDWALK_CB_NOP);
  }
  
- static void uv_warp_deps_object_bone_new(struct DepsNodeHandle *node,
-                                          Object *object,
-                                          const char *bonename)
 -static void uv_warp_deps_object_bone(
 -        DagForest *forest, DagNode *obNode,
 -        Object *obj, const char *bonename)
 -{
 -      if (obj) {
 -              DagNode *curNode = dag_get_node(forest, obj);
 -
 -              if (bonename[0])
 -                      dag_add_relation(forest, curNode, obNode, DAG_RL_OB_DATA | DAG_RL_DATA_DATA, "UVWarp Modifier");
 -              else
 -                      dag_add_relation(forest, curNode, obNode, DAG_RL_OB_DATA, "UVWarp Modifier");
 -      }
 -}
 -
 -static void updateDepgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
 -{
 -      UVWarpModifierData *umd = (UVWarpModifierData *) md;
 -
 -      uv_warp_deps_object_bone(ctx->forest, ctx->obNode, umd->object_src, umd->bone_src);
 -      uv_warp_deps_object_bone(ctx->forest, ctx->obNode, umd->object_dst, umd->bone_dst);
 -}
 -
+ static void uv_warp_deps_object_bone_new(
+         struct DepsNodeHandle *node,
+         Object *object,
+         const char *bonename)
  {
        if (object != NULL) {
                if (bonename[0])
@@@ -148,8 -165,9 +148,9 @@@ static void updateDepsgraph(ModifierDat
        }
  }
  
- static void warpModifier_do(WarpModifierData *wmd, Object *ob,
-                             Mesh *mesh, float (*vertexCos)[3], int numVerts)
+ static void warpModifier_do(
+         WarpModifierData *wmd, Object *ob,
 -        DerivedMesh *dm, float (*vertexCos)[3], int numVerts)
++        Mesh *mesh, float (*vertexCos)[3], int numVerts)
  {
        float obinv[4][4];
        float mat_from[4][4];
                }
        }
  
 -      if (tex_co)
 +      if (tex_co) {
                MEM_freeN(tex_co);
 -
 -}
 -
 -static int warp_needs_dm(WarpModifierData *wmd)
 -{
 -      return wmd->texture || wmd->defgrp_name[0];
 +      }
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
-                         float (*vertexCos)[3], int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
 -        float (*vertexCos)[3], int numVerts, ModifierApplyFlag UNUSED(flag))
++        ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh,
++        float (*vertexCos)[3], int numVerts)
  {
 -      DerivedMesh *dm = NULL;
 -      int use_dm = warp_needs_dm((WarpModifierData *)md);
 +      Mesh *mesh_src = mesh;
  
 -      if (use_dm) {
 -              dm = get_cddm(ob, NULL, derivedData, vertexCos, false);
 +      if (mesh_src == NULL) {
 +              mesh_src = ctx->object->data;
        }
  
 -      warpModifier_do((WarpModifierData *)md, ob, dm, vertexCos, numVerts);
 +      BLI_assert(mesh_src->totvert == numVerts);
  
 -      if (use_dm) {
 -              if (dm != derivedData) dm->release(dm);
 -      }
 +      warpModifier_do((WarpModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts);
  }
  
- static void deformVertsEM(ModifierData *md, const ModifierEvalContext *ctx, struct BMEditMesh *em,
-                           Mesh *mesh, float (*vertexCos)[3], int numVerts)
+ static void deformVertsEM(
 -        ModifierData *md, Object *ob, struct BMEditMesh *em,
 -        DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
++        ModifierData *md, const ModifierEvalContext *ctx, struct BMEditMesh *em,
++        Mesh *mesh, float (*vertexCos)[3], int numVerts)
  {
 -      DerivedMesh *dm = derivedData;
 -      int use_dm = warp_needs_dm((WarpModifierData *)md);
 +      Mesh *mesh_src = mesh;
  
 -      if (use_dm) {
 -              if (!derivedData)
 -                      dm = CDDM_from_editbmesh(em, false, false);
 +      if (mesh_src == NULL) {
 +              mesh_src = BKE_bmesh_to_mesh_nomain(em->bm, &(struct BMeshToMeshParams){0});
        }
  
 -      deformVerts(md, ob, dm, vertexCos, numVerts, 0);
 +      BLI_assert(mesh_src->totvert == numVerts);
 +
 +      warpModifier_do((WarpModifierData *)md, ctx->object, mesh_src, vertexCos, numVerts);
  
 -      if (use_dm) {
 -              if (!derivedData) dm->release(dm);
 +      if (!mesh) {
 +              BKE_id_free(NULL, mesh_src);
        }
  }
  
@@@ -138,10 -158,10 +140,11 @@@ static CustomDataMask requiredDataMask(
        return dataMask;
  }
  
- static void waveModifier_do(WaveModifierData *md,
-                             Depsgraph *depsgraph,
-                             Object *ob, DerivedMesh *dm,
-                             float (*vertexCos)[3], int numVerts)
+ static void waveModifier_do(
+         WaveModifierData *md,
 -        Scene *scene, Object *ob, DerivedMesh *dm,
++        Depsgraph *depsgraph,
++        Object *ob, DerivedMesh *dm,
+         float (*vertexCos)[3], int numVerts)
  {
        WaveModifierData *wmd = (WaveModifierData *) md;
        MVert *mvert = NULL;
        if (wmd->texture) MEM_freeN(tex_co);
  }
  
- static void deformVerts(ModifierData *md, const ModifierEvalContext *ctx,
-                         DerivedMesh *derivedData,
-                         float (*vertexCos)[3],
-                         int numVerts)
+ static void deformVerts(
 -        ModifierData *md, Object *ob,
++        ModifierData *md, const ModifierEvalContext *ctx,
+         DerivedMesh *derivedData,
+         float (*vertexCos)[3],
 -        int numVerts,
 -        ModifierApplyFlag UNUSED(flag))
++        int numVerts)
  {
        DerivedMesh *dm = derivedData;
        WaveModifierData *wmd = (WaveModifierData *)md;
@@@ -115,10 -114,11 +115,11 @@@ void weightvg_do_map(int num, float *ne
   * vertex index (in case the weight tables do not cover the whole vertices...).
   * XXX The standard "factor" value is assumed in [0.0, 1.0] range. Else, weird results might appear.
   */
- void weightvg_do_mask(const int num, const int *indices, float *org_w, const float *new_w,
-                       Object *ob, Mesh *mesh, const float fact, const char defgrp_name[MAX_VGROUP_NAME],
-                       Scene *scene, Tex *texture, const int tex_use_channel, const int tex_mapping,
-                       Object *tex_map_object, const char *tex_uvlayer_name)
+ void weightvg_do_mask(
 -        int num, const int *indices, float *org_w, const float *new_w,
 -        Object *ob, DerivedMesh *dm, float fact, const char defgrp_name[MAX_VGROUP_NAME],
 -        Scene *scene, Tex *texture, int tex_use_channel, int tex_mapping,
++        const int num, const int *indices, float *org_w, const float *new_w,
++        Object *ob, Mesh *mesh, const float fact, const char defgrp_name[MAX_VGROUP_NAME],
++        Scene *scene, Tex *texture, const int tex_use_channel, const int tex_mapping,
+         Object *tex_map_object, const char *tex_uvlayer_name)
  {
        int ref_didx;
        int i;
@@@ -72,17 -70,19 +72,19 @@@ void weightvg_do_map(int num, float *ne
   * vertex index (in case the weight tables do not cover the whole vertices...).
   * XXX The standard "factor" value is assumed in [0.0, 1.0] range. Else, weird results might appear.
   */
- void weightvg_do_mask(const int num, const int *indices, float *org_w, const float *new_w, Object *ob,
-                       struct Mesh *mesh, const float fact, const char defgrp_name[MAX_VGROUP_NAME],
-                       struct Scene *scene, Tex *texture, const int tex_use_channel, const int tex_mapping,
-                       Object *tex_map_object, const char *tex_uvlayer_name);
+ void weightvg_do_mask(
 -        int num, const int *indices, float *org_w, const float *new_w, Object *ob,
 -        DerivedMesh *dm, float fact, const char defgrp_name[MAX_VGROUP_NAME],
 -        struct Scene *scene, Tex *texture, int tex_use_channel, int tex_mapping,
++        const int num, const int *indices, float *org_w, const float *new_w, Object *ob,
++        struct Mesh *mesh, const float fact, const char defgrp_name[MAX_VGROUP_NAME],
++        struct Scene *scene, Tex *texture, const int tex_use_channel, const int tex_mapping,
+         Object *tex_map_object, const char *tex_uvlayer_name);
  
  /* Applies weights to given vgroup (defgroup), and optionally add/remove vertices from the group.
   * If indices is not NULL, it must be a table of same length as weights, mapping to the real
   * vertex index (in case the weight table does not cover the whole vertices...).
   */
- void weightvg_update_vg(struct MDeformVert *dvert, int defgrp_idx, struct MDeformWeight **dws, int num,
-                         const int *indices, const float *weights, const bool do_add,
-                         const float add_thresh, const bool do_rem, const float rem_thresh);
+ void weightvg_update_vg(
 -        MDeformVert *dvert, int defgrp_idx, MDeformWeight **dws, int num,
++        struct MDeformVert *dvert, int defgrp_idx, struct MDeformWeight **dws, int num,
+         const int *indices, const float *weights, const bool do_add,
+         const float add_thresh, const bool do_rem, const float rem_thresh);
  
  #endif /* __MOD_WEIGHTVG_UTIL_H__ */
@@@ -154,14 -172,12 +154,15 @@@ static bool isDisabled(ModifierData *md
        return (wmd->defgrp_name[0] == '\0');
  }
  
- static Mesh *applyModifier(ModifierData *md,
-                            const ModifierEvalContext *ctx,
-                            Mesh *mesh)
 -static DerivedMesh *applyModifier(
 -        ModifierData *md, Object *ob, DerivedMesh *derivedData,
 -        ModifierApplyFlag UNUSED(flag))
++static Mesh *applyModifier(
++        ModifierData *md,
++        const ModifierEvalContext *ctx,
++        Mesh *mesh)
  {
 +      BLI_assert(mesh != NULL);
 +
        WeightVGEditModifierData *wmd = (WeightVGEditModifierData *) md;
 -      DerivedMesh *dm = derivedData;
 +
        MDeformVert *dvert = NULL;
        MDeformWeight **dw = NULL;
        float *org_w; /* Array original weights. */
@@@ -139,9 -136,10 +139,10 @@@ static void vert2geom_task_cb_ex
  /**
   * Find nearest vertex and/or edge and/or face, for each vertex (adapted from shrinkwrap.c).
   */
- static void get_vert2geom_distance(int numVerts, float (*v_cos)[3],
-                                    float *dist_v, float *dist_e, float *dist_f,
-                                    Mesh *target, const SpaceTransform *loc2trgt)
+ static void get_vert2geom_distance(
+         int numVerts, float (*v_cos)[3],
+         float *dist_v, float *dist_e, float *dist_f,
 -        DerivedMesh *target, const SpaceTransform *loc2trgt)
++        Mesh *target, const SpaceTransform *loc2trgt)
  {
        Vert2GeomData data = {0};
        Vert2GeomDataChunk data_chunk = {{{0}}};