particles.c

Go to the documentation of this file.

// File particles.c

#define MODULE_PARTICLES

#include "render.h"
#include "..\shaders\shaders.h"
#include "..\gl2.h"

extern int RENDERBUFFER_WIDTH;
extern int RENDERBUFFER_HEIGHT;
extern int TEXTUREBUFFER_WIDTH;
extern int TEXTUREBUFFER_HEIGHT;
extern GLuint g_check_texture;
extern GLuint g_map_texture;
extern GLuint g_ref_texture;  
extern GLuint g_bump_texture;
extern GLuint g_tran_texture;
extern GLuint g_movie_texture;
extern GLuint g_env_texture;
extern GLuint g_envB_texture;
extern GLuint g_envN_texture;
extern GLuint g_noise_texture;
extern GLuint g_env3D_texture;
extern GLuint g_sky_texture;

extern double DepthScalingGL,FrontDepthGL,BackDepthGL;

extern char gszHomeDir[];
extern double GlobalScale;

#include "particles.h"

// useful macro to guarantee that values are within a given range
#define Clamp(x, min, max)  x = (x<min  ? min : x<max ? x : max);
//A number between 0.0000 and 1.00000
#define RAND_N ((float)(rand())/(float)(RAND_MAX))

#define FRAME_TIME 0.04       // 25ms
//#define PARTICLE_SCALE 32768.0
//#define SIZE_SCALE 100.0
//#define PARTICLE_SCALE 16384.0
//#define SIZE_SCALE 400.0
#define PARTICLE_SCALE 4096.0
#define SIZE_SCALE 2500.0
static long nParticleImages=NP_IMAGES;
static long ParticleImageSize[NP_IMAGES];
static unsigned char *ParticleImages[NP_IMAGES];
static GLuint g_particle_textures[NP_IMAGES];
static BOOL bParticleImageLoaded=FALSE;

static BOOL InitParticleSystem(ParticleSystem *pPS);
static void UpdateParticleSystem(ParticleSystem *pPS, double fTime);
static BOOL UpdateParticle(Particle *p,  double fTimeDelta );
static void InterpolateParticleSystemPosition(ParticleSystem *Ps, double ratio);
static void FreeThisParticle(Particle *p, ParticleSystem *Pp);
static void BlendFrameBufferParticle(double, double, double, double, double, long, long,
            Particle *, fullscreenbuffer *, float *);

void LoadParticleImages(void){
 int i;
 long x,y;
 char pfile[256];
 for(i=0;i<nParticleImages;i++){
   ParticleImages[i]=NULL;
   strcpy(pfile,gszHomeDir); strcat(pfile,"PBM_"); strcat(pfile,ParticleList[i]),strcat(pfile,".bmp");
//   ParticleImages[i]=LoadSystemMAP(FALSE,FALSE,pfile,&x,&y); // x must equal y (square images) // Don't scale
   ParticleImages[i]=LoadSystemMAP(FALSE,ParticleBits[i],pfile,&x,&y); // x must equal y (square images) // Don't scale
   ParticleImageSize[i]=x;
   //if(debug != NULL)fprintf(debug,"Load particle image %ld [%s] size %ld\n",i,pfile,x);
 }
 bParticleImageLoaded=TRUE;
}

void UnloadParticleImages(void){
  int i; for(i=0;i<nParticleImages;i++){
    if(ParticleImages[i] != NULL){
      //if(debug!= NULL)fprintf(debug,"unloading particle image %ld\n",i);
      X__Free(ParticleImages[i]);
      ParticleImages[i]=NULL;
    }
  }
  bParticleImageLoaded=FALSE;
}

void MakeParticleTextures(void){ // Make OpenGL textures from particle images
 int i,j,k;
 unsigned char *tex,*pi,*po;
 long gg;
 glGenTextures( nParticleImages, &g_particle_textures[0]);
 for(i=0;i<nParticleImages;i++){
   glBindTexture(GL_TEXTURE_2D,g_particle_textures[i]);
   if(ParticleBits[i]){
     glTexImage2D(GL_TEXTURE_2D,0,4,ParticleImageSize[i],ParticleImageSize[i],
                            0,GL_RGBA,GL_UNSIGNED_BYTE,
                            (GLvoid *)ParticleImages[i]);
   }
   else{
     if((tex=malloc(ParticleImageSize[i]*ParticleImageSize[i]*4*sizeof(unsigned char))) != NULL){
       pi=ParticleImages[i]; po=tex;
       for(j=0;j<ParticleImageSize[i];j++){
         for(k=0;k<ParticleImageSize[i];k++){
           *po++ = *pi++;  // R
           *po++ = gg= *pi++;  // G
           *po++ = *pi++;  // B
           *po++ = (unsigned char)(min(255,gg*2)); // alpha
         }
       }
       //if(debug != NULL)fprintf(debug,"making Particle Texture size %ld\n",ParticleImageSize[i]);
       if(tex != NULL)glTexImage2D(GL_TEXTURE_2D,0,4,ParticleImageSize[i],ParticleImageSize[i],
                                   0,GL_RGBA,GL_UNSIGNED_BYTE,
                                  (GLvoid *)tex);
       free(tex);   
    }
   }
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 }
 glBindTexture(GL_TEXTURE_2D,0);
}

void ReleaseParticleTextures(void){
 //if(debug != NULL)fprintf(debug,"Releasing Particle Textures \n");
 glDeleteTextures(nParticleImages,g_particle_textures);
}

