static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData, float (*vertexCos)[3],
int UNUSED(numVerts), ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm;
ClothModifierData *clmd = (ClothModifierData *) md;
DerivedMesh *result = NULL;
/* 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, 0);
if (dm == derivedData)
dm = CDDM_copy(dm);
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);
if (result) {
result->getVertCos(result, vertexCos);
result->release(result);
}
dm->release(dm);
}
/* returns a derived mesh if dm == NULL, for deforming modifiers that need it */
DerivedMesh *get_dm(Object *ob, struct BMEditMesh *em, DerivedMesh *dm,
float (*vertexCos)[3], bool use_normals, bool use_orco)
{
if (dm) {
/* pass */
}
else if (ob->type == OB_MESH) {
if (em) dm = CDDM_from_editbmesh(em, false, false);
else dm = CDDM_from_mesh((struct Mesh *)(ob->data));
if (vertexCos) {
CDDM_apply_vert_coords(dm, vertexCos);
dm->dirty |= DM_DIRTY_NORMALS;
}
if (use_orco) {
DM_add_vert_layer(dm, CD_ORCO, CD_ASSIGN, BKE_mesh_orco_verts_get(ob));
}
}
else if (ELEM3(ob->type, OB_FONT, OB_CURVE, OB_SURF)) {
dm = CDDM_from_curve(ob);
}
if (use_normals) {
if (LIKELY(dm)) {
DM_ensure_normals(dm);
}
}
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);
}
/* returns a cdderivedmesh if dm == NULL or is another type of derivedmesh */
DerivedMesh *get_cddm(Object *ob, struct BMEditMesh *em, DerivedMesh *dm, float (*vertexCos)[3], bool use_normals)
{
if (dm) {
if (dm->type != DM_TYPE_CDDM) {
dm = CDDM_copy(dm);
CDDM_apply_vert_coords(dm, vertexCos);
}
if (use_normals) {
DM_ensure_normals(dm);
}
}
else {
dm = get_dm(ob, em, dm, vertexCos, use_normals, false);
}
return dm;
}
/* returns a cdderivedmesh if dm == NULL or is another type of derivedmesh */
DerivedMesh *get_cddm(Object *ob, struct BMEditMesh *em, DerivedMesh *dm, float (*vertexCos)[3])
{
if (dm && dm->type == DM_TYPE_CDDM)
return dm;
if (!dm) {
dm = get_dm(ob, em, dm, vertexCos, 0);
}
else {
dm = CDDM_copy(dm);
CDDM_apply_vert_coords(dm, vertexCos);
}
if (dm)
CDDM_calc_normals(dm);
return dm;
}
/* returns a derived mesh if dm == NULL, for deforming modifiers that need it */
DerivedMesh *get_dm(Object *ob, struct BMEditMesh *em, DerivedMesh *dm, float (*vertexCos)[3], int orco)
{
if (dm)
return dm;
if (ob->type == OB_MESH) {
if (em) dm = CDDM_from_editbmesh(em, FALSE, FALSE);
else dm = CDDM_from_mesh((struct Mesh *)(ob->data), ob);
if (vertexCos) {
CDDM_apply_vert_coords(dm, vertexCos);
//CDDM_calc_normals(dm);
}
if (orco)
DM_add_vert_layer(dm, CD_ORCO, CD_ASSIGN, BKE_mesh_orco_verts_get(ob));
}
else if (ELEM3(ob->type, OB_FONT, OB_CURVE, OB_SURF)) {
dm = CDDM_from_curve(ob);
}
return dm;
}
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int UNUSED(numVerts),
int UNUSED(useRenderParams),
int UNUSED(isFinalCalc))
{
SurfaceModifierData *surmd = (SurfaceModifierData*) md;
if(surmd->dm)
surmd->dm->release(surmd->dm);
/* if possible use/create DerivedMesh */
if(derivedData) surmd->dm = CDDM_copy(derivedData);
else surmd->dm = get_dm(ob, NULL, NULL, NULL, 0);
if(!ob->pd)
{
printf("SurfaceModifier deformVerts: Should not happen!\n");
return;
}
if(surmd->dm)
{
unsigned int numverts = 0, i = 0;
int init = 0;
float *vec;
MVert *x, *v;
CDDM_apply_vert_coords(surmd->dm, vertexCos);
CDDM_calc_normals(surmd->dm);
numverts = surmd->dm->getNumVerts ( surmd->dm );
if(numverts != surmd->numverts || surmd->x == NULL || surmd->v == NULL || md->scene->r.cfra != surmd->cfra+1) {
if(surmd->x) {
MEM_freeN(surmd->x);
surmd->x = NULL;
}
if(surmd->v) {
MEM_freeN(surmd->v);
surmd->v = NULL;
}
surmd->x = MEM_callocN(numverts * sizeof(MVert), "MVert");
surmd->v = MEM_callocN(numverts * sizeof(MVert), "MVert");
surmd->numverts = numverts;
init = 1;
}
/* convert to global coordinates and calculate velocity */
for(i = 0, x = surmd->x, v = surmd->v; i<numverts; i++, x++, v++) {
vec = CDDM_get_vert(surmd->dm, i)->co;
mul_m4_v3(ob->obmat, vec);
if(init)
v->co[0] = v->co[1] = v->co[2] = 0.0f;
else
sub_v3_v3v3(v->co, vec, x->co);
copy_v3_v3(x->co, vec);
}
surmd->cfra = md->scene->r.cfra;
if(surmd->bvhtree)
free_bvhtree_from_mesh(surmd->bvhtree);
else
surmd->bvhtree = MEM_callocN(sizeof(BVHTreeFromMesh), "BVHTreeFromMesh");
if(surmd->dm->getNumFaces(surmd->dm))
bvhtree_from_mesh_faces(surmd->bvhtree, surmd->dm, 0.0, 2, 6);
else
bvhtree_from_mesh_edges(surmd->bvhtree, surmd->dm, 0.0, 2, 6);
}
}
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int UNUSED(numVerts),
ModifierApplyFlag UNUSED(flag))
{
CollisionModifierData *collmd = (CollisionModifierData *) md;
DerivedMesh *dm = NULL;
MVert *tempVert = NULL;
/* if possible use/create DerivedMesh */
if (derivedData) dm = CDDM_copy(derivedData);
else if (ob->type == OB_MESH) dm = CDDM_from_mesh(ob->data, ob);
if (!ob->pd) {
printf("CollisionModifier deformVerts: Should not happen!\n");
return;
}
if (dm) {
float current_time = 0;
unsigned int numverts = 0;
CDDM_apply_vert_coords(dm, vertexCos);
CDDM_calc_normals(dm);
current_time = BKE_scene_frame_get(md->scene);
if (G.debug_value > 0)
printf("current_time %f, collmd->time_xnew %f\n", current_time, collmd->time_xnew);
numverts = dm->getNumVerts(dm);
if (current_time > collmd->time_xnew) {
unsigned int i;
/* check if mesh has changed */
if (collmd->x && (numverts != collmd->numverts))
freeData((ModifierData *)collmd);
if (collmd->time_xnew == -1000) { /* first time */
collmd->x = dm->dupVertArray(dm); /* frame start position */
for (i = 0; i < numverts; i++) {
/* we save global positions */
mul_m4_v3(ob->obmat, collmd->x[i].co);
}
collmd->xnew = MEM_dupallocN(collmd->x); // frame end position
collmd->current_x = MEM_dupallocN(collmd->x); // inter-frame
collmd->current_xnew = MEM_dupallocN(collmd->x); // inter-frame
collmd->current_v = MEM_dupallocN(collmd->x); // inter-frame
collmd->numverts = numverts;
DM_ensure_tessface(dm); /* BMESH - UNTIL MODIFIER IS UPDATED FOR MPoly */
collmd->mfaces = dm->dupTessFaceArray(dm);
collmd->numfaces = dm->getNumTessFaces(dm);
/* create bounding box hierarchy */
collmd->bvhtree = bvhtree_build_from_mvert(collmd->mfaces, collmd->numfaces, collmd->x, numverts, ob->pd->pdef_sboft);
collmd->time_x = collmd->time_xnew = current_time;
}
else if (numverts == collmd->numverts) {
/* put positions to old positions */
tempVert = collmd->x;
collmd->x = collmd->xnew;
collmd->xnew = tempVert;
collmd->time_x = collmd->time_xnew;
memcpy(collmd->xnew, dm->getVertArray(dm), numverts * sizeof(MVert));
for (i = 0; i < numverts; i++) {
/* we save global positions */
mul_m4_v3(ob->obmat, collmd->xnew[i].co);
}
memcpy(collmd->current_xnew, collmd->x, numverts * sizeof(MVert));
memcpy(collmd->current_x, collmd->x, numverts * sizeof(MVert));
/* check if GUI setting has changed for bvh */
if (collmd->bvhtree) {
if (ob->pd->pdef_sboft != BLI_bvhtree_getepsilon(collmd->bvhtree)) {
BLI_bvhtree_free(collmd->bvhtree);
collmd->bvhtree = bvhtree_build_from_mvert(collmd->mfaces, collmd->numfaces, collmd->current_x, numverts, ob->pd->pdef_sboft);
}
}
/* happens on file load (ONLY when i decomment changes in readfile.c) */
if (!collmd->bvhtree) {
collmd->bvhtree = bvhtree_build_from_mvert(collmd->mfaces, collmd->numfaces, collmd->current_x, numverts, ob->pd->pdef_sboft);
}
else {
/* recalc static bounding boxes */
bvhtree_update_from_mvert(collmd->bvhtree, collmd->mfaces, collmd->numfaces, collmd->current_x, collmd->current_xnew, collmd->numverts, 1);
}
collmd->time_xnew = current_time;
}
else if (numverts != collmd->numverts) {
freeData((ModifierData *)collmd);
}
}
else if (current_time < collmd->time_xnew) {
freeData((ModifierData *)collmd);
}
else {
if (numverts != collmd->numverts) {
freeData((ModifierData *)collmd);
}
}
}
if (dm)
dm->release(dm);
}
/* saves the current emitter state for a particle system and calculates particles */
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int UNUSED(numVerts),
ModifierApplyFlag flag)
{
DerivedMesh *dm = derivedData;
ParticleSystemModifierData *psmd = (ParticleSystemModifierData *) md;
ParticleSystem *psys = NULL;
bool needsFree = false;
/* float cfra = BKE_scene_frame_get(md->scene); */ /* UNUSED */
if (ob->particlesystem.first)
psys = psmd->psys;
else
return;
if (!psys_check_enabled(ob, psys, (flag & MOD_APPLY_RENDER) != 0))
return;
if (dm == NULL) {
dm = get_dm(ob, NULL, NULL, vertexCos, false, true);
if (!dm)
return;
needsFree = true;
}
/* clear old dm */
if (psmd->dm_final) {
psmd->dm_final->needsFree = true;
psmd->dm_final->release(psmd->dm_final);
if (psmd->dm_deformed) {
psmd->dm_deformed->needsFree = 1;
psmd->dm_deformed->release(psmd->dm_deformed);
psmd->dm_deformed = NULL;
}
}
else if (psmd->flag & eParticleSystemFlag_file_loaded) {
/* in file read dm just wasn't saved in file so no need to reset everything */
psmd->flag &= ~eParticleSystemFlag_file_loaded;
}
else {
/* no dm before, so recalc particles fully */
psys->recalc |= PSYS_RECALC_RESET;
}
/* make new dm */
psmd->dm_final = CDDM_copy(dm);
CDDM_apply_vert_coords(psmd->dm_final, vertexCos);
CDDM_calc_normals(psmd->dm_final);
if (needsFree) {
dm->needsFree = true;
dm->release(dm);
}
/* protect dm */
psmd->dm_final->needsFree = false;
DM_ensure_tessface(psmd->dm_final);
if (!psmd->dm_final->deformedOnly) {
/* XXX Think we can assume here that if current DM is not only-deformed, ob->deformedOnly has been set.
* This is awfully weak though. :| */
if (ob->derivedDeform) {
psmd->dm_deformed = CDDM_copy(ob->derivedDeform);
}
else { /* Can happen in some cases, e.g. when rendering from Edit mode... */
psmd->dm_deformed = CDDM_from_mesh((Mesh *)ob->data);
}
DM_ensure_tessface(psmd->dm_deformed);
}
/* report change in mesh structure */
if (psmd->dm_final->getNumVerts(psmd->dm_final) != psmd->totdmvert ||
psmd->dm_final->getNumEdges(psmd->dm_final) != psmd->totdmedge ||
psmd->dm_final->getNumTessFaces(psmd->dm_final) != psmd->totdmface)
{
psys->recalc |= PSYS_RECALC_RESET;
psmd->totdmvert = psmd->dm_final->getNumVerts(psmd->dm_final);
psmd->totdmedge = psmd->dm_final->getNumEdges(psmd->dm_final);
psmd->totdmface = psmd->dm_final->getNumTessFaces(psmd->dm_final);
}
if (!(ob->transflag & OB_NO_PSYS_UPDATE)) {
psmd->flag &= ~eParticleSystemFlag_psys_updated;
particle_system_update(md->scene, ob, psys, (flag & MOD_APPLY_RENDER) != 0);
psmd->flag |= eParticleSystemFlag_psys_updated;
}
}
static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
ListBase *dispbase, DerivedMesh **r_dm_final,
const bool for_render, const bool use_render_resolution)
{
VirtualModifierData virtualModifierData;
ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
ModifierData *pretessellatePoint;
Curve *cu = ob->data;
int required_mode = 0, totvert = 0;
const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
DerivedMesh *dm = NULL, *ndm;
float (*vertCos)[3] = NULL;
int useCache = !for_render;
ModifierApplyFlag app_flag = 0;
if (use_render_resolution) {
app_flag |= MOD_APPLY_RENDER;
required_mode = eModifierMode_Render;
}
else
required_mode = eModifierMode_Realtime;
pretessellatePoint = curve_get_tessellate_point(scene, ob, use_render_resolution, editmode);
if (editmode)
required_mode |= eModifierMode_Editmode;
if (pretessellatePoint) {
md = pretessellatePoint->next;
}
if (r_dm_final && *r_dm_final) {
(*r_dm_final)->release(*r_dm_final);
}
for (; md; md = md->next) {
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
ModifierApplyFlag appf = app_flag;
md->scene = scene;
if (!modifier_isEnabled(scene, md, required_mode))
continue;
if (mti->type == eModifierTypeType_OnlyDeform ||
(mti->type == eModifierTypeType_DeformOrConstruct && !dm))
{
if (editmode)
appf |= MOD_APPLY_USECACHE;
if (dm) {
if (!vertCos) {
totvert = dm->getNumVerts(dm);
vertCos = MEM_mallocN(sizeof(*vertCos) * totvert, "dfmv");
dm->getVertCos(dm, vertCos);
}
mti->deformVerts(md, ob, dm, vertCos, totvert, appf);
}
else {
if (!vertCos) {
vertCos = displist_get_allverts(dispbase, &totvert);
}
mti->deformVerts(md, ob, NULL, vertCos, totvert, appf);
}
}
else {
if (!r_dm_final) {
/* makeDisplistCurveTypes could be used for beveling, where derived mesh
* is totally unnecessary, so we could stop modifiers applying
* when we found constructive modifier but derived mesh is unwanted result
*/
break;
}
if (dm) {
if (vertCos) {
DerivedMesh *tdm = CDDM_copy(dm);
dm->release(dm);
dm = tdm;
CDDM_apply_vert_coords(dm, vertCos);
}
}
else {
if (vertCos) {
displist_apply_allverts(dispbase, vertCos);
}
if (ELEM(ob->type, OB_CURVE, OB_FONT) && (cu->flag & CU_DEFORM_FILL)) {
curve_to_filledpoly(cu, nurb, dispbase);
}
dm = CDDM_from_curve_displist(ob, dispbase);
}
if (vertCos) {
/* Vertex coordinates were applied to necessary data, could free it */
MEM_freeN(vertCos);
vertCos = NULL;
}
if (useCache)
appf |= MOD_APPLY_USECACHE;
ndm = modwrap_applyModifier(md, ob, dm, appf);
if (ndm) {
/* Modifier returned a new derived mesh */
if (dm && dm != ndm) /* Modifier */
dm->release(dm);
dm = ndm;
}
}
}
if (vertCos) {
if (dm) {
DerivedMesh *tdm = CDDM_copy(dm);
dm->release(dm);
dm = tdm;
CDDM_apply_vert_coords(dm, vertCos);
CDDM_calc_normals_mapping(dm);
MEM_freeN(vertCos);
}
else {
displist_apply_allverts(dispbase, vertCos);
MEM_freeN(vertCos);
vertCos = NULL;
}
}
if (r_dm_final) {
if (dm) {
/* see: mesh_calc_modifiers */
if (dm->getNumTessFaces(dm) == 0) {
dm->recalcTessellation(dm);
}
/* Even if tessellation is not needed, some modifiers might have modified CD layers
* (like mloopcol or mloopuv), hence we have to update those. */
else if (dm->dirty & DM_DIRTY_TESS_CDLAYERS) {
DM_update_tessface_data(dm);
}
if (dm->type == DM_TYPE_CDDM) {
CDDM_calc_normals_mapping_ex(dm, (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
}
}
(*r_dm_final) = dm;
}
}
static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispbase,
DerivedMesh **derivedFinal, int forRender, float (*originalVerts)[3], float (*deformedVerts)[3])
{
ModifierData *md = modifiers_getVirtualModifierList(ob);
ModifierData *preTesselatePoint;
Curve *cu= ob->data;
ListBase *nurb= BKE_curve_nurbs(cu);
int required_mode = 0, totvert = 0;
int editmode = (!forRender && cu->editnurb);
DerivedMesh *dm= NULL, *ndm;
float (*vertCos)[3] = NULL;
if(forRender) required_mode = eModifierMode_Render;
else required_mode = eModifierMode_Realtime;
preTesselatePoint = curve_get_tesselate_point(scene, ob, forRender, editmode);
if(editmode) required_mode |= eModifierMode_Editmode;
if (preTesselatePoint) {
md = preTesselatePoint->next;
}
if (derivedFinal && *derivedFinal) {
(*derivedFinal)->release (*derivedFinal);
}
for (; md; md=md->next) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
md->scene= scene;
if ((md->mode & required_mode) != required_mode) continue;
if (mti->isDisabled && mti->isDisabled(md, forRender)) continue;
if (mti->type == eModifierTypeType_OnlyDeform ||
(mti->type == eModifierTypeType_DeformOrConstruct && !dm)) {
if (dm) {
if (!vertCos) {
totvert = dm->getNumVerts(dm);
vertCos = MEM_mallocN(sizeof(*vertCos) * totvert, "dfmv");
dm->getVertCos(dm, vertCos);
}
mti->deformVerts(md, ob, dm, vertCos, totvert, forRender, editmode);
} else {
if (!vertCos) {
vertCos= displist_get_allverts(dispbase, &totvert);
}
mti->deformVerts(md, ob, NULL, vertCos, totvert, forRender, editmode);
}
} else {
if (!derivedFinal) {
/* makeDisplistCurveTypes could be used for beveling, where derived mesh */
/* is totally unnecessary, so we could stop modifiers applying */
/* when we found constructive modifier but derived mesh is unwanted result */
break;
}
if (dm) {
if (vertCos) {
DerivedMesh *tdm = CDDM_copy(dm);
dm->release(dm);
dm = tdm;
CDDM_apply_vert_coords(dm, vertCos);
CDDM_calc_normals(dm);
}
} else {
if (vertCos) {
displist_apply_allverts(dispbase, vertCos);
}
if (ELEM(ob->type, OB_CURVE, OB_FONT) && (cu->flag & CU_DEFORM_FILL)) {
curve_to_filledpoly(cu, nurb, dispbase);
}
dm= CDDM_from_curve_customDB(ob, dispbase);
CDDM_calc_normals(dm);
}
if (vertCos) {
/* Vertex coordinates were applied to necessary data, could free it */
MEM_freeN(vertCos);
vertCos= NULL;
}
ndm = mti->applyModifier(md, ob, dm, forRender, editmode);
if (ndm) {
/* Modifier returned a new derived mesh */
if (dm && dm != ndm) /* Modifier */
dm->release (dm);
dm = ndm;
}
}
}
if (vertCos) {
if (dm) {
DerivedMesh *tdm = CDDM_copy(dm);
dm->release(dm);
dm = tdm;
CDDM_apply_vert_coords(dm, vertCos);
CDDM_calc_normals(dm);
MEM_freeN(vertCos);
} else {
displist_apply_allverts(dispbase, vertCos);
MEM_freeN(vertCos);
vertCos= NULL;
}
}
if (derivedFinal) {
(*derivedFinal) = dm;
}
if (deformedVerts) {
curve_applyVertexCos(ob->data, nurb, originalVerts);
MEM_freeN(originalVerts);
MEM_freeN(deformedVerts);
}
}
/* saves the current emitter state for a particle system and calculates particles */
static void deformVerts(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
float (*vertexCos)[3],
int UNUSED(numVerts),
ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = derivedData;
ParticleSystemModifierData *psmd = (ParticleSystemModifierData *) md;
ParticleSystem *psys = NULL;
int needsFree = 0;
/* float cfra = BKE_scene_frame_get(md->scene); */ /* UNUSED */
if (ob->particlesystem.first)
psys = psmd->psys;
else
return;
if (!psys_check_enabled(ob, psys))
return;
if (dm == NULL) {
dm = get_dm(ob, NULL, NULL, vertexCos, false, true);
if (!dm)
return;
needsFree = 1;
}
/* clear old dm */
if (psmd->dm) {
psmd->dm->needsFree = 1;
psmd->dm->release(psmd->dm);
}
else if (psmd->flag & eParticleSystemFlag_file_loaded) {
/* in file read dm just wasn't saved in file so no need to reset everything */
psmd->flag &= ~eParticleSystemFlag_file_loaded;
}
else {
/* no dm before, so recalc particles fully */
psys->recalc |= PSYS_RECALC_RESET;
}
/* make new dm */
psmd->dm = CDDM_copy(dm);
CDDM_apply_vert_coords(psmd->dm, vertexCos);
CDDM_calc_normals(psmd->dm);
if (needsFree) {
dm->needsFree = 1;
dm->release(dm);
}
/* protect dm */
psmd->dm->needsFree = 0;
/* report change in mesh structure */
DM_ensure_tessface(psmd->dm);
if (psmd->dm->getNumVerts(psmd->dm) != psmd->totdmvert ||
psmd->dm->getNumEdges(psmd->dm) != psmd->totdmedge ||
psmd->dm->getNumTessFaces(psmd->dm) != psmd->totdmface)
{
psys->recalc |= PSYS_RECALC_RESET;
psmd->totdmvert = psmd->dm->getNumVerts(psmd->dm);
psmd->totdmedge = psmd->dm->getNumEdges(psmd->dm);
psmd->totdmface = psmd->dm->getNumTessFaces(psmd->dm);
}
if (!(ob->transflag & OB_NO_PSYS_UPDATE)) {
psmd->flag &= ~eParticleSystemFlag_psys_updated;
particle_system_update(md->scene, ob, psys);
psmd->flag |= eParticleSystemFlag_psys_updated;
}
}
