281 lines
9.6 KiB
C
Executable File
281 lines
9.6 KiB
C
Executable File
#ifndef __PARTICLE_H__
|
|
#define __PARTICLE_H__
|
|
|
|
#include "common.h"
|
|
|
|
/* max particles per emitter */
|
|
#define MAX_PARTICLES 256
|
|
|
|
typedef struct {
|
|
GLint aliveTime; /* time the particle's been alive */
|
|
GLint lifetime; /* how long this particle should stay alive (in ms) */
|
|
GLfloat alpha;
|
|
Vector speed;
|
|
Vector pos;
|
|
Vector iGrav;
|
|
} Particle;
|
|
|
|
typedef struct {
|
|
GLboolean active; /* emitter active? */
|
|
GLint lifetime; /* base lifetime of particles from this emitter */
|
|
GLint lifeEdge; /* the random adjustment to each particle's lifetime
|
|
(between lifeEdge and lifeEdge*2) */
|
|
GLfloat alphaFade; /* a floating point value between 0.0 and 1.0 that tells
|
|
how much transparency should be added to the particle each frame */
|
|
|
|
Vector pos; /* base position of particles from this emitter */
|
|
Vector speed; /* base speed (direction) of particles from this emitter */
|
|
Vector pGrav; /* the base x, y, and z gravity acting on
|
|
particles from this emitter*/
|
|
|
|
Vector rSpeed; /* the random speed adjustment applied to particles */
|
|
Vector rGrav; /* the random gravity adjustment applied to particles */
|
|
Vector rPos; /* the random position adjustment applied to particles */
|
|
|
|
Particle particles[MAX_PARTICLES]; /* the actual particles */
|
|
GLfloat texCoords[4][2]; // the texture coordinates for all quad or triangle particles
|
|
GLuint texHandle; /* the texture handle for all particles from this emitter*/
|
|
GLuint pType; /* GL_POINTS, GL_TRIANGLES, or GL_QUADS.*/
|
|
GLfloat color[3]; /* color of particles in this emitter */
|
|
|
|
GLfloat size[2]; /* the size in X and Y of all particles from this emitter */
|
|
|
|
} PEmitter;
|
|
|
|
|
|
void DrawParticle(Particle *particle, PEmitter *emitter)
|
|
{
|
|
|
|
/* set up the texturing if we're not doing points */
|
|
if ( emitter->pType != GL_POINTS ) {
|
|
glBindTexture(GL_TEXTURE_2D, emitter->texHandle);
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
glBegin(emitter->pType);
|
|
|
|
if ( emitter->pType == GL_TRIANGLES ) {
|
|
glColor3f(emitter->color[0],
|
|
emitter->color[1],
|
|
emitter->color[2]);
|
|
glTexCoord2f(emitter->texCoords[0][0],
|
|
emitter->texCoords[0][1]);
|
|
glVertex3f(particle->pos.x - ( emitter->size[0] / 2),
|
|
particle->pos.y - ( emitter->size[1] / 2),
|
|
particle->pos.z);
|
|
|
|
glColor3f(emitter->color[0],
|
|
emitter->color[1],
|
|
emitter->color[2]);
|
|
glTexCoord2f(emitter->texCoords[1][0],
|
|
emitter->texCoords[1][1]);
|
|
glVertex3f(particle->pos.x + ( emitter->size[0] / 2),
|
|
particle->pos.y - ( emitter->size[1] / 2),
|
|
particle->pos.z);
|
|
|
|
glColor3f(emitter->color[0],
|
|
emitter->color[1],
|
|
emitter->color[2]);
|
|
glTexCoord2f(emitter->texCoords[2][0],
|
|
emitter->texCoords[2][1]);
|
|
glVertex3f(particle->pos.x,
|
|
particle->pos.y + ( emitter->size[1] / 2),
|
|
particle->pos.z);
|
|
}
|
|
|
|
else if ( emitter->pType == GL_QUADS ) {
|
|
glColor3f(emitter->color[0],
|
|
emitter->color[1],
|
|
emitter->color[2]);
|
|
glTexCoord2f(emitter->texCoords[0][0],
|
|
emitter->texCoords[0][1]);
|
|
glVertex3f(particle->pos.x - ( emitter->size[0] / 2),
|
|
particle->pos.y + ( emitter->size[1] / 2),
|
|
particle->pos.z);
|
|
|
|
glColor3f(emitter->color[0],
|
|
emitter->color[1],
|
|
emitter->color[2]);
|
|
glTexCoord2f(emitter->texCoords[1][0],
|
|
emitter->texCoords[1][1]);
|
|
glVertex3f(particle->pos.x + ( emitter->size[0] / 2),
|
|
particle->pos.y - ( emitter->size[1] / 2),
|
|
particle->pos.z);
|
|
|
|
glColor3f(emitter->color[0],
|
|
emitter->color[1],
|
|
emitter->color[2]);
|
|
glTexCoord2f(emitter->texCoords[2][0],
|
|
emitter->texCoords[2][1]);
|
|
glVertex3f(particle->pos.x + ( emitter->size[0] / 2),
|
|
particle->pos.y - ( emitter->size[1] / 2),
|
|
particle->pos.z);
|
|
|
|
glColor3f(emitter->color[0],
|
|
emitter->color[1],
|
|
emitter->color[2]);
|
|
glTexCoord2f(emitter->texCoords[3][0],
|
|
emitter->texCoords[3][1]);
|
|
glVertex3f(particle->pos.x + ( emitter->size[0] / 2),
|
|
particle->pos.y + ( emitter->size[1] / 2),
|
|
particle->pos.z);
|
|
}
|
|
else {
|
|
glColor4f(emitter->color[0], emitter->color[1], emitter->color[2], particle->alpha);
|
|
glVertex3f(particle->pos.x, particle->pos.y, particle->pos.z);
|
|
|
|
}
|
|
|
|
glEnd();
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
GLuint DrawEmitter(PEmitter *emitter)
|
|
{
|
|
/* this function assumes the viewport and etc has already been setup
|
|
* (e.g., call this from within your main GL drawing function) */
|
|
|
|
int i = 0;
|
|
Particle *currParticle;
|
|
|
|
if ( !emitter ) {
|
|
return 1;
|
|
}
|
|
|
|
if ( emitter->active != GL_TRUE ) {
|
|
return 0; // emitter not active, but this isn't an error
|
|
}
|
|
|
|
for ( i = 0 ; i < MAX_PARTICLES ; i++ ) {
|
|
currParticle = &emitter->particles[i];
|
|
|
|
/* draw the particle given its type */
|
|
DrawParticle(currParticle, emitter);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void ResetParticle(Particle *particle, PEmitter *emitter)
|
|
{
|
|
particle->aliveTime = 0;
|
|
|
|
/* get a new lifetime for the particle based on the base from the emitter + random adj */
|
|
particle->lifetime = emitter->lifetime + (rand() % (emitter->lifeEdge*2)) - emitter->lifeEdge;
|
|
particle->alpha = 1.0F;
|
|
|
|
/* reset the particle's x, y, z position from the emitter base */
|
|
vectorCopy(&particle->pos, &emitter->pos);
|
|
if ( emitter->rPos.x != 0.0f)
|
|
particle->pos.x += frand( emitter->rPos.x);
|
|
if ( emitter->rPos.y != 0.0f )
|
|
particle->pos.y += frand( emitter->rPos.y );
|
|
if ( emitter->rPos.z != 0.0f )
|
|
particle->pos.z += frand( emitter->rPos.z );
|
|
|
|
/* reset the particle's gravity from the base gravity of the emitter + rand adjust */
|
|
vectorCopy(&particle->iGrav, &emitter->pGrav);
|
|
if ( emitter->rGrav.x != 0.0f )
|
|
particle->iGrav.x += frand( emitter->rGrav.x );
|
|
if ( emitter->rGrav.y != 0.0f )
|
|
particle->iGrav.y += frand( emitter->rGrav.y );
|
|
if ( emitter->rGrav.z != 0.0f )
|
|
particle->iGrav.z += frand( emitter->rGrav.z );
|
|
|
|
/* reset the particle's speed from the base gravity of the emitter + rand adjust */
|
|
vectorCopy(&particle->speed, &emitter->speed);
|
|
if ( emitter->rSpeed.x != 0.0f )
|
|
particle->speed.x += frand( emitter->rSpeed.x);
|
|
if ( emitter->rSpeed.y != 0.0f )
|
|
particle->speed.y += frand( emitter->rSpeed.y);
|
|
if ( emitter->rSpeed.z != 0.0f )
|
|
particle->speed.z += frand( emitter->rSpeed.z);
|
|
}
|
|
|
|
void UpdateEmitter(PEmitter *emitter, GLuint timePassed)
|
|
{
|
|
/* here's where we do the emitter's logic. It's assumed
|
|
* we're being called once per frame, so we don't do any
|
|
* time calculations, other than updating the lifetimes
|
|
* ... timePassed is the number of ms passed since the last call */
|
|
|
|
int i = 0;
|
|
Particle *currParticle;
|
|
|
|
for ( i = 0 ; i < MAX_PARTICLES ; i++ ) {
|
|
currParticle = &emitter->particles[i];
|
|
|
|
currParticle->aliveTime += timePassed;
|
|
|
|
if ( currParticle->aliveTime >= currParticle->lifetime ) {
|
|
/* this particle has died; set it to inactive and reset its lifetime/pos/dir */
|
|
ResetParticle(currParticle,emitter);
|
|
continue;
|
|
}
|
|
|
|
/* apply gravity and such to the particle */
|
|
|
|
currParticle->speed.x += currParticle->iGrav.x;
|
|
currParticle->speed.y += currParticle->iGrav.y;
|
|
currParticle->speed.z += currParticle->iGrav.z;
|
|
|
|
currParticle->pos.x += (currParticle->speed.x);
|
|
currParticle->pos.y += (currParticle->speed.y);
|
|
currParticle->pos.z += (currParticle->speed.z);
|
|
|
|
/* the alpha is a constant drop over the lifetime of the particle */
|
|
currParticle->alpha -= emitter->alphaFade;
|
|
}
|
|
}
|
|
|
|
GLuint PopulateEmitter(PEmitter *emitter,
|
|
GLboolean active,
|
|
GLfloat color[],
|
|
GLfloat alphaFade,
|
|
GLint lifetime,
|
|
Vector *pGrav,
|
|
Vector *pos,
|
|
Vector *speed,
|
|
Vector *rgrav,
|
|
Vector *rpos,
|
|
Vector *rspeed,
|
|
GLint lifeEdge,
|
|
GLuint pType,
|
|
GLuint texHandle)
|
|
{
|
|
int i = 0;
|
|
|
|
if ( !emitter ) {
|
|
return 1;
|
|
}
|
|
|
|
emitter->active = active;
|
|
|
|
emitter->color[0] = color[0];
|
|
emitter->color[1] = color[1];
|
|
emitter->color[2] = color[2];
|
|
|
|
emitter->lifetime = lifetime;
|
|
emitter->lifeEdge = lifeEdge;
|
|
emitter->alphaFade = alphaFade;
|
|
|
|
vectorCopy(&emitter->pGrav, pGrav);
|
|
vectorCopy(&emitter->pos, pos);
|
|
vectorCopy(&emitter->speed, speed);
|
|
vectorCopy(&emitter->rSpeed, rspeed);
|
|
vectorCopy(&emitter->rPos, rpos);
|
|
vectorCopy(&emitter->rGrav, rgrav);
|
|
|
|
|
|
emitter->pType = pType;
|
|
emitter->texHandle = texHandle;
|
|
|
|
for ( i = 0; i < MAX_PARTICLES; i++ ) {
|
|
ResetParticle(&emitter->particles[i],emitter);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif // __PARTICLE_H__
|