Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/blender/blenkernel/intern/effect.c
diff options
context:
space:
mode:
Diffstat (limited to 'source/blender/blenkernel/intern/effect.c')
-rw-r--r--source/blender/blenkernel/intern/effect.c854
1 files changed, 854 insertions, 0 deletions
diff --git a/source/blender/blenkernel/intern/effect.c b/source/blender/blenkernel/intern/effect.c
new file mode 100644
index 00000000000..c39ad72ecdf
--- /dev/null
+++ b/source/blender/blenkernel/intern/effect.c
@@ -0,0 +1,854 @@
+/* effect.c MIX MODEL
+ *
+ * dec 95
+ *
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License. See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "MEM_guardedalloc.h"
+#include "DNA_listBase.h"
+#include "DNA_effect_types.h"
+#include "DNA_object_types.h"
+#include "DNA_mesh_types.h"
+#include "DNA_material_types.h"
+#include "DNA_curve_types.h"
+#include "DNA_key_types.h"
+#include "DNA_texture_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_lattice_types.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "BLI_rand.h"
+
+#include "BKE_utildefines.h"
+#include "BKE_bad_level_calls.h"
+#include "BKE_global.h"
+#include "BKE_material.h"
+#include "BKE_effect.h"
+#include "BKE_key.h"
+#include "BKE_ipo.h"
+#include "BKE_screen.h"
+#include "BKE_texture.h"
+#include "BKE_blender.h"
+#include "BKE_object.h"
+#include "BKE_displist.h"
+#include "BKE_lattice.h"
+
+
+Effect *add_effect(int type)
+{
+ Effect *eff=0;
+ BuildEff *bld;
+ PartEff *paf;
+ WaveEff *wav;
+ int a;
+
+ switch(type) {
+ case EFF_BUILD:
+ bld= MEM_callocN(sizeof(BuildEff), "neweff");
+ eff= (Effect *)bld;
+
+ bld->sfra= 1.0;
+ bld->len= 100.0;
+ break;
+
+ case EFF_PARTICLE:
+ paf= MEM_callocN(sizeof(PartEff), "neweff");
+ eff= (Effect *)paf;
+
+ paf->sta= 1.0;
+ paf->end= 100.0;
+ paf->lifetime= 50.0;
+ for(a=0; a<PAF_MAXMULT; a++) {
+ paf->life[a]= 50.0;
+ paf->child[a]= 4;
+ paf->mat[a]= 1;
+ }
+
+ paf->totpart= 1000;
+ paf->totkey= 8;
+ paf->staticstep= 5;
+ paf->defvec[2]= 1.0f;
+ paf->nabla= 0.05f;
+
+ break;
+
+ case EFF_WAVE:
+ wav= MEM_callocN(sizeof(WaveEff), "neweff");
+ eff= (Effect *)wav;
+
+ wav->flag |= (WAV_X+WAV_Y+WAV_CYCL);
+
+ wav->height= 0.5f;
+ wav->width= 1.5f;
+ wav->speed= 0.5f;
+ wav->narrow= 1.5f;
+ wav->lifetime= 0.0f;
+ wav->damp= 10.0f;
+
+ break;
+ }
+
+ eff->type= eff->buttype= type;
+ eff->flag |= SELECT;
+
+ return eff;
+}
+
+void free_effect(Effect *eff)
+{
+ PartEff *paf;
+
+ if(eff->type==EFF_PARTICLE) {
+ paf= (PartEff *)eff;
+ if(paf->keys) MEM_freeN(paf->keys);
+ }
+ MEM_freeN(eff);
+}
+
+
+void free_effects(ListBase *lb)
+{
+ Effect *eff;
+
+ eff= lb->first;
+ while(eff) {
+ BLI_remlink(lb, eff);
+ free_effect(eff);
+ eff= lb->first;
+ }
+}
+
+Effect *copy_effect(Effect *eff)
+{
+ Effect *effn;
+
+ effn= MEM_dupallocN(eff);
+ if(effn->type==EFF_PARTICLE) ((PartEff *)effn)->keys= 0;
+
+ return effn;
+}
+
+void copy_act_effect(Object *ob)
+{
+ /* return de aktieve eff gekopieerd */
+ Effect *effn, *eff;
+
+ eff= ob->effect.first;
+ while(eff) {
+ if(eff->flag & SELECT) {
+
+ effn= copy_effect(eff);
+ BLI_addtail(&ob->effect, effn);
+
+ eff->flag &= ~SELECT;
+ return;
+
+ }
+ eff= eff->next;
+ }
+
+ /* als tie hier komt: new effect */
+ eff= add_effect(EFF_BUILD);
+ BLI_addtail(&ob->effect, eff);
+
+}
+
+void copy_effects(ListBase *lbn, ListBase *lb)
+{
+ Effect *eff, *effn;
+
+ lbn->first= lbn->last= 0;
+
+ eff= lb->first;
+ while(eff) {
+ effn= copy_effect(eff);
+ BLI_addtail(lbn, effn);
+
+ eff= eff->next;
+ }
+
+}
+
+void deselectall_eff(Object *ob)
+{
+ Effect *eff= ob->effect.first;
+
+ while(eff) {
+ eff->flag &= ~SELECT;
+ eff= eff->next;
+ }
+}
+
+void set_buildvars(Object *ob, int *start, int *end)
+{
+ BuildEff *bld;
+ float ctime;
+
+ bld= ob->effect.first;
+ while(bld) {
+ if(bld->type==EFF_BUILD) {
+ ctime= bsystem_time(ob, 0, (float)G.scene->r.cfra, bld->sfra-1.0f);
+ if(ctime < 0.0) {
+ *end= *start;
+ }
+ else if(ctime < bld->len) {
+ *end= *start+ (int)((*end - *start)*ctime/bld->len);
+ }
+
+ return;
+ }
+ bld= bld->next;
+ }
+}
+
+/* ***************** PARTICLES ***************** */
+
+Particle *new_particle(PartEff *paf)
+{
+ static Particle *pa;
+ static int cur;
+
+ /* afspraak: als paf->keys==0: alloc */
+ if(paf->keys==0) {
+ pa= paf->keys= MEM_callocN( paf->totkey*paf->totpart*sizeof(Particle), "particlekeys" );
+ cur= 0;
+ }
+ else {
+ if(cur && cur<paf->totpart) pa+=paf->totkey;
+ cur++;
+ }
+ return pa;
+}
+
+PartEff *give_parteff(Object *ob)
+{
+ PartEff *paf;
+
+ paf= ob->effect.first;
+ while(paf) {
+ if(paf->type==EFF_PARTICLE) return paf;
+ paf= paf->next;
+ }
+ return 0;
+}
+
+void where_is_particle(PartEff *paf, Particle *pa, float ctime, float *vec)
+{
+ Particle *p[4];
+ float dt, t[4];
+ int a;
+
+ if(paf->totkey==1) {
+ VECCOPY(vec, pa->co);
+ return;
+ }
+
+ /* eerst op zoek naar de eerste particlekey */
+ a= (int)((paf->totkey-1)*(ctime-pa->time)/pa->lifetime);
+ if(a>=paf->totkey) a= paf->totkey-1;
+
+ pa+= a;
+
+ if(a>0) p[0]= pa-1; else p[0]= pa;
+ p[1]= pa;
+
+ if(a+1<paf->totkey) p[2]= pa+1; else p[2]= pa;
+ if(a+2<paf->totkey) p[3]= pa+2; else p[3]= p[2];
+
+ if(p[1]==p[2]) dt= 0.0;
+ else dt= (ctime-p[1]->time)/(p[2]->time - p[1]->time);
+
+ if(paf->flag & PAF_BSPLINE) set_four_ipo(dt, t, KEY_BSPLINE);
+ else set_four_ipo(dt, t, KEY_CARDINAL);
+
+ vec[0]= t[0]*p[0]->co[0] + t[1]*p[1]->co[0] + t[2]*p[2]->co[0] + t[3]*p[3]->co[0];
+ vec[1]= t[0]*p[0]->co[1] + t[1]*p[1]->co[1] + t[2]*p[2]->co[1] + t[3]*p[3]->co[1];
+ vec[2]= t[0]*p[0]->co[2] + t[1]*p[1]->co[2] + t[2]*p[2]->co[2] + t[3]*p[3]->co[2];
+
+}
+
+
+void particle_tex(MTex *mtex, PartEff *paf, float *co, float *no)
+{
+ extern float Tin, Tr, Tg, Tb;
+ float old;
+
+ externtex(mtex, co);
+
+ if(paf->texmap==PAF_TEXINT) {
+ Tin*= paf->texfac;
+ no[0]+= Tin*paf->defvec[0];
+ no[1]+= Tin*paf->defvec[1];
+ no[2]+= Tin*paf->defvec[2];
+ }
+ else if(paf->texmap==PAF_TEXRGB) {
+ no[0]+= (Tr-0.5f)*paf->texfac;
+ no[1]+= (Tg-0.5f)*paf->texfac;
+ no[2]+= (Tb-0.5f)*paf->texfac;
+ }
+ else { /* PAF_TEXGRAD */
+
+ old= Tin;
+ co[0]+= paf->nabla;
+ externtex(mtex, co);
+ no[0]+= (old-Tin)*paf->texfac;
+
+ co[0]-= paf->nabla;
+ co[1]+= paf->nabla;
+ externtex(mtex, co);
+ no[1]+= (old-Tin)*paf->texfac;
+
+ co[1]-= paf->nabla;
+ co[2]+= paf->nabla;
+ externtex(mtex, co);
+ no[2]+= (old-Tin)*paf->texfac;
+
+ }
+}
+
+void make_particle_keys(int depth, int nr, PartEff *paf, Particle *part, float *force, int deform, MTex *mtex)
+{
+ Particle *pa, *opa = NULL;
+ float damp, deltalife;
+ int b, rt1, rt2;
+
+ damp= 1.0f-paf->damp;
+ pa= part;
+
+ /* startsnelheid: random */
+ if(paf->randfac!=0.0) {
+ pa->no[0]+= (float)(paf->randfac*( BLI_drand() -0.5));
+ pa->no[1]+= (float)(paf->randfac*( BLI_drand() -0.5));
+ pa->no[2]+= (float)(paf->randfac*( BLI_drand() -0.5));
+ }
+
+ /* startsnelheid: texture */
+ if(mtex && paf->texfac!=0.0) {
+ particle_tex(mtex, paf, pa->co, pa->no);
+ }
+
+ /* keys */
+ if(paf->totkey>1) {
+
+ deltalife= pa->lifetime/(paf->totkey-1);
+ opa= pa;
+ pa++;
+
+ b= paf->totkey-1;
+ while(b--) {
+ /* nieuwe tijd */
+ pa->time= opa->time+deltalife;
+
+ /* nieuwe plek */
+ pa->co[0]= opa->co[0] + deltalife*opa->no[0];
+ pa->co[1]= opa->co[1] + deltalife*opa->no[1];
+ pa->co[2]= opa->co[2] + deltalife*opa->no[2];
+
+ /* nieuwe snelheid */
+ pa->no[0]= opa->no[0] + deltalife*force[0];
+ pa->no[1]= opa->no[1] + deltalife*force[1];
+ pa->no[2]= opa->no[2] + deltalife*force[2];
+
+ /* snelheid: texture */
+ if(mtex && paf->texfac!=0.0) {
+ particle_tex(mtex, paf, pa->co, pa->no);
+ }
+ if(damp!=1.0) {
+ pa->no[0]*= damp;
+ pa->no[1]*= damp;
+ pa->no[2]*= damp;
+ }
+
+ opa= pa;
+ pa++;
+ /* opa wordt onderin ook gebruikt */
+ }
+ }
+
+ if(deform) {
+ /* alle keys deformen */
+ pa= part;
+ b= paf->totkey;
+ while(b--) {
+ calc_latt_deform(pa->co);
+ pa++;
+ }
+ }
+
+ /* de grote vermenigvuldiging */
+ if(depth<PAF_MAXMULT && paf->mult[depth]!=0.0) {
+
+ /* uit gemiddeld 'mult' deel van de particles ontstaan 'child' nieuwe */
+ damp = (float)nr;
+ rt1= (int)(damp*paf->mult[depth]);
+ rt2= (int)((damp+1.0)*paf->mult[depth]);
+ if(rt1!=rt2) {
+
+ for(b=0; b<paf->child[depth]; b++) {
+ pa= new_particle(paf);
+ *pa= *opa;
+ pa->lifetime= paf->life[depth];
+ if(paf->randlife!=0.0) {
+ pa->lifetime*= 1.0f+ (float)(paf->randlife*( BLI_drand() - 0.5));
+ }
+ pa->mat_nr= paf->mat[depth];
+
+ make_particle_keys(depth+1, b, paf, pa, force, deform, mtex);
+ }
+ }
+ }
+}
+
+void init_mv_jit(float *jit, int num)
+{
+ float *jit2, x, rad1, rad2, rad3;
+ int i;
+
+ if(num==0) return;
+
+ rad1= (float)(1.0/sqrt((float)num));
+ rad2= (float)(1.0/((float)num));
+ rad3= (float)sqrt((float)num)/((float)num);
+
+ BLI_srand(31415926 + num);
+ x= 0;
+ for(i=0; i<2*num; i+=2) {
+
+ jit[i]= x+ (float)(rad1*(0.5-BLI_drand()));
+ jit[i+1]= ((float)i/2)/num +(float)(rad1*(0.5-BLI_drand()));
+
+ jit[i]-= (float)floor(jit[i]);
+ jit[i+1]-= (float)floor(jit[i+1]);
+
+ x+= rad3;
+ x -= (float)floor(x);
+ }
+
+ jit2= MEM_mallocN(12 + 2*sizeof(float)*num, "initjit");
+
+ for (i=0 ; i<4 ; i++) {
+ RE_jitterate1(jit, jit2, num, rad1);
+ RE_jitterate1(jit, jit2, num, rad1);
+ RE_jitterate2(jit, jit2, num, rad2);
+ }
+ MEM_freeN(jit2);
+}
+
+
+void give_mesh_mvert(Mesh *me, int nr, float *co, short *no)
+{
+ static float *jit=0;
+ static int jitlevel=1;
+ MVert *mvert;
+ MFace *mface;
+ float u, v, *v1, *v2, *v3, *v4;
+ int curface, curjit;
+ short *n1, *n2, *n3, *n4;
+
+ /* signal */
+ if(me==0) {
+ if(jit) MEM_freeN(jit);
+ jit= 0;
+ return;
+ }
+
+ if(me->totface==0 || nr<me->totvert) {
+ mvert= me->mvert + (nr % me->totvert);
+ VECCOPY(co, mvert->co);
+ VECCOPY(no, mvert->no);
+ }
+ else {
+
+ nr-= me->totvert;
+
+ if(jit==0) {
+ jitlevel= nr/me->totface;
+ if(jitlevel==0) jitlevel= 1;
+ if(jitlevel>100) jitlevel= 100;
+
+ jit= MEM_callocN(2+ jitlevel*2*sizeof(float), "jit");
+ init_mv_jit(jit, jitlevel);
+
+ }
+
+ curjit= nr/me->totface;
+ curjit= curjit % jitlevel;
+
+ curface= nr % me->totface;
+
+ mface= me->mface;
+ mface+= curface;
+
+ v1= (me->mvert+(mface->v1))->co;
+ v2= (me->mvert+(mface->v2))->co;
+ n1= (me->mvert+(mface->v1))->no;
+ n2= (me->mvert+(mface->v2))->no;
+ if(mface->v3==0) {
+ v3= (me->mvert+(mface->v2))->co;
+ v4= (me->mvert+(mface->v1))->co;
+ n3= (me->mvert+(mface->v2))->no;
+ n4= (me->mvert+(mface->v1))->no;
+ }
+ else if(mface->v4==0) {
+ v3= (me->mvert+(mface->v3))->co;
+ v4= (me->mvert+(mface->v1))->co;
+ n3= (me->mvert+(mface->v3))->no;
+ n4= (me->mvert+(mface->v1))->no;
+ }
+ else {
+ v3= (me->mvert+(mface->v3))->co;
+ v4= (me->mvert+(mface->v4))->co;
+ n3= (me->mvert+(mface->v3))->no;
+ n4= (me->mvert+(mface->v4))->no;
+ }
+
+ u= jit[2*curjit];
+ v= jit[2*curjit+1];
+
+ co[0]= (float)((1.0-u)*(1.0-v)*v1[0] + (1.0-u)*(v)*v2[0] + (u)*(v)*v3[0] + (u)*(1.0-v)*v4[0]);
+ co[1]= (float)((1.0-u)*(1.0-v)*v1[1] + (1.0-u)*(v)*v2[1] + (u)*(v)*v3[1] + (u)*(1.0-v)*v4[1]);
+ co[2]= (float)((1.0-u)*(1.0-v)*v1[2] + (1.0-u)*(v)*v2[2] + (u)*(v)*v3[2] + (u)*(1.0-v)*v4[2]);
+
+ no[0]= (short)((1.0-u)*(1.0-v)*n1[0] + (1.0-u)*(v)*n2[0] + (u)*(v)*n3[0] + (u)*(1.0-v)*n4[0]);
+ no[1]= (short)((1.0-u)*(1.0-v)*n1[1] + (1.0-u)*(v)*n2[1] + (u)*(v)*n3[1] + (u)*(1.0-v)*n4[1]);
+ no[2]= (short)((1.0-u)*(1.0-v)*n1[2] + (1.0-u)*(v)*n2[2] + (u)*(v)*n3[2] + (u)*(1.0-v)*n4[2]);
+
+ }
+}
+
+
+void build_particle_system(Object *ob)
+{
+ Object *par;
+ PartEff *paf;
+ Particle *pa;
+ Mesh *me;
+ MVert *mvert;
+ MTex *mtexmove=0;
+ Material *ma;
+ float framelenont, ftime, dtime, force[3], imat[3][3], vec[3];
+ float fac, prevobmat[4][4], sfraont, co[3];
+ int deform=0, a, cur, cfraont, cfralast, totpart;
+ short no[3];
+
+ if(ob->type!=OB_MESH) return;
+ me= ob->data;
+ if(me->totvert==0) return;
+
+ ma= give_current_material(ob, 1);
+ if(ma) {
+ mtexmove= ma->mtex[7];
+ }
+
+ paf= give_parteff(ob);
+ if(paf==0) return;
+
+ waitcursor(1);
+
+ disable_speed_curve(1);
+
+ /* alle particles genereren */
+ if(paf->keys) MEM_freeN(paf->keys);
+ paf->keys= 0;
+ new_particle(paf);
+
+ cfraont= G.scene->r.cfra;
+ cfralast= -1000;
+ framelenont= G.scene->r.framelen;
+ G.scene->r.framelen= 1.0;
+ sfraont= ob->sf;
+ ob->sf= 0.0;
+
+ /* mult generaties? */
+ totpart= paf->totpart;
+ for(a=0; a<PAF_MAXMULT; a++) {
+ if(paf->mult[a]!=0.0) {
+ /* interessante formule! opdezewijze is na 'x' generaties het totale aantal paf->totpart */
+ totpart= (int)(totpart / (1.0+paf->mult[a]*paf->child[a]));
+ }
+ else break;
+ }
+
+ ftime= paf->sta;
+ dtime= (paf->end - paf->sta)/totpart;
+
+ /* hele hiera onthouden */
+ par= ob;
+ while(par) {
+ pushdata(par, sizeof(Object));
+ par= par->parent;
+ }
+
+ /* alles op eerste frame zetten */
+ G.scene->r.cfra= cfralast= (int)floor(ftime);
+ par= ob;
+ while(par) {
+ /* do_ob_ipo(par); */
+ do_ob_key(par);
+ par= par->parent;
+ }
+ do_mat_ipo(ma);
+
+ if((paf->flag & PAF_STATIC)==0) {
+ where_is_object(ob);
+ Mat4CpyMat4(prevobmat, ob->obmat);
+ Mat4Invert(ob->imat, ob->obmat);
+ Mat3CpyMat4(imat, ob->imat);
+ }
+ else {
+ Mat4One(prevobmat);
+ Mat3One(imat);
+ }
+
+ BLI_srand(paf->seed);
+
+ /* gaat anders veuls te hard */
+ force[0]= paf->force[0]*0.05f;
+ force[1]= paf->force[1]*0.05f;
+ force[2]= paf->force[2]*0.05f;
+
+ deform= (ob->parent && ob->parent->type==OB_LATTICE);
+ if(deform) init_latt_deform(ob->parent, 0);
+
+ /* init */
+ give_mesh_mvert(me, totpart, co, no);
+
+ for(a=0; a<totpart; a++, ftime+=dtime) {
+
+ pa= new_particle(paf);
+ pa->time= ftime;
+
+ /* ob op juiste tijd zetten */
+
+ if((paf->flag & PAF_STATIC)==0) {
+
+ cur= (int)floor(ftime) + 1 ; /* + 1 heeft een reden: (obmat/prevobmat) anders beginnen b.v. komeetstaartjes te laat */
+ if(cfralast != cur) {
+ G.scene->r.cfra= cfralast= cur;
+
+ /* later bijgevoegd: blur? */
+ bsystem_time(ob, ob->parent, (float)G.scene->r.cfra, 0.0);
+
+ par= ob;
+ while(par) {
+ /* do_ob_ipo(par); */
+ par->ctime= -1234567.0;
+ do_ob_key(par);
+ par= par->parent;
+ }
+ do_mat_ipo(ma);
+ Mat4CpyMat4(prevobmat, ob->obmat);
+ where_is_object(ob);
+ Mat4Invert(ob->imat, ob->obmat);
+ Mat3CpyMat4(imat, ob->imat);
+ }
+ }
+ /* coordinaat ophalen */
+ if(paf->flag & PAF_FACE) give_mesh_mvert(me, a, co, no);
+ else {
+ mvert= me->mvert + (a % me->totvert);
+ VECCOPY(co, mvert->co);
+ VECCOPY(no, mvert->no);
+ }
+
+ VECCOPY(pa->co, co);
+
+ if(paf->flag & PAF_STATIC);
+ else {
+ Mat4MulVecfl(ob->obmat, pa->co);
+
+ VECCOPY(vec, co);
+ Mat4MulVecfl(prevobmat, vec);
+
+ /* eerst even startsnelheid: object */
+ VecSubf(pa->no, pa->co, vec);
+ VecMulf(pa->no, paf->obfac);
+
+ /* nu juiste interframe co berekenen */
+ fac= (ftime- (float)floor(ftime));
+ pa->co[0]= fac*pa->co[0] + (1.0f-fac)*vec[0];
+ pa->co[1]= fac*pa->co[1] + (1.0f-fac)*vec[1];
+ pa->co[2]= fac*pa->co[2] + (1.0f-fac)*vec[2];
+ }
+
+ /* startsnelheid: normaal */
+ if(paf->normfac!=0.0) {
+ /* sp= mvert->no; */
+ /* transpose ! */
+ vec[0]= imat[0][0]*no[0] + imat[0][1]*no[1] + imat[0][2]*no[2];
+ vec[1]= imat[1][0]*no[0] + imat[1][1]*no[1] + imat[1][2]*no[2];
+ vec[2]= imat[2][0]*no[0] + imat[2][1]*no[1] + imat[2][2]*no[2];
+
+ Normalise(vec);
+ VecMulf(vec, paf->normfac);
+ VecAddf(pa->no, pa->no, vec);
+ }
+ pa->lifetime= paf->lifetime;
+ if(paf->randlife!=0.0) {
+ pa->lifetime*= 1.0f+ (float)(paf->randlife*( BLI_drand() - 0.5));
+ }
+ pa->mat_nr= 1;
+
+ make_particle_keys(0, a, paf, pa, force, deform, mtexmove);
+ }
+
+ if(deform) end_latt_deform();
+
+ /* restore */
+ G.scene->r.cfra= cfraont;
+ G.scene->r.framelen= framelenont;
+ give_mesh_mvert(0, 0, 0, 0);
+
+
+ /* hele hiera terug */
+ par= ob;
+ while(par) {
+ popfirst(par);
+ /* geen ob->ipo doen: insertkey behouden */
+ do_ob_key(par);
+ par= par->parent;
+ }
+
+ /* restore: NA popfirst */
+ ob->sf= sfraont;
+
+ disable_speed_curve(0);
+
+ waitcursor(0);
+
+}
+
+/* ************* WAVE **************** */
+
+void calc_wave_deform(WaveEff *wav, float ctime, float *co)
+{
+ /* co is in lokale coords */
+ float lifefac, x, y, amplit;
+
+ /* mag eigenlijk niet voorkomen */
+ if((wav->flag & (WAV_X+WAV_Y))==0) return;
+
+ lifefac= wav->height;
+
+ if( wav->lifetime!=0.0) {
+ x= ctime - wav->timeoffs;
+ if(x>wav->lifetime) {
+
+ lifefac= x-wav->lifetime;
+
+ if(lifefac > wav->damp) lifefac= 0.0;
+ else lifefac= (float)(wav->height*(1.0 - sqrt(lifefac/wav->damp)));
+ }
+ }
+ if(lifefac==0.0) return;
+
+ x= co[0]-wav->startx;
+ y= co[1]-wav->starty;
+
+ if(wav->flag & WAV_X) {
+ if(wav->flag & WAV_Y) amplit= (float)sqrt( (x*x + y*y));
+ else amplit= x;
+ }
+ else amplit= y;
+
+ /* zo maaktie mooie cirkels */
+ amplit-= (ctime-wav->timeoffs)*wav->speed;
+
+ if(wav->flag & WAV_CYCL) {
+ amplit = (float)fmod(amplit-wav->width, 2.0*wav->width) + wav->width;
+ }
+
+ /* GAUSSIAN */
+
+ if(amplit> -wav->width && amplit<wav->width) {
+
+ amplit = amplit*wav->narrow;
+ amplit= (float)(1.0/exp(amplit*amplit) - wav->minfac);
+
+ co[2]+= lifefac*amplit;
+ }
+}
+
+void object_wave(Object *ob)
+{
+ WaveEff *wav;
+ DispList *dl;
+ Mesh *me;
+ MVert *mvert;
+ float *fp, ctime;
+ int a, first;
+
+ /* is er een mave */
+ wav= ob->effect.first;
+ while(wav) {
+ if(wav->type==EFF_WAVE) break;
+ wav= wav->next;
+ }
+ if(wav==0) return;
+
+ if(ob->type==OB_MESH) {
+
+ ctime= bsystem_time(ob, 0, (float)G.scene->r.cfra, 0.0);
+ first= 1;
+
+ me= ob->data;
+ dl= find_displist_create(&ob->disp, DL_VERTS);
+
+ if(dl->verts) MEM_freeN(dl->verts);
+ dl->nr= me->totvert;
+ dl->verts= MEM_mallocN(3*4*me->totvert, "wave");
+
+ wav= ob->effect.first;
+ while(wav) {
+ if(wav->type==EFF_WAVE) {
+
+ /* voorberekenen */
+ 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;
+ fp= dl->verts;
+
+ for(a=0; a<me->totvert; a++, mvert++, fp+=3) {
+ if(first) VECCOPY(fp, mvert->co);
+ calc_wave_deform(wav, ctime, fp);
+ }
+ first= 0;
+ }
+ wav= wav->next;
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-17 09:07:46 +0300