void  SetUpSingleParticle(ParticleSystem *ps){
 double mr,particle_transformation[4][4],trinv[4][4];
 vector Zero_Vector,dc;
 int i;
 Particle *p;
 ps->Rate=0;// should only make 1 particle
 InitParticleSystem(ps);
 if(ps->particles == NULL)return;
 ps->NumP=1;
 MakeObjectTransformation(ps->dPhi,ps->dTheta,ps->dAlpha,
              ps->im, ps->ima,
              ps->sx,ps->sy,ps->sz,
              Zero_Vector,ps->pin,
              particle_transformation,ps->particle_object_transformation,trinv);
 p=&ps->particles[0];
 p->fAge=1.0; // t0 allow for viewing
 mr=ps->mratio;
 if(mr > 0.5)mr  = (1.0-mr)*2.0;
 else        mr *=  2.0;

 p->fAlpha = ps->fAlphaStart+(ps->fAlphaEnd - ps->fAlphaStart)*mr; 
 VECSUB(ps->vColorEnd,ps->vColorStart,dc)
 VECCOPY(ps->vColorStart,p->c)
 VECSUM(p->c,mr*dc,p->c)
 p->fSize  = ps->fSizeStart+(ps->fSizeEnd - ps->fSizeStart)*mr;
 
 R_m4by4(ViewTransform,ps->particle_object_transformation,particle_transformation); 
 R_m4by1(particle_transformation,
        p->p[0]*PARTICLE_SCALE,p->p[1]*PARTICLE_SCALE,p->p[2]*PARTICLE_SCALE,
        &p->pfx[0],&p->pfx[1],&p->pfx[2]);
}

void  SetUpParticles(ParticleSystem *ps){
 double frame_time,time,delta_time=0.01,time_burst,time_burst_interval,time_burst_pulse;
 double particle_transformation[4][4],trinv[4][4];
 vector Zero_Vector;
 int i,steps,np;
 Particle *p;
 //if(debug != NULL)fprintf(debug,"Particle system setup Np=%ld\n",ps->Rate);
 // First build the particle system and move it into "local" position 
 InitParticleSystem(ps);
 // dframe is the absolute time, in number of frames along timeline 
 frame_time=ps->dframe*FRAME_TIME;
 if(ps->bSteadyState)frame_time += ps->fLifeTime;
  // NB:  we MUST get the same sequence of random numbers every time
 steps=(int)(frame_time/delta_time);  // number of steps to run particle model for
 steps=max(steps,1);
 //if(debug != NULL)fprintf(debug,"burst=%ld dframe=%ld steps=%ld frame_time=%lf\n",ps->bBurst,ps->dframe,steps,frame_time);
 srand((unsigned int)ps->NumP);
 if(ps->bBurst){
   time_burst=0.0;  
   time_burst_interval = 1.100*ps->fLifeTime; // how often pulse repeats
   time_burst_pulse    = 0.075*ps->fLifeTime;
 }
 ps->bSuppress=FALSE;
 time=0.0;
 if(!ps->bSpinOff)MakeObjectTransformation(ps->dPhi,ps->dTheta,ps->dAlpha, // keep the particle system relative to local frame of reference
              ps->im, ps->ima,
              ps->sx,ps->sy,ps->sz,
              Zero_Vector,ps->pin,
              particle_transformation,ps->particle_object_transformation,trinv);
 // bring the particle system up to date by stepping from the start
 for(i=0;i<steps;i++){
   if(ps->bSpinOff){
     InterpolateParticleSystemPosition(ps,((double)i/(double)steps));
     MakeObjectTransformation(ps->tdPhi,ps->tdTheta,ps->tdAlpha,
              ps->tim, ps->tima,
              ps->tsx,ps->tsy,ps->tsz,
              Zero_Vector,ps->tpin,
              particle_transformation,ps->particle_object_transformation,trinv);

   }
   if(ps->bBurst){  // if bursting and in quiet period - suppress particle emission
     if(time_burst < time_burst_interval){
       if(time_burst < time_burst_pulse)ps->bSuppress=FALSE;
       else                             ps->bSuppress=TRUE;
       time_burst += delta_time;
     }
     else time_burst = 0.0;
   }
   UpdateParticleSystem(ps,time);
   time += delta_time;
   //if(debug != NULL)fprintf(debug,"time=%lf time_burst=%lf\n",time,time_burst);
 }
 np=ps->NumP;  // number of particles 
 if(!ps->bSpinOff){ // particles remain in the local frame of reference 
   R_m4by4(ViewTransform,ps->particle_object_transformation,particle_transformation);  // include the viewing transform
   for(i=0;i<np;i++){
     p=&ps->particles[i];
     if(p->fAge < 0.0)continue;
     R_m4by1(particle_transformation,
           p->p[0]*PARTICLE_SCALE,p->p[1]*PARTICLE_SCALE,p->p[2]*PARTICLE_SCALE,
           &p->pfx[0],&p->pfx[1],&p->pfx[2]);
   } 
 }
 else{
   for(i=0;i<np;i++){
     p=&ps->particles[i];
     if(p->fAge < 0.0)continue;
     R_m4by1(ViewTransform,p->p[0],p->p[1],p->p[2],&p->pfx[0],&p->pfx[1],&p->pfx[2]);
   } 
 }
}

