archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
e2d9d5de08d03974ad8e3cb3b4bf3a167efdce7b
blender-archive/source/blender/blenkernel/intern/effect.c

858 lines
18 KiB
C
Raw Blame History

/* 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"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
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);
}
if(paf->totkey>1) deltalife= pa->lifetime/(paf->totkey-1);
else deltalife= pa->lifetime;
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++;
}
}
/* the big multiplication */
if(depth<PAF_MAXMULT && paf->mult[depth]!=0.0) {
/* new 'child' emerges from an average 'mult' part from
the particles */
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, num2;
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;
num2 = 2 * num;
for(i=0; i<num2; 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;
}
}
}
View Git Blame Copy Permalink