kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

- split mesh_deform off from object_deform

Browse Source 
- changed mesh_modifier, sbObjectStep, object_deform to take vertexCo
   argument instead of operating on mesh
 - fixed bug where a derived mesh would not be returned in editmode
 - removed object_wave, replaced by init_wave_deform and calc_wave_deform
 - moved cached DerivedMesh to Object, not Mesh... fixes heisenbugs
   with linked objects
This commit is contained in:
Daniel Dunbar 2005-07-19 02:36:21 +00:00
parent 8962195f21
commit 09b5272639
16 changed files with 199 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
source/blender/blenkernel/BKE_deform.h
View File

@ -40,7 +40,6 @@
struct Object;
struct ListBase;
struct MVert;
struct bDeformGroup;
void copy_defgroups (struct ListBase *lb1, struct ListBase *lb2);
@ -51,7 +50,7 @@ int get_defgroup_num (struct Object *ob, struct bDeformGroup *dg);
void hook_object_deform(struct Object *ob, int index, float *vec);
int curve_modifier(struct Object *ob, char mode);
void mesh_modifier(struct Object *ob, struct MVert **mvert_r);
void mesh_modifier(struct Object *ob, float (**vertexCos_r)[3]);
int lattice_modifier(struct Object *ob, char mode);

2
source/blender/blenkernel/BKE_effect.h
View File

@ -58,8 +58,8 @@ void particle_tex(struct MTex *mtex, struct PartEff *paf, float *co, float *no);
void make_particle_keys(int depth, int nr, struct PartEff *paf, struct Particle *part, float *force, int deform, struct MTex *mtex, unsigned int par_layer);
void init_mv_jit(float *jit, int num,int seed2);
void build_particle_system(struct Object *ob);
void init_wave_deform(struct WaveEff *wav);
void calc_wave_deform(struct WaveEff *wav, float ctime, float *co);
int object_wave(struct Object *ob);
/* particle deflector */
#define PE_WIND_AS_SPEED 0x00000001

1
source/blender/blenkernel/BKE_lattice.h
View File

@ -50,6 +50,7 @@ void calc_lat_fudu(int flag, int res, float *fu, float *du);
void init_latt_deform(struct Object *oblatt, struct Object *ob);
void calc_latt_deform(float *co);
void end_latt_deform(void);
int mesh_deform(struct Object *ob, float (*vertexCos)[3]);
int object_deform(struct Object *ob);
struct BPoint *latt_bp(struct Lattice *lt, int u, int v, int w);
void outside_lattice(struct Lattice *lt);

6
source/blender/blenkernel/BKE_softbody.h
View File

@ -56,8 +56,10 @@ extern struct SoftBody *sbNew(void);
/* frees internal data and softbody itself */
extern void sbFree(struct SoftBody *sb);
/* go one step in simulation, copy result in displist vertices */
extern void sbObjectStep(struct Object *ob, float framnr);
/* go one step in simulation, copy result in vertexCos for meshes, or
* directly for lattices.
*/
extern void sbObjectStep(struct Object *ob, float framnr, float (*vertexCos)[3]);
/* makes totally fresh start situation, resets time */
extern void sbObjectToSoftbody(struct Object *ob);

122
source/blender/blenkernel/intern/DerivedMesh.c
View File