static BOOL InitParticleSystem(ParticleSystem *pPS){
int i;
double s;
// assign these values from the settings in the animator
pPS->bSuppress=FALSE;
pPS->fTimeLastUpdate  = 0.0;
pPS->fEmissionResidue = 0.0;
pPS->vLocation[0]     = pPS->vLocation[1]     = pPS->vLocation[2]     = 0.0; 
pPS->vPrevLocation[0] = pPS->vPrevLocation[1] = pPS->vPrevLocation[2] = 0.0; 
pPS->vTempVelocity[0] = pPS->vTempVelocity[1] = pPS->vTempVelocity[2] = 0.0; 

pPS->vColorStart[0]   = (double)(pPS->colour_start[0])/255.0; 
pPS->vColorStart[1]   = (double)(pPS->colour_start[1])/255.0; 
pPS->vColorStart[2]   = (double)(pPS->colour_start[2])/255.0; 
pPS->vColorEnd[0]     = (double)(pPS->colour_end[0])/255.0; 
pPS->vColorEnd[1]     = (double)(pPS->colour_end[1])/255.0; 
pPS->vColorEnd[2]     = (double)(pPS->colour_end[2])/255.0; 
pPS->vColorVar[0]     = (double)(pPS->vcolour)*0.001;
pPS->vColorVar[1]     = (double)(pPS->vcolour)*0.001;
pPS->vColorVar[2]     = (double)(pPS->vcolour)*0.001;
pPS->fAlphaStart      = (double)(pPS->alpha_start)*0.001;
pPS->fAlphaVar        = (double)(pPS->valpha)*0.001;
pPS->fAlphaEnd        = (double)(pPS->alpha_end)*0.001;
pPS->fSizeStart       = (double)(pPS->size_start)*0.001*MAX_SIZE;  pPS->fSizeStart=max(0.1,pPS->fSizeStart);
pPS->fSizeVar         = (double)(pPS->vsize)*0.001*MAX_SIZE;
pPS->fSizeEnd         = (double)(pPS->size_end)*0.001*MAX_SIZE;    pPS->fSizeEnd=max(0.1,pPS->fSizeEnd);
pPS->fSpeed           = (double)(pPS->speed)*0.001*MAX_SPEED;
pPS->fSpeedVar        = (double)(pPS->vspeed)*0.001*MAX_SPEED/10.0;
pPS->fTheta           = (double)(pPS->theta)*0.001;
pPS->fLifeTime        = (double)(pPS->life)*0.001*MAX_LIFETIME;    pPS->fLifeTime=max(0.1,pPS->fLifeTime);
pPS->fLifeVar         = (double)(pPS->vlife)*0.001*MAX_LIFETIME;
pPS->vGravityStart[0] = (double)(pPS->ew_start)*0.001*(MAX_GRAVITY-MIN_GRAVITY);
pPS->vGravityStart[1] = (double)(pPS->ns_start)*0.001*(MAX_GRAVITY-MIN_GRAVITY);
pPS->vGravityStart[2] = (double)(pPS->ud_start)*0.001*(MAX_GRAVITY-MIN_GRAVITY);
pPS->vGravityEnd[0]   = (double)(pPS->ew_end)*0.001*(MAX_GRAVITY-MIN_GRAVITY);
pPS->vGravityEnd[1]   = (double)(pPS->ns_end)*0.001*(MAX_GRAVITY-MIN_GRAVITY);
pPS->vGravityEnd[2]   = (double)(pPS->ud_end)*0.001*(MAX_GRAVITY-MIN_GRAVITY);
s=(double)(pPS->particle_size_scale)*0.001;  // 0 - 1
if(s < 0.5){
 s=1.0+(0.5-s)*2.0*9.0;  // 10 - 1
 s=1.0/s;
}
else {
  s=1.0+((s-0.5)*2.0*9.0);  // magnification by  1 up to 10
}
pPS->fSizeScale       = s;
pPS->fGravityVar      = 0.00f; 
pPS->uParticlesPerSec = pPS->Rate;  // related to NumP  - should be the default
pPS->NumP=(long)((double)pPS->Rate*pPS->fLifeTime*10.0);  // should be long enough for all particles to be alive > no/sec * lifetime
pPS->NumP=max(pPS->NumP,1);
#if 0
if(debug != NULL){
  fprintf(debug,"iid=%ld name=[%s] [%s]\n",pPS->iid,ParticleList[pPS->iid],pPS->ImageName);
  fprintf(debug,"%lf\n",pPS->vColorStart[0]);
  fprintf(debug,"%lf\n",pPS->vColorStart[1]);
  fprintf(debug,"%lf\n",pPS->vColorStart[2]);
  fprintf(debug,"%lf\n",pPS->vColorEnd[0]);
  fprintf(debug,"%lf\n",pPS->vColorEnd[1]);
  fprintf(debug,"%lf\n",pPS->vColorEnd[2]);
  fprintf(debug,"Color Var %lf\n",pPS->vColorVar[0]);
  fprintf(debug,"Rate %ld\n",pPS->uParticlesPerSec);
  fprintf(debug,"NumP %ld\n",pPS->NumP);
  fprintf(debug,"AS %lf\n",pPS->fAlphaStart);
  fprintf(debug,"AV %lf\n",pPS->fAlphaVar);
  fprintf(debug,"AE %lf\n",pPS->fAlphaEnd);
  fprintf(debug,"size %lf\n",pPS->fSizeStart);
  fprintf(debug,"size var %lf\n",pPS->fSizeVar);
  fprintf(debug,"size end %lf\n",pPS->fSizeEnd);
  fprintf(debug,"speed %lf\n",pPS->fSpeed);
  fprintf(debug,"speed var %lf\n",pPS->fSpeedVar);
  fprintf(debug,"theta %lf\n",pPS->fTheta);
  fprintf(debug,"lifetime %lf\n",pPS->fLifeTime);
  fprintf(debug,"life var%lf\n",pPS->fLifeVar);
  fprintf(debug,"particle size scale %lf\n",pPS->fSizeScale);
  fprintf(debug,"Gravity\n");
  fprintf(debug,"s %lf\n",pPS->vGravityStart[0]);
  fprintf(debug,"s %lf\n",pPS->vGravityStart[1]);
  fprintf(debug,"s %lf\n",pPS->vGravityStart[2]);
  fprintf(debug,"e %lf\n",pPS->vGravityEnd[0]);
  fprintf(debug,"e %lf\n",pPS->vGravityEnd[1]);
  fprintf(debug,"e %lf\n",pPS->vGravityEnd[2]);
}
#endif
if(pPS->NumP > 0){
  pPS->particles=(Particle *)X__Malloc(pPS->NumP*sizeof(Particle));
  for(i=0;i<pPS->NumP;i++){
    pPS->particles[i].fAge = -1.0;  // particle is not part of the system initially
  }
}
else pPS->particles=NULL;
return (TRUE);
}

