static void deformVertsEM(
ModifierData *md, Object *ob, struct BMEditMesh *em,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = derivedData;
if (!derivedData) dm = CDDM_from_editbmesh(em, false, false);
deformVerts(md, ob, dm, vertexCos, numVerts, 0);
if (!derivedData) dm->release(dm);
}
static void deformVertsEM(
ModifierData *md, Object *ob, EditMesh *editData,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = derivedData;
if (!derivedData) dm = CDDM_from_editmesh(editData, ob->data);
deformVerts(md, ob, dm, vertexCos, numVerts);
if (!derivedData) dm->release(dm);
}
static void deformVertsEM(
ModifierData *md, Object *ob, struct BMEditMesh *editData,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = get_dm(ob, editData, derivedData, NULL, false, false);
correctivesmooth_modifier_do(md, ob, dm, vertexCos, (unsigned int)numVerts, editData);
if (dm != derivedData) {
dm->release(dm);
}
}
static void deformVertsEM(
ModifierData *md, Object *ob, struct BMEditMesh *editData,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = get_cddm(ob, editData, derivedData, vertexCos, dependsOnNormals(md));
displaceModifier_do((DisplaceModifierData *)md, ob, dm,
vertexCos, numVerts);
if (dm != derivedData)
dm->release(dm);
}
static void deformVerts(
ModifierData *md, Object *ob, DerivedMesh *derivedData,
float (*vertexCos)[3], int numVerts, ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, false, false);
correctivesmooth_modifier_do(md, ob, dm, vertexCos, (unsigned int)numVerts, NULL);
if (dm != derivedData) {
dm->release(dm);
}
}
/* Edge index from a loop index for a given original mesh. */
static int exporter_MapLoopToEdge(ExportMeshData *export_data,
int which_mesh, int loop_index)
{
DerivedMesh *dm = which_dm(export_data, which_mesh);
MLoop *mloop = which_mloop(export_data, which_mesh);
(void) dm; /* Unused in release builds. */
BLI_assert(dm != NULL);
BLI_assert(loop_index >= 0 && loop_index < dm->getNumLoops(dm));
return mloop[loop_index].e;
}
static void deformMatrices(ModifierData *md, Object *ob, DerivedMesh *derivedData,
float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
{
ArmatureModifierData *amd = (ArmatureModifierData *) md;
DerivedMesh *dm = derivedData;
if (!derivedData) dm = CDDM_from_mesh((Mesh *)ob->data, ob);
armature_deform_verts(amd->object, ob, dm, vertexCos, defMats, numVerts,
amd->deformflag, NULL, amd->defgrp_name);
if (!derivedData) dm->release(dm);
}
static void deformVertsEM(ModifierData *md, Object *ob,
struct BMEditMesh *UNUSED(editData),
DerivedMesh *derivedData,
float (*vertexCos)[3],
int numVerts)
{
DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, 0);
meshdeformModifier_do(md, ob, dm, vertexCos, numVerts);
if (dm && dm != derivedData)
dm->release(dm);
}
int editmesh_get_first_deform_matrices(Scene *scene, Object *ob, EditMesh *em, float (**deformmats)[3][3], float (**deformcos)[3])
{
ModifierData *md;
DerivedMesh *dm;
int i, a, numleft = 0, numVerts = 0;
int cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
modifiers_clearErrors(ob);
dm = NULL;
md = modifiers_getVirtualModifierList(ob);
/* compute the deformation matrices and coordinates for the first
modifiers with on cage editing that are enabled and support computing
deform matrices */
for(i = 0; md && i <= cageIndex; i++, md = md->next) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if(!editmesh_modifier_is_enabled(scene, md, dm))
continue;
if(mti->type==eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
if(!defmats) {
dm= editmesh_get_derived(em, NULL);
deformedVerts= editmesh_get_vertex_cos(em, &numVerts);
defmats= MEM_callocN(sizeof(*defmats)*numVerts, "defmats");
for(a=0; a<numVerts; a++)
unit_m3(defmats[a]);
}
mti->deformMatricesEM(md, ob, em, dm, deformedVerts, defmats,
numVerts);
}
else
break;
}
for(; md && i <= cageIndex; md = md->next, i++)
if(editmesh_modifier_is_enabled(scene, md, dm) && modifier_isCorrectableDeformed(md))
numleft++;
if(dm)
dm->release(dm);
*deformmats= defmats;
*deformcos= deformedVerts;
return numleft;
}
static DerivedMesh *cloth_to_triangles(DerivedMesh *dm)
{
DerivedMesh *result = NULL;
unsigned int i = 0, j = 0;
unsigned int quads = 0, numfaces = dm->getNumTessFaces(dm);
MFace *mface = dm->getTessFaceArray(dm);
MFace *mface2 = NULL;
/* calc faces */
for (i = 0; i < numfaces; i++) {
if (mface[i].v4) {
quads++;
}
}
result = CDDM_from_template(dm, dm->getNumVerts(dm), 0, numfaces + quads, 0, 0);
DM_copy_vert_data(dm, result, 0, 0, dm->getNumVerts(dm));
DM_copy_tessface_data(dm, result, 0, 0, numfaces);
DM_ensure_tessface(result);
mface2 = result->getTessFaceArray(result);
for (i = 0, j = numfaces; i < numfaces; i++) {
// DG TODO: is this necessary?
mface2[i].v1 = mface[i].v1;
mface2[i].v2 = mface[i].v2;
mface2[i].v3 = mface[i].v3;
mface2[i].v4 = 0;
//test_index_face(&mface2[i], &result->faceData, i, 3);
if (mface[i].v4) {
DM_copy_tessface_data(dm, result, i, j, 1);
mface2[j].v1 = mface[i].v1;
mface2[j].v2 = mface[i].v3;
mface2[j].v3 = mface[i].v4;
mface2[j].v4 = 0;
//test_index_face(&mface2[j], &result->faceData, j, 3);
j++;
}
}
CDDM_calc_edges_tessface(result);
CDDM_tessfaces_to_faces(result); /* builds ngon faces from tess (mface) faces */
return result;
}
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int numVerts,
ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = get_cddm(ob, NULL, derivedData, vertexCos, dependsOnNormals(md));
displaceModifier_do((DisplaceModifierData *)md, ob, dm,
vertexCos, numVerts);
if (dm != derivedData)
dm->release(dm);
}
static void deformVertsEM(ModifierData *md, Object *ob, struct BMEditMesh *editData,
DerivedMesh *derivedData, 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);
deformVerts_do(hmd, ob, dm, vertexCos, numVerts);
if (derivedData != dm)
dm->release(dm);
}
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int UNUSED(numVerts),
ModifierApplyFlag UNUSED(flag))
{
SmokeModifierData *smd = (SmokeModifierData *) md;
DerivedMesh *dm = get_cddm(ob, NULL, derivedData, vertexCos);
smokeModifier_do(smd, md->scene, ob, dm);
if (dm != derivedData)
dm->release(dm);
}
static void deformVertsEM(ModifierData *md, Object *ob, struct BMEditMesh *editData, DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = derivedData;
CustomDataMask dataMask = requiredDataMask(ob, md);
/* ensure we get a CDDM with applied vertex coords */
if (dataMask)
dm= get_cddm(ob, editData, dm, vertexCos);
shrinkwrapModifier_deform((ShrinkwrapModifierData*)md, ob, dm, vertexCos, numVerts);
if (dm != derivedData)
dm->release(dm);
}
static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *dm,
ModifierApplyFlag flag)
{
MultiresModifierData *mmd = (MultiresModifierData *)md;
DerivedMesh *result;
Mesh *me = (Mesh *)ob->data;
const int useRenderParams = flag & MOD_APPLY_RENDER;
if (mmd->totlvl) {
if (!CustomData_get_layer(&me->ldata, CD_MDISPS)) {
/* multires always needs a displacement layer */
CustomData_add_layer(&me->ldata, CD_MDISPS, CD_CALLOC, NULL, me->totloop);
}
}
result = multires_dm_create_from_derived(mmd, 0, dm, ob, useRenderParams);
if (result == dm)
return dm;
if(useRenderParams || !(flag & MOD_APPLY_USECACHE)) {
DerivedMesh *cddm;
cddm = CDDM_copy(result);
/* copy hidden flag to vertices */
if (!useRenderParams) {
struct MDisps *mdisps;
mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS);
if (mdisps) {
subsurf_copy_grid_hidden(result, me->mpoly,
cddm->getVertArray(cddm),
mdisps);
BKE_mesh_flush_hidden_from_verts(cddm->getVertArray(cddm),
cddm->getLoopArray(cddm),
cddm->getEdgeArray(cddm),
cddm->getNumEdges(cddm),
cddm->getPolyArray(cddm),
cddm->getNumPolys(cddm));
}
}
result->release(result);
result = cddm;
}
return result;
}
static int modifier_apply_shape(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
{
ModifierTypeInfo *mti= modifierType_getInfo(md->type);
md->scene= scene;
if (mti->isDisabled && mti->isDisabled(md, 0)) {
BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
return 0;
}
if (ob->type==OB_MESH) {
DerivedMesh *dm;
Mesh *me= ob->data;
Key *key=me->key;
KeyBlock *kb;
if(!modifier_sameTopology(md)) {
BKE_report(reports, RPT_ERROR, "Only deforming modifiers can be applied to Shapes");
return 0;
}
mesh_pmv_off(me);
dm = mesh_create_derived_for_modifier(scene, ob, md);
if (!dm) {
BKE_report(reports, RPT_ERROR, "Modifier is disabled or returned error, skipping apply");
return 0;
}
if(key == NULL) {
key= me->key= add_key((ID *)me);
key->type= KEY_RELATIVE;
/* if that was the first key block added, then it was the basis.
* Initialise it with the mesh, and add another for the modifier */
kb= add_keyblock(key, NULL);
mesh_to_key(me, kb);
}
kb= add_keyblock(key, md->name);
DM_to_meshkey(dm, me, kb);
dm->release(dm);
}
else {
BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
return 0;
}
return 1;
}
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int numVerts,
ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, 0);
modifier_vgroup_cache(md, vertexCos); /* if next modifier needs original vertices */
meshdeformModifier_do(md, ob, dm, vertexCos, numVerts);
if (dm && dm != derivedData)
dm->release(dm);
}
static void deformMatricesEM(
ModifierData *md, Object *ob, struct BMEditMesh *em,
DerivedMesh *derivedData, float (*vertexCos)[3],
float (*defMats)[3][3], int numVerts)
{
ArmatureModifierData *amd = (ArmatureModifierData *) md;
DerivedMesh *dm = derivedData;
if (!derivedData) dm = CDDM_from_editbmesh(em, FALSE, FALSE);
armature_deform_verts(amd->object, ob, dm, vertexCos, defMats, numVerts,
amd->deformflag, NULL, amd->defgrp_name);
if (!derivedData) dm->release(dm);
}
static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData,
float (*vertexCos)[3], int numVerts,
int UNUSED(useRenderParams), int UNUSED(isFinalCalc))
{
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, 0);
deformVerts_do(hmd, ob, dm, vertexCos, numVerts);
if (derivedData != dm)
dm->release(dm);
}
static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData,
float (*vertexCos)[3], int numVerts, ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = NULL;
int use_dm = warp_needs_dm((WarpModifierData *)md);
if (use_dm) {
dm = get_cddm(ob, NULL, derivedData, vertexCos, false);
}
warpModifier_do((WarpModifierData *)md, ob, dm, vertexCos, numVerts);
if (use_dm) {
if (dm != derivedData) dm->release(dm);
}
}
static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData,
float (*vertexCos)[3], int numVerts, ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm;
if (numVerts == 0)
return;
dm = get_dm(ob, NULL, derivedData, NULL, false, false);
laplaciansmoothModifier_do((LaplacianSmoothModifierData *)md, ob, dm,
vertexCos, numVerts);
if (dm != derivedData)
dm->release(dm);
}
static void deformVertsEM(
ModifierData *md, Object *ob, struct EditMesh *editData,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = get_dm(ob, editData, derivedData, NULL, 0);
CastModifierData *cmd = (CastModifierData *)md;
if (cmd->type == MOD_CAST_TYPE_CUBOID) {
cuboid_do(cmd, ob, dm, vertexCos, numVerts);
} else { /* MOD_CAST_TYPE_SPHERE or MOD_CAST_TYPE_CYLINDER */
sphere_do(cmd, ob, dm, vertexCos, numVerts);
}
if(dm != derivedData)
dm->release(dm);
}
/* copy the face flags, most importantly selection from the mesh to the final derived mesh,
* use in object mode when selecting faces (while painting) */
void paintface_flush_flags(Object *ob, short flag)
{
Mesh *me = BKE_mesh_from_object(ob);
DerivedMesh *dm = ob->derivedFinal;
MPoly *polys, *mp_orig;
const int *index_array = NULL;
int totpoly;
int i;
BLI_assert((flag & ~(SELECT | ME_HIDE)) == 0);
if (me == NULL)
return;
/* note, call #BKE_mesh_flush_hidden_from_verts_ex first when changing hidden flags */
/* we could call this directly in all areas that change selection,
* since this could become slow for realtime updates (circle-select for eg) */
if (flag & SELECT) {
BKE_mesh_flush_select_from_polys(me);
}
if (dm == NULL)
return;
/* Mesh polys => Final derived polys */
if ((index_array = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX))) {
polys = dm->getPolyArray(dm);
totpoly = dm->getNumPolys(dm);
/* loop over final derived polys */
for (i = 0; i < totpoly; i++) {
if (index_array[i] != ORIGINDEX_NONE) {
/* Copy flags onto the final derived poly from the original mesh poly */
mp_orig = me->mpoly + index_array[i];
polys[i].flag = mp_orig->flag;
}
}
}
if (flag & ME_HIDE) {
/* draw-object caches hidden faces, force re-generation T46867 */
GPU_drawobject_free(dm);
}
}
static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = derivedData;
ExplodeModifierData *emd = (ExplodeModifierData *) md;
ParticleSystemModifierData *psmd = findPrecedingParticlesystem(ob, md);
DM_ensure_tessface(dm); /* BMESH - UNTIL MODIFIER IS UPDATED FOR MPoly */
if (psmd) {
ParticleSystem *psys = psmd->psys;
if (psys == NULL || psys->totpart == 0) return derivedData;
if (psys->part == NULL || psys->particles == NULL) return derivedData;
if (psmd->dm == NULL) return derivedData;
/* 1. find faces to be exploded if needed */
if (emd->facepa == NULL ||
psmd->flag & eParticleSystemFlag_Pars ||
emd->flag & eExplodeFlag_CalcFaces ||
MEM_allocN_len(emd->facepa) / sizeof(int) != dm->getNumTessFaces(dm))
{
if (psmd->flag & eParticleSystemFlag_Pars)
psmd->flag &= ~eParticleSystemFlag_Pars;
if (emd->flag & eExplodeFlag_CalcFaces)
emd->flag &= ~eExplodeFlag_CalcFaces;
createFacepa(emd, psmd, derivedData);
}
/* 2. create new mesh */
if (emd->flag & eExplodeFlag_EdgeCut) {
int *facepa = emd->facepa;
DerivedMesh *splitdm = cutEdges(emd, dm);
DerivedMesh *explode = explodeMesh(emd, psmd, md->scene, ob, splitdm);
MEM_freeN(emd->facepa);
emd->facepa = facepa;
splitdm->release(splitdm);
return explode;
}
else
return explodeMesh(emd, psmd, md->scene, ob, derivedData);
}
return derivedData;
}
static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *derivedData,
ModifierApplyFlag UNUSED(flag))
{
DataTransferModifierData *dtmd = (DataTransferModifierData *) md;
DerivedMesh *dm = derivedData;
ReportList reports;
/* Only used to check wehther we are operating on org data or not... */
Mesh *me = ob->data;
MVert *mvert;
const bool invert_vgroup = (dtmd->flags & MOD_DATATRANSFER_INVERT_VGROUP) != 0;
const float max_dist = (dtmd->flags & MOD_DATATRANSFER_MAP_MAXDIST) ? dtmd->map_max_distance : FLT_MAX;
SpaceTransform space_transform_data;
SpaceTransform *space_transform = (dtmd->flags & MOD_DATATRANSFER_OBSRC_TRANSFORM) ? &space_transform_data : NULL;
if (space_transform) {
BLI_SPACE_TRANSFORM_SETUP(space_transform, ob, dtmd->ob_source);
}
mvert = dm->getVertArray(dm);
if ((me->mvert == mvert) && (dtmd->data_types & DT_TYPES_AFFECT_MESH)) {
/* We need to duplicate data here, otherwise setting custom normals, edges' shaprness, etc., could
* modify org mesh, see T43671. */
dm = CDDM_copy(dm);
}
BKE_reports_init(&reports, RPT_STORE);
/* Note: no islands precision for now here. */
BKE_object_data_transfer_dm(md->scene, dtmd->ob_source, ob, dm, dtmd->data_types, false,
dtmd->vmap_mode, dtmd->emap_mode, dtmd->lmap_mode, dtmd->pmap_mode,
space_transform, max_dist, dtmd->map_ray_radius, 0.0f,
dtmd->layers_select_src, dtmd->layers_select_dst,
dtmd->mix_mode, dtmd->mix_factor, dtmd->defgrp_name, invert_vgroup, &reports);
if (BKE_reports_contain(&reports, RPT_ERROR)) {
modifier_setError(md, "%s", BKE_reports_string(&reports, RPT_ERROR));
}
else if (dm->getNumVerts(dm) > HIGH_POLY_WARNING || ((Mesh *)(dtmd->ob_source->data))->totvert > HIGH_POLY_WARNING) {
modifier_setError(md, "You are using a rather high poly as source or destination, computation might be slow");
}
return dm;
}
static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData, float (*vertexCos)[3],
int numVerts, ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm;
ClothModifierData *clmd = (ClothModifierData *) md;
/* check for alloc failing */
if (!clmd->sim_parms || !clmd->coll_parms) {
initData(md);
if (!clmd->sim_parms || !clmd->coll_parms)
return;
}
dm = get_dm(ob, NULL, derivedData, NULL, false, false);
if (dm == derivedData)
dm = CDDM_copy(dm);
/* TODO(sergey): For now it actually duplicates logic from DerivedMesh.c
* and needs some more generic solution. But starting experimenting with
* this so close to the release is not that nice..
*
* Also hopefully new cloth system will arrive soon..
*/
if (derivedData == NULL && clmd->sim_parms->shapekey_rest) {
KeyBlock *kb = BKE_keyblock_from_key(BKE_key_from_object(ob),
clmd->sim_parms->shapekey_rest);
if (kb && kb->data != NULL) {
float (*layerorco)[3];
if (!(layerorco = DM_get_vert_data_layer(dm, CD_CLOTH_ORCO))) {
DM_add_vert_layer(dm, CD_CLOTH_ORCO, CD_CALLOC, NULL);
layerorco = DM_get_vert_data_layer(dm, CD_CLOTH_ORCO);
}
memcpy(layerorco, kb->data, sizeof(float) * 3 * numVerts);
}
}
CDDM_apply_vert_coords(dm, vertexCos);
DM_ensure_tessface(dm); /* BMESH - UNTIL MODIFIER IS UPDATED FOR MPoly */
clothModifier_do(clmd, md->scene, ob, dm, vertexCos);
dm->release(dm);
}
static void deformVertsEM(
ModifierData *md, Object *ob, struct BMEditMesh *editData,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm;
if (numVerts == 0)
return;
dm = get_dm(ob, editData, derivedData, NULL, false, false);
laplaciansmoothModifier_do((LaplacianSmoothModifierData *)md, ob, dm,
vertexCos, numVerts);
if (dm != derivedData)
dm->release(dm);
}
static void deformVertsEM(
ModifierData *md, Object *ob, struct BMEditMesh *editData,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = derivedData;
WaveModifierData *wmd = (WaveModifierData *)md;
if (wmd->flag & MOD_WAVE_NORM)
dm = get_cddm(ob, editData, dm, vertexCos);
else if (wmd->texture || wmd->defgrp_name[0])
dm = get_dm(ob, editData, dm, NULL, 0);
waveModifier_do(wmd, md->scene, ob, dm, vertexCos, numVerts);
if (dm != derivedData)
dm->release(dm);
}
static void deformVertsEM(ModifierData *md, Object *ob, struct BMEditMesh *em,
DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
DerivedMesh *dm = derivedData;
int use_dm = warp_needs_dm((WarpModifierData *)md);
if (use_dm) {
if (!derivedData)
dm = CDDM_from_editbmesh(em, FALSE, FALSE);
}
deformVerts(md, ob, dm, vertexCos, numVerts, 0);
if (use_dm) {
if (!derivedData) dm->release(dm);
}
}
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int numVerts,
ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = derivedData;
CustomDataMask dataMask = requiredDataMask(ob, md);
/* ensure we get a CDDM with applied vertex coords */
if (dataMask)
dm = get_cddm(ob, NULL, dm, vertexCos);
shrinkwrapModifier_deform((ShrinkwrapModifierData *)md, ob, dm, vertexCos, numVerts);
if (dm != derivedData)
dm->release(dm);
}
