/**
* =========================================================================
* File : ParticleEmitter.h
* Project : 0 A.D.
* Description : Particle and Emitter base classes.
* =========================================================================
*/
#ifndef INCLUDED_PARTICLEEMITTER
#define INCLUDED_PARTICLEEMITTER
#include "maths/Vector3D.h"
class CTexture;
class CEmitter
{
static const int HALF_RAND = (RAND_MAX / 2);
public:
struct tColor
{
unsigned char r, g, b;
};
struct tParticle
{
// base stuff
CVector3D pos; // Current position 12
CVector3D dir; // Current direction with speed 12
float alpha; // Fade value 4
float alphaDelta; // Change of fade 4
tColor color; // Current color of particle 3
tColor deltaColor; // Change of color 3
short life; // How long it will last 2
// particle text stuff
CVector3D endPos; // For particle texture 12
bool inPos; // 1
tParticle* next; // pointer for link lists 4
tParticle()
{
next = 0;
}
};
//struct tParticleNode
//{
// tParticle* pParticle;
// tParticleNode* next;
//};
protected:
CTexture* texture; // Texture ID
bool isFinished; // tells the engine it's ready to be deleted
// Transformation Info
CVector3D pos; // XYZ Position
CVector3D finalPos; // Final position of the particles (IF IMPLOSION)
float yaw, yawVar; // Yaw and variation
float pitch, pitchVar; // Pitch and variation
float speed, speedVar; // Speed and variation
float updateSpeed; // Controls how fast emitter is updated.
float size; // size of the particles (if point sprites is not enabled)
// Particle
tParticle* heap; // Pointer to beginning of array
tParticle* openList; // linked list of unused particles
tParticle* usedList; // linked list of used particles
int blend_mode; // Method used to blend particles.
int max_particles; // Maximum particles emitter can put out
int particleCount; // Total emitted right now
int emitsPerFrame, emitVar; // Emits per frame and variation
int life, lifeVar; // Life count and variation (in Frames)
int emitterLife; // Life of the emitter
bool decrementLife; // Controls whether or not the particles life is decremented every update.
bool decrementAlpha; // Controls whether or not the particles alpha is decremented every update.
bool RenderParticles; // Controls the rendering of the particles.
tColor startColor, startColorVar; // Current color of particle
tColor endColor, endColorVar; // Current color of particle
// Physics
CVector3D force; // Forces that affect the particles
public:
CEmitter(const int MAX_PARTICLES = 4000, const int lifetime = -1, int textureID = 0);
virtual ~CEmitter(void);
// note: functions are virtual and overridable so as to suit the
// specific particle needs.
virtual bool Setup() { return false; }
virtual bool AddParticle();
virtual bool Update() { return false; }
virtual bool Render();
inline float RandomNum()
{
int rn;
rn = rand();
return ((float)(rn -HALF_RAND) / (float)HALF_RAND);
}
inline char RandomChar()
{
return (unsigned char)(rand() >> 24);
}
inline void RotationToDirection(float pitch, float yaw, CVector3D* direction)
{
direction->X = (float)(-sin(yaw)* cos(pitch));
direction->Y = (float)sin(pitch);
direction->Z = (float)(cos(pitch)* cos(yaw));
}
///////////////////////////////////////////////////////////////////
//
// Accessors
//
///////////////////////////////////////////////////////////////////
float GetPosX() { return pos.X; }
float GetPosY() { return pos.Y; }
float GetPosZ() { return pos.Z; }
CVector3D GetPosVec() { return pos; }
float GetFinalPosX() { return finalPos.X; }
float GetFinalPosY() { return finalPos.Y; }
float GetFinalPosZ() { return finalPos.Z; }
bool IsFinished(void) { return isFinished; }
int GetEmitterLife() { return emitterLife; }
int GetParticleCount() { return particleCount; }
float GetUpdateSpeed() { return updateSpeed; }
int GetMaxParticles(void) { return max_particles; }
tColor GetStartColor(void) { return startColor; }
tColor GetStartColorVar(void) { return startColorVar; }
tColor GetEndColor(void) { return endColor; }
tColor GetEndColorVar(void) { return endColorVar; }
int GetBlendMode(void) { return blend_mode; }
float GetSize(void) { return size; }
float GetYaw(void) { return yaw; }
float GetYawVar(void) { return yawVar; }
float GetPitch(void) { return pitch; }
float GetPitchVar(void) { return pitchVar; }
float GetSpeed(void) { return speed; }
float GetSpeedVar(void) { return speedVar; }
int GetEmitsPerFrame(void) { return emitsPerFrame; }
int GetEmitVar(void) { return emitVar; }
int GetLife(void) { return life; }
int GetLifeVar(void) { return lifeVar; }
float GetForceX(void) { return force.X; }
float GetForceY(void) { return force.Y; }
float GetForceZ(void) { return force.Z; }
///////////////////////////////////////////////////////////////////
//
// Mutators
//
///////////////////////////////////////////////////////////////////
void SetPosX(float posX) { pos.X = posX; }
void SetPosY(float posY) { pos.Y = posY; }
void SetPosZ(float posZ) { pos.Z = posZ; }
inline void SetPosVec(const CVector3D& newPos)
{
pos = newPos;
}
void SetFinalPosX(float finalposX) { finalPos.X = finalposX; }
void SetFinalPosY(float finalposY) { finalPos.Y = finalposY; }
void SetFinalPosZ(float finalposZ) { finalPos.Z = finalposZ; }
void SetTexture(CTexture* id) { texture = id; }
void SetIsFinished(bool finished) { isFinished = finished; }
void SetEmitterLife(int life) { emitterLife = life; }
void SetUpdateSpeed(float speed) { updateSpeed = speed; }
void SetLife(int newlife) { life = newlife; }
void SetLifeVar(int newlifevar) { lifeVar = newlifevar; }
void SetSpeed(float newspeed) { speed = newspeed; }
void SetSpeedVar(float newspeedvar) { speedVar = newspeedvar; }
void SetYaw(float newyaw) { yaw = newyaw; }
void SetYawVar(float newyawvar) { yawVar = newyawvar; }
void SetPitch(float newpitch) { pitch = newpitch; }
void SetPitchVar(float newpitchvar) { pitchVar = newpitchvar; }
void SetStartColor(tColor newColor) { startColor = newColor; }
void SetStartColorVar(tColor newColorVar) { startColorVar = newColorVar; }
void SetEndColor(tColor newColor) { endColor = newColor; }
void SetEndColorVar(tColor newColorVar) { endColorVar = newColorVar; }
void SetStartColorR(int newColorR) { startColor.r = newColorR; }
void SetStartColorG(int newColorG) { startColor.g = newColorG; }
void SetStartColorB(int newColorB) { startColor.b = newColorB; }
void SetStartColorVarR(int newColorVarR) { startColorVar.r = newColorVarR; }
void SetStartColorVarG(int newColorVarG) { startColorVar.g = newColorVarG; }
void SetStartColorVarB(int newColorVarB) { startColorVar.b = newColorVarB; }
void SetEndColorR(int newColorR) { endColor.r = newColorR; }
void SetEndColorG(int newColorG) { endColor.g = newColorG; }
void SetEndColorB(int newColorB) { endColor.b = newColorB; }
void SetEndColorVarR(int newColorVarR) { endColorVar.r = newColorVarR; }
void SetEndColorVarG(int newColorVarG) { endColorVar.g = newColorVarG; }
void SetEndColorVarB(int newColorVarB) { endColorVar.b = newColorVarB; }
inline void SetBlendMode(int blendmode)
{
if(blendmode >= 1 && blendmode <= 4)
blend_mode = blendmode;
else
blend_mode = 1;
}
void SetEmitsPerFrame(int emitsperframe) { emitsPerFrame = emitsperframe; }
void SetEmitVar(int emitvar) { emitVar = emitvar; }
void SetForceX(float forceX) { force.X = forceX; }
void SetForceY(float forceY) { force.Y = forceY; }
void SetForceZ(float forceZ) { force.Z = forceZ; }
void SetSize(float newSize) { size = newSize; }
void SetRenderParticles(bool render) { RenderParticles = render; }
};
#endif