// update the particle system to the new time (using old time as starting point)
// this is called as part of the startup process to bring the particle system up to
// date for the frame being rendered.
static void UpdateParticleSystem(ParticleSystem *pPS, double fTime){
 int i;
 vector vLocation;
 double fTimeDelta;
 double fParticlesNeeded;
 double RandomYaw;
 double RandomPitch;
 double fNewSpeed;
 unsigned int uParticlesCreated,uParticlesAlive;
 Particle *pP;
 fTimeDelta = fTime - pPS->fTimeLastUpdate;
 pPS->fTimeLastUpdate = fTime;
 vLocation[0] = 0.0f;
 vLocation[1] = 0.0f;
 vLocation[2] = 0.0f;
 uParticlesAlive = 0;
 pP = pPS->particles;
 if(pP == NULL)return;
 for(i=0;i<pPS->NumP;i++){  // update the particles
   if (pP[i].fAge >= 0.0f ){
     if(UpdateParticle(&(pP[i]),fTimeDelta ))uParticlesAlive++;
   }
 }
 fParticlesNeeded = pPS->uParticlesPerSec * fTimeDelta + pPS->fEmissionResidue;
 if(pPS->bSuppress){
   uParticlesCreated = 0;
   pPS->fEmissionResidue = 0.0;
 }
 else{
   uParticlesCreated = (unsigned int)fParticlesNeeded;
   pPS->fEmissionResidue = fParticlesNeeded - uParticlesCreated;
 }
 //if(debug != NULL)fprintf(debug,"Update particle system time=%lf dt=%lf Up created=%ld alive=%ld\n",fTime,fTimeDelta,uParticlesCreated,uParticlesAlive);
 if (uParticlesCreated > 0 ) {
   for (i=0; i<pPS->NumP; i++ ){
    if(!uParticlesCreated)break;
    if( pP[i].fAge < 0.0f ) {
       pP[i].fAge = 0.0f;
       pP[i].fLifetime = pPS->fLifeTime+RAND_N * pPS->fLifeVar;
       Clamp( pP[i].fLifetime, MIN_LIFETIME, MAX_LIFETIME ); 
       pP[i].fAlpha = pPS->fAlphaStart + RAND_N * pPS->fAlphaVar;
       Clamp( pP[i].fAlpha, MIN_ALPHA, MAX_ALPHA );
       pP[i].fAlphaDelta = (pPS->fAlphaEnd - pP[i].fAlpha) / pP[i].fLifetime;
       pP[i].c[0] = pPS->vColorStart[0] + RAND_N * pPS->vColorVar[0];
       pP[i].c[1] = pPS->vColorStart[1] + RAND_N * pPS->vColorVar[1];
       pP[i].c[2] = pPS->vColorStart[2] + RAND_N * pPS->vColorVar[2];
       Clamp( pP[i].c[0], 0.0f, 1.0f );
       Clamp( pP[i].c[1], 0.0f, 1.0f );
       Clamp( pP[i].c[2], 0.0f, 1.0f );
       pP[i].dc[0]=((pPS->vColorEnd[0]+RAND_N*pPS->vColorVar[0])-pP[i].c[0])/pP[i].fLifetime;
       pP[i].dc[1]=((pPS->vColorEnd[1]+RAND_N*pPS->vColorVar[1])-pP[i].c[1])/pP[i].fLifetime;
       pP[i].dc[2]=((pPS->vColorEnd[2]+RAND_N*pPS->vColorVar[2])-pP[i].c[2])/pP[i].fLifetime;
       pP[i].fSize= pPS->fSizeStart + RAND_N * pPS->fSizeVar;
       Clamp( pP[i].fSize, MIN_SIZE, MAX_SIZE );
       pP[i].fSizeDelta = (pPS->fSizeEnd - pP[i].fSize) / pP[i].fLifetime;
       pP[i].g[0]=pPS->vGravityStart[0]*GRAVITY+RAND_N*pPS->fGravityVar*GRAVITY;
       Clamp( pP[i].g[0], MIN_GRAVITY*GRAVITY, MAX_GRAVITY*GRAVITY );
       pP[i].g[1]=pPS->vGravityStart[1]*GRAVITY+RAND_N*pPS->fGravityVar*GRAVITY;
       Clamp( pP[i].g[1], MIN_GRAVITY*GRAVITY, MAX_GRAVITY*GRAVITY );
       pP[i].g[2]=pPS->vGravityStart[2]*GRAVITY+RAND_N*pPS->fGravityVar*GRAVITY;
       Clamp( pP[i].g[2], MIN_GRAVITY*GRAVITY, MAX_GRAVITY*GRAVITY );
       pP[i].dg[0] = ( pPS->vGravityEnd[0]*GRAVITY - pP[i].g[0] ) / pP[i].fLifetime;
       pP[i].dg[1] = ( pPS->vGravityEnd[1]*GRAVITY - pP[i].g[1] ) / pP[i].fLifetime;
       pP[i].dg[2] = ( pPS->vGravityEnd[2]*GRAVITY - pP[i].g[2] ) / pP[i].fLifetime;
       pPS->vTempVelocity[0] = (pPS->vLocation[0] - pPS->vPrevLocation[0])/fTimeDelta;
       pPS->vTempVelocity[1] = (pPS->vLocation[1] - pPS->vPrevLocation[1])/fTimeDelta;
       pPS->vTempVelocity[2] = (pPS->vLocation[2] - pPS->vPrevLocation[2])/fTimeDelta;
       pP[i].p[0] = pPS->vPrevLocation[0];
       pP[i].p[1] = pPS->vPrevLocation[1];
       pP[i].p[2] = pPS->vPrevLocation[2];
       pP[i].pl[0] = pP[i].p[0];
       pP[i].pl[1] = pP[i].p[1];
       pP[i].pl[2] = pP[i].p[2];
       RandomYaw = RAND_N * 3.14159f * 2.0f;
       RandomPitch = RAND_N * pPS->fTheta * 3.14159f;
       pP[i].v[2] = cos( RandomPitch );  // up - down 
       pP[i].v[0] = sin(RandomPitch) * cos(RandomYaw);
       pP[i].v[1] = sin(RandomPitch) * sin(RandomYaw);
       fNewSpeed = pPS->fSpeed + RAND_N * pPS->fSpeedVar;
       Clamp( fNewSpeed, MIN_SPEED, MAX_SPEED );
       pP[i].v[0] *= fNewSpeed ;
       pP[i].v[1] *= fNewSpeed ;
       pP[i].v[2] *= fNewSpeed ;
       if(pPS->bSpinOff)FreeThisParticle(&(pP[i]),pPS);
       else pP[i].bSpin=FALSE; 
       uParticlesCreated--;
     }
   }
 }
 VECCOPY(pPS->vLocation,pPS->vPrevLocation)
}