@ -71,7 +71,7 @@ typedef struct {
MVert *verts;
float *nors;
int freeNors;
int freeNors, freeVerts;
} MeshDerivedMesh;
static DispListMesh *meshDM_convertToDispListMesh(DerivedMesh *dm)
@ -446,7 +446,7 @@ static void meshDM_release(DerivedMesh *dm)
MeshDerivedMesh *mdm = (MeshDerivedMesh*) dm;
if (mdm->freeNors) MEM_freeN(mdm->nors);
if (mdm->verts!=((Mesh*) mdm->me)->mvert) MEM_freeN(mdm->verts);
if (mdm->freeVerts) MEM_freeN(mdm->verts);
MEM_freeN(mdm);
}
@ -505,6 +505,7 @@ static DerivedMesh *getMeshDerivedMesh(Mesh *me, Object *ob, float (*vertCos)[3]
mdm->verts = me->mvert;
mdm->nors = NULL;
mdm->freeNors = 0;
mdm->freeVerts = 0;
if (vertCos) {
int i;
@ -517,6 +518,7 @@ static DerivedMesh *getMeshDerivedMesh(Mesh *me, Object *ob, float (*vertCos)[3]
}
mesh_calc_normals(mdm->verts, me->totvert, me->mface, me->totface, &mdm->nors);
mdm->freeNors = 1;
mdm->freeVerts = 1;
} else {
mdm->nors = mesh_build_faceNormals(ob);
mdm->freeNors = 1;
@ -1018,22 +1020,7 @@ static void mesh_calc_modifiers(Mesh *me, Object *ob, float (*inputVertexCos)[3]
*final_r = NULL;
if (useDeform && ob) {
MVert *deformedMVerts;
mesh_modifier(ob, &deformedMVerts);
if (deformedMVerts) {
int i;
deformedVerts = MEM_mallocN(sizeof(*deformedVerts)*me->totvert, "deformedverts");
for (i=0; i<me->totvert; i++) {
VECCOPY(deformedVerts[i], deformedMVerts[i].co);
}
MEM_freeN(deformedMVerts);
} else {
deformedVerts = NULL;
}
mesh_modifier(ob, &deformedVerts);
if (deform_r) *deform_r = getMeshDerivedMesh(me, ob, deformedVerts);
} else {
@ -1053,22 +1040,70 @@ static void mesh_calc_modifiers(Mesh *me, Object *ob, float (*inputVertexCos)[3]
/***/
static void clear_and_build_mesh_data(Object *ob, int mustBuildForMesh)
{
float min[3], max[3];
Mesh *me= ob->data;
if(ob->flag&OB_FROMDUPLI) return; // XXX is this needed
/* also serves as signal to remake texspace */
if (me->bb) {
MEM_freeN(me->bb);
me->bb = NULL;
}
freedisplist(&ob->disp);
if (ob->derivedFinal) {
ob->derivedFinal->release(ob->derivedFinal);
ob->derivedFinal= NULL;
}
if (ob->derivedDeform) {
ob->derivedDeform->release(ob->derivedDeform);
ob->derivedDeform= NULL;
}
if (ob==G.obedit) {
G.editMesh->derived= subsurf_make_derived_from_editmesh(G.editMesh, me->subdiv, me->subsurftype, G.editMesh->derived);
}
if (ob!=G.obedit || mustBuildForMesh) {
mesh_calc_modifiers(ob->data, ob, NULL, &ob->derivedDeform, &ob->derivedFinal, 0, 1);
INIT_MINMAX(min, max);
ob->derivedFinal->getMinMax(ob->derivedFinal, min, max);
boundbox_set_from_min_max(mesh_get_bb(ob->data), min, max);
build_particle_system(ob);
}
}
void makeDispListMesh(Object *ob)
{
clear_and_build_mesh_data(ob, 0);
}
/***/
DerivedMesh *mesh_get_derived_final(Object *ob, int *needsFree_r)
{
Mesh *me = ob->data;
if (!me->derived) {
makeDispListMesh(ob);
if (!ob->derivedFinal) {
clear_and_build_mesh_data(ob, 1);
}
*needsFree_r = 0;
return me->derived;
return ob->derivedFinal;
}
DerivedMesh *mesh_get_derived_deform(Object *ob, int *needsFree_r)
{
if (!ob->derivedDeform) {
makeDispListMesh(ob);
clear_and_build_mesh_data(ob, 1);
}
*needsFree_r = 0;
@ -1141,46 +1176,3 @@ DerivedMesh *editmesh_get_derived_cage(int *needsFree_r)
return dm;
}
/***/
void makeDispListMesh(Object *ob)
{
MVert *deformedMVerts = NULL;
float min[3], max[3];
Mesh *me;
if(ob->flag&OB_FROMDUPLI) return; // XXX is this needed
me= ob->data;
/* also serves as signal to remake texspace */
if (me->bb) {
MEM_freeN(me->bb);
me->bb = NULL;
}
freedisplist(&ob->disp);
if (me->derived) {
me->derived->release(me->derived);
me->derived= NULL;
}
if (ob->derivedDeform) {
ob->derivedDeform->release(ob->derivedDeform);
ob->derivedDeform= NULL;
}
if (ob==G.obedit) {
G.editMesh->derived= subsurf_make_derived_from_editmesh(G.editMesh, me->subdiv, me->subsurftype, G.editMesh->derived);
} else {
mesh_calc_modifiers(ob->data, ob, NULL, &ob->derivedDeform, &me->derived, 0, 1);
INIT_MINMAX(min, max);
me->derived->getMinMax(me->derived, min, max);
boundbox_set_from_min_max(mesh_get_bb(ob->data), min, max);
build_particle_system(ob);
}
}

1
source/blender/blenkernel/intern/anim.c
View File

@ -275,6 +275,7 @@ static Object *new_dupli_object(ListBase *lb, Object *ob, Object *par)
Object *newob;
newob= MEM_mallocN(sizeof(Object), "newobj dupli");
memcpy(newob, ob, sizeof(Object));
newob->flag |= OB_FROMDUPLI;
newob->id.newid= (ID *)par; /* store duplicator */

46
source/blender/blenkernel/intern/deform.c
View File

@ -227,14 +227,14 @@ void hook_object_deform(Object *ob, int index, float *vec)
}
void mesh_modifier(Object *ob, MVert **mvert_r)
void mesh_modifier(Object *ob, float (**vertexCos_r)[3])
{
MVert *origMVert=NULL;
Mesh *me= ob->data;
MVert *mv;
int a, done=0;
float (*vertexCos)[3];
*mvert_r = NULL;
*vertexCos_r = NULL;
do_mesh_key(me);
@ -248,7 +248,10 @@ void mesh_modifier(Object *ob, MVert **mvert_r)
if(me->totvert==0) return;
origMVert= MEM_dupallocN(me->mvert);
vertexCos = MEM_mallocN(sizeof(*vertexCos)*me->totvert, "vertexcos");
for (a=0; a<me->totvert; a++) {
VECCOPY(vertexCos[a], me->mvert[a].co);
}
/* hooks */
if(ob->hooks.first) {
@ -257,29 +260,46 @@ void mesh_modifier(Object *ob, MVert **mvert_r)
/* NULL signals initialize */
hook_object_deform(ob, 0, NULL);
for(a=0, mv= me->mvert; a<me->totvert; a++, mv++) {
hook_object_deform(ob, a, mv->co);
for(a=0; a<me->totvert; a++) {
hook_object_deform(ob, a, vertexCos[a]);
}
}
if(ob->effect.first) done |= object_wave(ob);
if(ob->effect.first) {
WaveEff *wav;
float ctime = bsystem_time(ob, 0, (float)G.scene->r.cfra, 0.0);
int a;
for (wav= ob->effect.first; wav; wav= wav->next) {
if(wav->type==EFF_WAVE) {
init_wave_deform(wav);
for(a=0; a<me->totvert; a++) {
calc_wave_deform(wav, ctime, vertexCos[a]);
}
done = 1;
}
}
}
if((ob->softflag & OB_SB_ENABLE) && !(ob->softflag & OB_SB_POSTDEF)) {
done= 1;
sbObjectStep(ob, (float)G.scene->r.cfra);
sbObjectStep(ob, (float)G.scene->r.cfra, vertexCos);
}
/* object_deform: output for mesh is in mesh->mvert */
done |= object_deform(ob);
done |= mesh_deform(ob, vertexCos);
if((ob->softflag & OB_SB_ENABLE) && (ob->softflag & OB_SB_POSTDEF)) {
done= 1;
sbObjectStep(ob, (float)G.scene->r.cfra);
sbObjectStep(ob, (float)G.scene->r.cfra, vertexCos);
}
if (done) {
*mvert_r = me->mvert;
me->mvert = origMVert;
*vertexCos_r = vertexCos;
} else {
MEM_freeN(vertexCos_r);
}
}
@ -390,7 +410,7 @@ int lattice_modifier(Object *ob, char mode)
}
if((ob->softflag & OB_SB_ENABLE)) {
sbObjectStep(ob, (float)G.scene->r.cfra);
sbObjectStep(ob, (float)G.scene->r.cfra, NULL);
}
}

50
source/blender/blenkernel/intern/effect.c
View File

@ -1418,6 +1418,11 @@ void build_particle_system(Object *ob)
/* ************* WAVE **************** */
void init_wave_deform(WaveEff *wav) {
wav->minfac= (float)(1.0/exp(wav->width*wav->narrow*wav->width*wav->narrow));
if(wav->damp==0) wav->damp= 10.0f;
}
void calc_wave_deform(WaveEff *wav, float ctime, float *co)
{
/* co is in local coords */
@ -1467,51 +1472,6 @@ void calc_wave_deform(WaveEff *wav, float ctime, float *co)
}
}
/* return 1 if deformed
Note: it works on mvert now, so assumes to be callied in modifier stack \
*/
int object_wave(Object *ob)
{
WaveEff *wav;
Mesh *me;
MVert *mvert;
float ctime;
int a;
/* is there a wave */
wav= ob->effect.first;
while(wav) {
if(wav->type==EFF_WAVE) break;
wav= wav->next;
}
if(wav==NULL) return 0;
if(ob->type==OB_MESH) {
ctime= bsystem_time(ob, 0, (float)G.scene->r.cfra, 0.0);
me= ob->data;
wav= ob->effect.first;
while(wav) {
if(wav->type==EFF_WAVE) {
/* precalculate */
wav->minfac= (float)(1.0/exp(wav->width*wav->narrow*wav->width*wav->narrow));
if(wav->damp==0) wav->damp= 10.0f;
mvert= me->mvert;
for(a=0; a<me->totvert; a++, mvert++) {
calc_wave_deform(wav, ctime, mvert->co);
}
}
wav= wav->next;
}
}
return 1;
}
int SoftBodyDetectCollision(float opco[3], float npco[3], float colco[3],
float facenormal[3], float *damp, float force[3], int mode,
float cur_time, unsigned int par_layer,struct Object *vertexowner)

118
source/blender/blenkernel/intern/lattice.c
View File

@ -516,70 +516,79 @@ static void calc_curve_deform(Object *par, float *co, short axis, CurveDeform *c
}
/* Mesh now applies on mesh itself, others do displist */
int object_deform(Object *ob)
int mesh_deform(Object *ob, float (*vertexCos)[3])
{
Mesh *me;
Curve *cu;
DispList *dl;
MVert *mvert;
float *fp;
int a, tot, flag;
Mesh *me = ob->data;
int a;
if(ob->parent==NULL) return 0;
if(ob->parent==NULL || ob->type!=OB_MESH || !me->totvert) return 0;
/* always try to do the entire deform in this function: apply! */
if(ob->parent->type==OB_CURVE) {
if(ob->parent->type==OB_CURVE && ob->partype==PARSKEL) {
Curve *cu = ob->parent->data;
int flag = cu->flag;
CurveDeform cd;
if (ob->partype != PARSKEL){
return 0;
}
cu= ob->parent->data;
flag= cu->flag;
cu->flag |= (CU_PATH|CU_FOLLOW); // needed for path & bevlist
if(ob->type==OB_MESH) {
me= ob->data;
if(me->totvert==0) return 0;
/* init deform */
init_curve_deform(ob->parent, ob, &cd);
/* transformation to curve space, and min max*/
INIT_MINMAX(cd.dmin, cd.dmax);
for(a=0, mvert=me->mvert; a<me->totvert; a++, mvert++) {
Mat4MulVecfl(cd.curvespace, mvert->co);
DO_MINMAX(mvert->co, cd.dmin, cd.dmax);
for(a=0; a<me->totvert; a++) {
Mat4MulVecfl(cd.curvespace, vertexCos[a]);
DO_MINMAX(vertexCos[a], cd.dmin, cd.dmax);
}
mvert= me->mvert;
for(a=0; a<me->totvert; a++, mvert++) {
calc_curve_deform(ob->parent, mvert->co, ob->trackflag, &cd);
/* move coord back to objectspace */
Mat4MulVecfl(cd.objectspace, mvert->co);
for(a=0; a<me->totvert; a++) {
calc_curve_deform(ob->parent, vertexCos[a], ob->trackflag, &cd);
Mat4MulVecfl(cd.objectspace, vertexCos[a]); /* move coord back to objectspace */
}
}
/* restore */
cu->flag = flag;
return 1;
}
else if(ob->parent->type==OB_LATTICE) {
init_latt_deform(ob->parent, ob);
if(ob->type==OB_MESH) {
for(a=0; a<me->totvert; a++) {
calc_latt_deform(vertexCos[a]);
}
}
end_latt_deform();
return 1;
}
else if(ob->parent->type==OB_ARMATURE && ob->partype==PARSKEL) {
if (ob->parent==G.obedit) // misleading making displists... very bad
return 1;
init_armature_deform (ob->parent, ob);
for(a=0; a<me->totvert; a++) {
calc_armature_deform(ob->parent, vertexCos[a], a);
}
return 1;
}
return 0;
}
int object_deform(Object *ob)
{
Curve *cu;
DispList *dl;
float *fp;
int a, tot;
if(ob->parent==NULL) return 0;
if(ob->parent->type==OB_LATTICE) {
init_latt_deform(ob->parent, ob);
if(ob->type==OB_MESH) {
me= ob->data;
mvert= me->mvert;
for(a=0; a<me->totvert; a++, mvert++) {
calc_latt_deform(mvert->co);
}
}
else if(ob->type==OB_MBALL) {
if(ob->type==OB_MBALL) {
dl=ob->disp.first;
while(dl) {
fp = dl->verts;
@ -609,31 +618,6 @@ int object_deform(Object *ob)
end_latt_deform();
return 1;
}
else if(ob->parent->type==OB_ARMATURE) {
if (ob->partype != PARSKEL)
return 0;
if (ob->parent==G.obedit) // misleading making displists... very bad
return 1;
init_armature_deform (ob->parent, ob);
switch (ob->type){
case OB_MESH:
me= ob->data;
mvert= me->mvert;
for(a=0; a<me->totvert; a++, mvert++) {
calc_armature_deform(ob->parent, mvert->co, a);
}
break;
case OB_CURVE:
case OB_SURF:
break;
}
return 1;
}
return 0;

5
source/blender/blenkernel/intern/mesh.c
View File

@ -136,7 +136,6 @@ void unlink_mesh(Mesh *me)
/* do not free mesh itself */
void free_mesh(Mesh *me)
{
unlink_mesh(me);
if(me->mvert) MEM_freeN(me->mvert);
@ -151,7 +150,6 @@ void free_mesh(Mesh *me)
if(me->mat) MEM_freeN(me->mat);
if(me->bb) MEM_freeN(me->bb);
if(me->derived) me->derived->release(me->derived);
}
void copy_dverts(MDeformVert *dst, MDeformVert *src, int copycount)
@ -238,7 +236,6 @@ Mesh *copy_mesh(Mesh *me)
men->key= copy_key(me->key);
if(men->key) men->key->from= (ID *)men;
men->derived = NULL;
men->decimated = NULL;
return men;
@ -681,8 +678,6 @@ void flipnorm_mesh(Mesh *me)
{
MFace *mface;
MVert *mvert;
DispList *dl;
float *fp;
int a, temp;
mvert= me->mvert;

2
source/blender/blenkernel/intern/object.c
View File

@ -176,6 +176,7 @@ void free_object(Object *ob)
int a;
if(ob->derivedDeform) ob->derivedDeform->release(ob->derivedDeform);
if(ob->derivedFinal) ob->derivedFinal->release(ob->derivedFinal);
/* disconnect specific data */
if(ob->data) {
@ -841,6 +842,7 @@ Object *copy_object(Object *ob)
obn->soft= copy_softbody(ob->soft);
ob->derivedDeform = NULL;
ob->derivedFinal = NULL;
return obn;
}

30
source/blender/blenkernel/intern/softbody.c
View File

@ -910,20 +910,16 @@ static void mesh_to_softbody(Object *ob)
}
/* copies current sofbody position in mesh, so do this within modifier stacks! */
static void softbody_to_mesh(Object *ob)
static void softbody_to_mesh(Object *ob, float (*vertexCos)[3])
{
Mesh *me= ob->data;
MVert *mvert;
BodyPoint *bp;
BodyPoint *bp= ob->soft->bpoint;
int a;
bp= ob->soft->bpoint;
mvert= me->mvert;
for(a=me->totvert; a>0; a--, mvert++, bp++) {
VECCOPY(mvert->co, bp->pos);
Mat4MulVecfl(ob->imat, mvert->co); // softbody is in global coords
for(a=me->totvert; a>0; a--, bp++, vertexCos++) {
VECCOPY(vertexCos[0], bp->pos);
Mat4MulVecfl(ob->imat, vertexCos[0]); // softbody is in global coords
}
}
/* makes totally fresh start situation */
@ -991,7 +987,7 @@ static void lattice_update_softbody(Object *ob)
/* copies softbody result back in object */
/* only used in sbObjectStep() */
static void softbody_to_object(Object *ob)
static void softbody_to_object(Object *ob, float (*vertexCos)[3])
{
if(ob->soft==NULL) return;
@ -1001,7 +997,7 @@ static void softbody_to_object(Object *ob)
switch(ob->type) {
case OB_MESH:
softbody_to_mesh(ob);
softbody_to_mesh(ob, vertexCos);
break;
case OB_LATTICE:
softbody_to_lattice(ob);
@ -1027,7 +1023,7 @@ static void object_update_softbody(Object *ob)
}
/* return 1 if succesfully baked and applied step */
static int softbody_baked_step(Object *ob, float framenr)
static int softbody_baked_step(Object *ob, float framenr, float (*vertexCos)[3])
{
SoftBody *sb= ob->soft;
SBVertex *key0, *key1, *key2, *key3;
@ -1079,7 +1075,7 @@ static int softbody_baked_step(Object *ob, float framenr)
bp->pos[2]= data[0]*key0->vec[2] + data[1]*key1->vec[2] + data[2]*key2->vec[2] + data[3]*key3->vec[2];
}
softbody_to_object(ob);
softbody_to_object(ob, vertexCos);
return 1;
}
@ -1220,7 +1216,7 @@ void sbObjectReset(Object *ob)
/* simulates one step. framenr is in frames */
/* copies result back to object, displist */
void sbObjectStep(Object *ob, float framenr)
void sbObjectStep(Object *ob, float framenr, float (*vertexCos)[3])
{
SoftBody *sb;
Base *base;
@ -1237,7 +1233,7 @@ void sbObjectStep(Object *ob, float framenr)
/* baking works with global time */
if(!(ob->softflag & OB_SB_BAKEDO) )
if(softbody_baked_step(ob, framenr) ) return;
if(softbody_baked_step(ob, framenr, vertexCos) ) return;
/* remake softbody if: */
if( (ob->softflag & OB_SB_REDO) || // signal after weightpainting
@ -1367,7 +1363,7 @@ void sbObjectStep(Object *ob, float framenr)
}
/* and apply to vertices */
softbody_to_object(ob);
softbody_to_object(ob, vertexCos);
sb->ctime= ctime;
} // if(ABS(dtime) > 0.0)
@ -1376,7 +1372,7 @@ void sbObjectStep(Object *ob, float framenr)
// since dtime= ctime - ob->soft->ctime== 0.0;
// and we were not notifified about any other time changes
// so here it is !
softbody_to_object(ob);
softbody_to_object(ob, vertexCos);
}
/* reset deflector cache */

2
source/blender/blenloader/intern/readfile.c
View File

@ -2090,7 +2090,6 @@ static void direct_link_mesh(FileData *fd, Mesh *mesh)
mesh->oc= 0;
mesh->dface= NULL;
mesh->decimated= NULL;
mesh->derived= NULL;
if (mesh->tface) {
TFace *tfaces= mesh->tface;
@ -2371,6 +2370,7 @@ static void direct_link_object(FileData *fd, Object *ob)
ob->bb= NULL;
ob->derivedDeform= NULL;
ob->derivedFinal= NULL;
}
/* ************ READ SCENE ***************** */

2
source/blender/makesdna/DNA_mesh_types.h
View File

@ -80,8 +80,6 @@ typedef struct Mesh {
struct MSticky *msticky;
struct Mesh *texcomesh;
/* not written in file, caches derived mesh */
struct DerivedMesh *derived;
/* hacky place to store temporary decimated mesh */
struct DispListMesh *decimated;

2
source/blender/makesdna/DNA_object_types.h
View File

@ -194,7 +194,7 @@ typedef struct Object {
float toonedge, smoothresh; /* smoothresh is phong interpolation ray_shadow correction in render */
struct DerivedMesh *derivedDeform;
struct DerivedMesh *derivedDeform, *derivedFinal;
} Object;
typedef struct ObHook {

23
source/blender/python/api2_2x/Lattice.c
View File

@ -32,6 +32,7 @@
#include "Lattice.h" /*This must come first*/
#include "BKE_utildefines.h"
#include "BKE_main.h"
#include "BKE_global.h"
#include "BKE_library.h"
@ -39,6 +40,8 @@
#include "BLI_blenlib.h"
#include "DNA_object_types.h"
#include "DNA_key_types.h"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_curve_types.h"
#include "DNA_scene_types.h"
#include "BIF_editkey.h"
@ -702,10 +705,28 @@ static PyObject *Lattice_applyDeform( BPy_Lattice * self, PyObject *args )
* method is needed. Or for users who actually want to apply the
* deformation n times. */
if((self->Lattice == par->data)) {
if ((base->object->type != OB_MESH) || forced)
if ((base->object->type != OB_MESH) || forced) {
if (base->object->type==OB_MESH) {
Mesh *me = base->object->data;
float (*vcos)[3] = malloc(sizeof(*vcos)*me->totvert);
int a;
for (a=0; a<me->totvert; a++) {
VECCOPY(vcos[a], me->mvert[a].co);
}
mesh_deform( base->object, vcos );
for (a=0; a<me->totvert; a++) {
VECCOPY(me->mvert[a].co, vcos[a]);
}
free(vcos);
} else {
object_deform( base->object );
}
}
}
}
base = base->next;
}