// update the position and other attribes of a particle within a particle system 
static BOOL UpdateParticle(Particle *p,  double fTimeDelta ){
 if ( p->fAge + fTimeDelta >= p->fLifetime ) {
   p->fAge = -1.0f;
   return FALSE;
 }
 else{
   p->fAge += fTimeDelta;
   VECCOPY(p->p,p->pl)
   VECSUM(p->p,fTimeDelta*p->v,p->p)
   VECSUM(p->v,9.8*fTimeDelta*p->g,p->v)  
   p->fAlpha += p->fAlphaDelta * fTimeDelta;
   VECSUM(p->c,fTimeDelta*p->dc,p->c)
   p->fSize += p->fSizeDelta * fTimeDelta;
   VECSUM(p->g,fTimeDelta*p->dg,p->g)
   if(p->bSpin && R_Nground > 0){
     if(p->p[2] < Ground.pin[2]){
       p->p[2]=Ground.pin[2];  // don't allow to go below ground
       p->v[2] = -0.5*p->v[2]; // rebound
     }
   }
 }
 return TRUE;
}


static void FreeThisParticle(Particle *p, ParticleSystem *Pp){
 // the particle breaks free from the particle system local frame of reference and moves so that
 // it is now relative to the global reference frame.  Things like smoke from a steam train, or a moving
 // flame drift off.
 vector t;
 p->bSpin=TRUE;
 R_m4by1(Pp->particle_object_transformation,
         p->p[0]*PARTICLE_SCALE,p->p[1]*PARTICLE_SCALE,p->p[2]*PARTICLE_SCALE,
         &t[0],&t[1],&t[2]);
 VECCOPY(t,p->p);
 R_m3by1(Pp->particle_object_transformation, 
         p->v[0]*PARTICLE_SCALE,p->v[1]*PARTICLE_SCALE,p->v[2]*PARTICLE_SCALE,
         &t[0],&t[1],&t[2]);
 VECCOPY(t,p->v);
#if 0
 // perhaps gravity should always be downward
 R_m3by1(Pp->particle_object_transformation, 
         p->g[0]*PARTICLE_SCALE,p->g[1]*PARTICLE_SCALE,p->g[2]*PARTICLE_SCALE,
         &t[0],&t[1],&t[2]);
 VECCOPY(t,p->g);
 R_m3by1(Pp->particle_object_transformation, 
         p->dg[0]*PARTICLE_SCALE,p->dg[1]*PARTICLE_SCALE,p->dg[2]*PARTICLE_SCALE,
         &t[0],&t[1],&t[2]);
 VECCOPY(t,p->dg);
#else
 VECSCALE(PARTICLE_SCALE,p->g,p->g) 
 VECSCALE(PARTICLE_SCALE,p->dg,p->dg) 
#endif

}

static void InterpolateParticleSystemPosition(ParticleSystem *Ps, double ratio){
 double dp;
 vector dv;
 dp = Ps->dPhi - Ps->sdPhi;
 if(dp < -180.0)dp += 360.0;
 if(dp >  180.0)dp -= 360.0;
 dp *= ratio;
 dp += Ps->sdPhi;
 if(dp < -180.0)dp += 360.0;
 if(dp >  180.0)dp -= 360.0;
 Ps->tdPhi = dp;
 dp = Ps->dAlpha - Ps->sdAlpha;
 if(dp < -180.0)dp += 360.0;
 if(dp >  180.0)dp -= 360.0;
 dp *= ratio;
 dp += Ps->sdAlpha;
 if(dp < -180.0)dp += 360.0;
 if(dp >  180.0)dp -= 360.0;
 Ps->tdAlpha = dp;
 dp = Ps->dTheta - Ps->sdTheta;
 if(dp < -180.0)dp += 360.0;
 if(dp >  180.0)dp -= 360.0;
 dp *= ratio;
 dp += Ps->sdTheta;
 if(dp < -180.0)dp += 360.0;
 if(dp >  180.0)dp -= 360.0;
 Ps->tdTheta = dp;
 VECSUB(Ps->pin,Ps->spin,dv)
 VECSCALE(ratio,dv,dv)
 VECSUM(Ps->spin,dv,Ps->tpin)
 Ps->tsx=(Ps->sx-Ps->ssx)*ratio+Ps->ssx;
 Ps->tsy=(Ps->sx-Ps->ssy)*ratio+Ps->ssy;
 Ps->tsz=(Ps->sx-Ps->ssz)*ratio+Ps->ssz;
}

static void DrawParticleSystemGL(BOOL clip, ParticleSystem *Ps){ // Draw the current state of a speciifc particle system - i.e. where are all the particles
 int np,i;
 Particle *p;
 GLfloat xc,yc,zc;
 GLfloat psize;
 np=Ps->NumP;
 if(np < 1 || Ps->particles == NULL)return;
 if(R_Nground > 0){
   GLdouble GroundClip[4];
   GroundClip[0]=-Ground.n[0]; GroundClip[1]=-Ground.n[2]; GroundClip[2]=Ground.n[1];
   GroundClip[3]=DOT(Ground.n,Ground.p)*GlobalScale; 
   glEnable(GL_CLIP_PLANE0); 
   glClipPlane(GL_CLIP_PLANE0,GroundClip);
 }
 glBindTexture(GL_TEXTURE_2D,g_particle_textures[Ps->iid]);
 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 glEnable(GL_BLEND);
 if(Ps->blend_type == 1)glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 else glBlendFunc(GL_SRC_ALPHA,GL_ONE);
 glDepthMask(GL_FALSE);
 glBegin(GL_QUADS);
 for(i=0;i<np;i++){  // render all the particles in the particle system 
   p=&Ps->particles[i];
   if(p->fAge < 0.0)continue;    // don't render particles that are not active
   if(p->pfx[1] < 0.0)continue;  // don't render particles behind viewpoint
   glColor4f(p->c[0],p->c[1],p->c[2],p->fAlpha);  //   glColor4f(p->c[0],p->c[1],p->c[2],2.0);
   xc =  (p->pfx[0])*GlobalScale;
   yc =  (p->pfx[2])*GlobalScale;
   zc = -(p->pfx[1])*GlobalScale;
   psize=p->fSize*SIZE_SCALE*PARTICLE_SCALE/p->pfx[1]*Ps->sx*Ps->fSizeScale;
   glTexCoord2f(1.0f, 1.0f); glVertex3f(xc+psize,  yc+psize, zc); // Top Right 
   glTexCoord2f(0.0f, 1.0f); glVertex3f(xc-psize,  yc+psize, zc); // Top Left
   glTexCoord2f(0.0f, 0.0f); glVertex3f(xc-psize,  yc-psize, zc); // Bottom left
   glTexCoord2f(1.0f, 0.0f); glVertex3f(xc+psize,  yc-psize, zc); // Bottom right
 }
 glEnd();
 glDepthMask(GL_TRUE);
 glDisable(GL_BLEND);
 glBindTexture(GL_TEXTURE_2D,0);
 if(R_Nground > 0)glDisable(GL_CLIP_PLANE0);
}

void RenderParticlesGL(BOOL clip){
 int i;
 for(i=0;i<Nparticles;i++){  // for the particle systems
   DrawParticleSystemGL(clip,&(ParticleS[i]));
 }
}

static void DrawParticleSystem(ParticleSystem *Ps){ // Draw the current particle system as it is.
 int np,i,ix,iy;
 Particle *p;
 GLfloat xc,yc,zc;
 GLfloat psize;
 fullscreenbuffer *S;
 float *Z;
 double Xscale,Yscale,xxl,yyt,xxr,yyb;
 np=Ps->NumP;    // number of particles to be rendered
 if(np < 1 || Ps->particles == NULL)return;
 S=FullScreenBuffer;
 Z=fszBuffer;
 Xscale=scalex; Yscale=scaley;
 if(anti_alias == LOW)   {Xscale /= 2;}
 if(anti_alias == MEDIUM){Xscale /= 2; Yscale /= 2;}
 if(anti_alias == HIGH)  {Xscale /= 3; Yscale /= 2;}
 if(anti_alias == ULTRA) {Xscale /= 3; Yscale /= 3;}
 for(i=0;i<np;i++){
   p=&Ps->particles[i];
   if(p->fAge < 0.0)continue;    // don't render particles that are not active
   if(p->pfx[1] < 0.0)continue;  // don't render particles behind viewpoint
   xc =  (p->pfx[0]);
   yc =  (p->pfx[1]);
   zc =  (p->pfx[2]);
   psize=p->fSize*4.8*PARTICLE_SCALE*Ps->sx*Ps->fSizeScale;  // 4.5 is to make particles same size as GPU version
   xxl=(double)ResolutionX/2.0 + (Xscale*(xc-psize)/yc);
   yyt=(double)ResolutionY/2.0 - (Yscale*(zc+psize)/yc);
   xxr=(double)ResolutionX/2.0 + (Xscale*(xc+psize)/yc);
   yyb=(double)ResolutionY/2.0 - (Yscale*(zc-psize)/yc);
   // the software renderer has to blend the particle image into the output buffer - it has to 
   // take account of the depth buffer so that the particles can appear to move behind other objects.
   // the GPU renderer does this naturally.)
   BlendFrameBufferParticle(xxl,yyt,xxr,yyb,yc,Ps->iid,Ps->blend_type,p,S,Z);
 }
}

static void BlendFrameBufferPixel(long ix, long iy, double f, double z, double r, double g, double b, double a,
                                  fullscreenbuffer *S, float *Z, long type){
 double R,G,B;
 if(ix>=0 && ix<ResolutionX && iy>=0 && iy<ResolutionY){
   if((float)z<*(Z+(iy*(ResolutionX))+ix)){
     R=(double)( (S+(iy*(ResolutionX))+ix)->R);
     G=(double)( (S+(iy*(ResolutionX))+ix)->G);
     B=(double)( (S+(iy*(ResolutionX))+ix)->B);
     if(type == 1){ // blend
       R=min(255.0, R*(1.0-a) + 255.0*r*f*a); 
       G=min(255.0, G*(1.0-a) + 255.0*g*f*a);
       B=min(255.0, B*(1.0-a) + 255.0*b*f*a);
     }
     else{ // burn
       R=min(255.0, R + 255.0*r*f*a); 
       G=min(255.0, G + 255.0*g*f*a);
       B=min(255.0, B + 255.0*b*f*a);
     }
     (S+(iy*(ResolutionX))+ix)->R=(unsigned char)R;
     (S+(iy*(ResolutionX))+ix)->G=(unsigned char)G;
     (S+(iy*(ResolutionX))+ix)->B=(unsigned char)B;
//        *(Z+(iy*(ResolutionX))+ix)=Yview;  /*update the Z-buffer with the new depth value*/
     }
 }
}

static void BlendFrameBufferParticle(double xxl, double yyt, double xxr, double yyb,
                                double z, long pid, long blend_type, Particle *p, fullscreenbuffer *S, float *Z){
 long i,j,ix,iy,xin;
 long idx,idy;
 double dx,dy,cr,cg,cb,ca,cr0,cg0,cb0,ca0;
 unsigned char *image,*simage,*si;
 dx=(xxr-xxl);
 dy=(yyb-yyt);
 idy=(long)dy+1;
 idx=(long)dx+1;
 dx=xxr-floor(xxr); dy=yyt-floor(yyt);
 if((image=ParticleImages[pid]) == NULL)return;
 xin=ParticleImageSize[pid];
 if(ParticleBits[pid]){ // 4 bits per pixel
   simage=(unsigned char *)X__Malloc(idx*idy*4);
   if(simage == NULL)return;
   ScaleImageBuffer4(xin,xin,image,idx,idy,simage);
  }
 else{
   simage=(unsigned char *)X__Malloc(idx*idy*3);
   if(simage == NULL)return;
   ScaleImageBuffer3(xin,xin,image,idx,idy,simage);
 }
 cr0=p->c[0]/255.0;  cg0=p->c[1]/255.0; cb0=p->c[2]/255.0; ca0=p->fAlpha;
 si=simage;
 iy=(long)yyt; for(i=0;i<idy;i++){
   ix=(long)xxl; for(j=0;j<idx;j++){
     cr = cr0*(double)(*si++); cg = cg0*(double)(*si++); cb = cb0*(double)(*si++);
     if(ParticleBits[pid]) ca = ca0*(double)(*si++)/255.0; else ca=ca0;
     BlendFrameBufferPixel(ix,iy,(1.0-dx)*(1.0-dy),z,cr,cg,cb,ca,S,Z,blend_type);
     BlendFrameBufferPixel(ix+1,iy,(dx)*(1.0-dy),z,cr,cg,cb,ca,S,Z,blend_type);
     BlendFrameBufferPixel(ix,iy+1,(1.0-dx)*(dy),z,cr,cg,cb,ca,S,Z,blend_type);
     BlendFrameBufferPixel(ix+1,iy+1,(dx)*(dy),z,cr,cg,cb,ca,S,Z,blend_type);
     ix++;
   }
   iy++;
 }
 if(simage != NULL)X__Free(simage);
}


void RenderParticles(void){  // render into frame buffer 
 int i;
 for(i=0;i<Nparticles;i++){
   DrawParticleSystem(&(ParticleS[i]));
 }
}


#if 0
   if ((long)xx>=0 && (long)xx<ResolutionX && (long)yy>=0 && (long)yy<ResolutionY){
 // glBindTexture(GL_TEXTURE_2D,g_particle_textures[Ps->iid]);
//   glColor4f(p->c[0],p->c[1],p->c[2],p->fAlpha);  //   glColor4f(p->c[0],p->c[1],p->c[2],2.0);
//   glTexCoord2f(1.0f, 1.0f); glVertex3f(xc+psize,  yc+psize, zc); // Top Right 
//   glTexCoord2f(0.0f, 1.0f); glVertex3f(xc-psize,  yc+psize, zc); // Top Left
//   glTexCoord2f(0.0f, 0.0f); glVertex3f(xc-psize,  yc-psize, zc); // Bottom left
//   glTexCoord2f(1.0f, 0.0f); glVertex3f(xc+psize,  yc-psize, zc); // Bottom right
     ix=(long)xx;
     iy=(long)yy;
     if((float)yc<*(Z+(iy*(ResolutionX))+ix)){
        (S+(iy*(ResolutionX))+ix)->R=255;
        (S+(iy*(ResolutionX))+ix)->G=255;
        (S+(iy*(ResolutionX))+ix)->B=255;
//        *(Z+(iy*(ResolutionX))+ix)=Yview;  /*update the Z-buffer with the new depth value*/
     }
   }
#endif

#if 0
 //                   bottom                 top                back               front
 GLfloat x[16]={-1.0, 1.0, 1.0,-1.0,  -1.0, 1.0, 1.0,-1.0,   -1.0, 1.0, 1.0,-1.0,  -1.0, 1.0, 1.0,-1.0};
 GLfloat y[16]={-1.0,-1.0, 1.0, 1.0,  -1.0,-1.0, 1.0, 1.0,   -1.0,-1.0,-1.0,-1.0,   1.0, 1.0, 1.0, 1.0}; 
 GLfloat z[16]={-1.0,-1.0,-1.0,-1.0,   1.0, 1.0, 1.0, 1.0,   -1.0,-1.0, 1.0, 1.0,  -1.0,-1.0, 1.0, 1.0};
 glBegin(GL_QUADS);
 glColor4ub(0,255,255,255);
 for(i=0;i<4*4;i++){
 glVertex3f(  (x[i]*PARTICLE_SCALE+Ps->p[0])*GlobalScale,
              (z[i]*PARTICLE_SCALE+Ps->p[2])*GlobalScale,
             -(y[i]*PARTICLE_SCALE+Ps->p[1])*GlobalScale);

 }
 glEnd();

 glPointSize(4.0);
 glBegin(GL_POINTS);
 glColor4ub(0,255,255,255);
 for(i=0;i<np;i++){
  p=&Ps->particles[i];
  if(p->fAge < 0.0)continue;
 // glVertex3f(  (p->p[0]*PARTICLE_SCALE+Ps->p[0])*GlobalScale,
 //              (p->p[2]*PARTICLE_SCALE+Ps->p[2])*GlobalScale,
 //             -(p->p[1]*PARTICLE_SCALE+Ps->p[1])*GlobalScale);
  glVertex3f(  (p->pfx[0])*GlobalScale,
               (p->pfx[2])*GlobalScale,
              -(p->pfx[1])*GlobalScale);
 }
 glEnd();


                                //this uses spherical coordinates to randomize the velocity vector ( or the direction ) of the m_rParticles
                                m_rParticles[i].m_vVelocity.y = static_cast<float>(cos( RandomPitch ));
                                m_rParticles[i].m_vVelocity.x = static_cast<float>(sin(RandomPitch) * cos(RandomYaw));
                                m_rParticles[i].m_vVelocity.z = static_cast<float>(sin(RandomPitch) * sin(RandomYaw));

                                /*
                                // Velocity at this point is just a direction (normalized vector ) and needs to be multiplied by 
                                // the speed component to be a true velocity
                                float fNewSpeed = m_fSpeed + RANDOM_NUM * m_fSpeedVar;
                                Clamp( fNewSpeed, MIN_SPEED, MAX_SPEED );
                                */

                                // Multiply Velocity by speed
                                m_rParticles[i].m_vVelocity.x *= m_fSpeed ;
                                m_rParticles[i].m_vVelocity.y *= m_fSpeed ;
                                m_rParticles[i].m_vVelocity.z *= m_fSpeed ;


/*
                                m_rParticles[i].m_vVelocity.y = (0.5f-RANDOM_NUM)* RANDOM_NUM;// * m_fSpeedVar;
                                m_rParticles[i].m_vVelocity.x = (0.5f-RANDOM_NUM)* RANDOM_NUM;// * m_fSpeedVar;
                                m_rParticles[i].m_vVelocity.z = (0.5f-RANDOM_NUM)* RANDOM_NUM;// * m_fSpeedVar;

                                m_rParticles[i].m_vVelocity.x *= m_fSpeed ;
                                m_rParticles[i].m_vVelocity.y *= m_fSpeed ;
                                m_rParticles[i].m_vVelocity.z *= m_fSpeed ;

*/
                                // let the m_rParticles know who it's Daddy is


//   fprintf(debug,"Particle Age=%lf  Alpha=%lf  Lifetime=%lf deltaT=%lf  deltaAlpha=%lf\n",
//   p->fAge,p->fAlpha,p->fLifetime,fTimeDelta,p->fAlphaDelta);
//   fprintf(debug,"velocity %lf %lf %lf\n",p->v[0],p->v[1],p->v[2]);
//   fprintf(debug,"gravity %lf %lf %lf\n",p->g[0],p->g[1],p->g[2]);

// defaults
pPS->vColorStart[0] = 0.48f; 
pPS->vColorStart[1] = 0.42f; 
pPS->vColorStart[2] = 0.10f; 
pPS->vColorVar[0] = 0.15f; 
pPS->vColorVar[1] = 0.15f; 
pPS->vColorVar[2] = 0.15f; 
pPS->vColorEnd[0] = 0.04f; 
pPS->vColorEnd[1] = 0.22f; 
pPS->vColorEnd[2] = 0.81f; 
pPS->fAlphaStart = 0.92f; 
pPS->fAlphaVar   = 0.14f; 
pPS->fAlphaEnd   = 0.14f; 
pPS->fSizeStart  = 1.04f; 
pPS->fSizeVar    = 0.04f; 
pPS->fSizeEnd    = 1.08f; 
pPS->fSpeed      = 3.00f; 
pPS->fSpeedVar   = 0.00f; 
pPS->fTheta      = 0.20f; 
pPS->fLifeTime   = 0.60f; 
pPS->fLifeVar    = 0.10f; 
pPS->vGravityStart[0] = 0.00f; 
pPS->vGravityStart[1] = 0.00f; 
pPS->vGravityStart[2] = 0.00f; 
pPS->vGravityEnd[0]= 0.00f; 
pPS->vGravityEnd[1]= 0.00f; 
pPS->vGravityEnd[2]= 0.00f; 
pPS->fGravityVar   = 0.00f; 
pPS->fSizeScale    = 1.0;
pPS->uParticlesPerSec = 20;  // related to NumP  - should be the default
pPS->NumP=60;                // should be enougg for all particles to be alive   no/sec * lifetime    

#endif