1641 lines
49 KiB
C++
Executable File
1641 lines
49 KiB
C++
Executable File
//-----------------------------------------------------------------------------
|
|
// Torque Game Engine
|
|
// Copyright (C) GarageGames.com, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "game/fx/particleEngine.h"
|
|
#include "util/safeDelete.h"
|
|
#include "dgl/dgl.h"
|
|
#include "sceneGraph/sceneGraph.h"
|
|
#include "sceneGraph/sceneState.h"
|
|
#include "console/consoleTypes.h"
|
|
#include "core/bitStream.h"
|
|
#include "math/mRandom.h"
|
|
#include "dgl/gTexManager.h"
|
|
|
|
//--------------------------------------------------------------------------
|
|
//-------------------------------------- Internal global data
|
|
//
|
|
namespace {
|
|
|
|
PEngine* sgParticleEngine = NULL;
|
|
MRandomLCG sgRandom(0x1);
|
|
|
|
} // namespace {}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
//-------------------------------------- Internal classes
|
|
//
|
|
struct Particle;
|
|
class PEngine
|
|
{
|
|
// Interface for emitters.
|
|
static const U32 csmBlockSize;
|
|
Vector<Particle*> mAllocatedBlocks;
|
|
Particle* mFreeList;
|
|
|
|
public:
|
|
void updateParticles(Particle* particles, ParticleEmitter &emitter, const U32 ms);
|
|
void updateSingleParticle(Particle* particle, ParticleEmitter &emitter, const U32 ms);
|
|
|
|
Particle* allocateParticle(ParticleEmitter*);
|
|
void releaseParticle(Particle*);
|
|
|
|
public:
|
|
PEngine();
|
|
~PEngine();
|
|
};
|
|
|
|
const U32 PEngine::csmBlockSize = 512;
|
|
|
|
#define MaxParticleSize 50.0
|
|
//--------------------------------------
|
|
class ParticleData : public SimDataBlock
|
|
{
|
|
typedef SimDataBlock Parent;
|
|
|
|
enum PDConst
|
|
{
|
|
PDC_MAX_TEX = 50,
|
|
};
|
|
|
|
public:
|
|
F32 dragCoefficient;
|
|
F32 windCoefficient;
|
|
F32 gravityCoefficient;
|
|
|
|
F32 inheritedVelFactor;
|
|
F32 constantAcceleration;
|
|
|
|
S32 lifetimeMS;
|
|
S32 lifetimeVarianceMS;
|
|
|
|
F32 spinSpeed; // degrees per second
|
|
F32 spinRandomMin;
|
|
F32 spinRandomMax;
|
|
|
|
bool useInvAlpha;
|
|
|
|
bool animateTexture;
|
|
U32 numFrames;
|
|
U32 framesPerSec;
|
|
|
|
ColorF colors[ParticleEngine::PC_COLOR_KEYS];
|
|
F32 sizes[ParticleEngine::PC_SIZE_KEYS];
|
|
F32 times[4];
|
|
|
|
StringTableEntry textureNameList[PDC_MAX_TEX];
|
|
TextureHandle textureList[PDC_MAX_TEX];
|
|
|
|
public:
|
|
ParticleData();
|
|
~ParticleData();
|
|
|
|
void initializeParticle(Particle*, const Point3F&);
|
|
|
|
void packData(BitStream* stream);
|
|
void unpackData(BitStream* stream);
|
|
bool onAdd();
|
|
bool preload(bool server, char errorBuffer[256]);
|
|
bool loadParameters();
|
|
bool reload(char errorBuffer[256]);
|
|
DECLARE_CONOBJECT(ParticleData);
|
|
static void initPersistFields();
|
|
};
|
|
|
|
|
|
//--------------------------------------
|
|
struct Particle
|
|
{
|
|
Point3F pos; // current instantaneous position
|
|
Point3F vel; // " " velocity
|
|
Point3F acc; // Constant acceleration
|
|
Point3F orientDir; // direction particle should go if using oriented particles
|
|
|
|
U32 totalLifetime; // Total ms that this instance should be "live"
|
|
ParticleData* dataBlock; // datablock that contains global parameters for
|
|
// this instance
|
|
|
|
Particle* nextInList; // Managed by the current owning emitter
|
|
U32 currentAge;
|
|
|
|
Particle* nextInEngine; // Managed by the global engine object
|
|
ParticleEmitter* currentOwner;
|
|
ColorF color;
|
|
F32 size;
|
|
F32 spinSpeed;
|
|
};
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
//-------------------------------------- Datablock implementation
|
|
IMPLEMENT_CO_DATABLOCK_V1(ParticleEmitterData);
|
|
|
|
ParticleEmitterData::ParticleEmitterData()
|
|
{
|
|
bool loadParameters();
|
|
|
|
VECTOR_SET_ASSOCIATION(particleDataBlocks);
|
|
VECTOR_SET_ASSOCIATION(dataBlockIds);
|
|
|
|
ejectionPeriodMS = 100; // 10 Particles Per second
|
|
periodVarianceMS = 0; // exactly
|
|
|
|
ejectionVelocity = 2.0f; // From 1.0 - 3.0 meters per sec
|
|
velocityVariance = 1.0f;
|
|
ejectionOffset = 0.0f; // ejection from the emitter point
|
|
|
|
thetaMin = 0.0f; // All heights
|
|
thetaMax = 90.0f;
|
|
|
|
phiReferenceVel = 0.0f; // All directions
|
|
phiVariance = 360.0f;
|
|
|
|
lifetimeMS = 0;
|
|
lifetimeVarianceMS = 0;
|
|
|
|
overrideAdvance = false;
|
|
orientParticles = false;
|
|
orientOnVelocity = true;
|
|
useEmitterSizes = false;
|
|
useEmitterColors = false;
|
|
particleString = NULL;
|
|
}
|
|
|
|
|
|
IMPLEMENT_CONSOLETYPE(ParticleEmitterData)
|
|
IMPLEMENT_GETDATATYPE(ParticleEmitterData)
|
|
IMPLEMENT_SETDATATYPE(ParticleEmitterData)
|
|
|
|
void ParticleEmitterData::initPersistFields()
|
|
{
|
|
Parent::initPersistFields();
|
|
|
|
addField("ejectionPeriodMS", TypeS32, Offset(ejectionPeriodMS, ParticleEmitterData));
|
|
addField("periodVarianceMS", TypeS32, Offset(periodVarianceMS, ParticleEmitterData));
|
|
addField("ejectionVelocity", TypeF32, Offset(ejectionVelocity, ParticleEmitterData));
|
|
addField("velocityVariance", TypeF32, Offset(velocityVariance, ParticleEmitterData));
|
|
addField("ejectionOffset", TypeF32, Offset(ejectionOffset, ParticleEmitterData));
|
|
addField("thetaMin", TypeF32, Offset(thetaMin, ParticleEmitterData));
|
|
addField("thetaMax", TypeF32, Offset(thetaMax, ParticleEmitterData));
|
|
addField("phiReferenceVel", TypeF32, Offset(phiReferenceVel, ParticleEmitterData));
|
|
addField("phiVariance", TypeF32, Offset(phiVariance, ParticleEmitterData));
|
|
addField("overrideAdvance", TypeBool, Offset(overrideAdvance, ParticleEmitterData));
|
|
addField("orientParticles", TypeBool, Offset(orientParticles, ParticleEmitterData));
|
|
addField("orientOnVelocity", TypeBool, Offset(orientOnVelocity, ParticleEmitterData));
|
|
addField("particles", TypeString, Offset(particleString, ParticleEmitterData));
|
|
addField("lifetimeMS", TypeS32, Offset(lifetimeMS, ParticleEmitterData));
|
|
addField("lifetimeVarianceMS", TypeS32, Offset(lifetimeVarianceMS, ParticleEmitterData));
|
|
addField("useEmitterSizes", TypeBool, Offset(useEmitterSizes, ParticleEmitterData));
|
|
addField("useEmitterColors", TypeBool, Offset(useEmitterColors, ParticleEmitterData));
|
|
}
|
|
|
|
static ParticleEmitterData gDefaultEmitterData;
|
|
|
|
void ParticleEmitterData::packData(BitStream* stream)
|
|
{
|
|
Parent::packData(stream);
|
|
|
|
stream->writeInt(ejectionPeriodMS, 10);
|
|
stream->writeInt(periodVarianceMS, 10);
|
|
stream->writeInt((S32)(ejectionVelocity * 100), 16);
|
|
stream->writeInt((S32)(velocityVariance * 100), 14);
|
|
|
|
if(stream->writeFlag(ejectionOffset != gDefaultEmitterData.ejectionOffset))
|
|
stream->writeInt((S32)(ejectionOffset * 100), 16);
|
|
|
|
stream->writeRangedU32((U32)thetaMin, 0, 180);
|
|
stream->writeRangedU32((U32)thetaMax, 0, 180);
|
|
|
|
if(stream->writeFlag(phiReferenceVel != gDefaultEmitterData.phiReferenceVel))
|
|
stream->writeRangedU32((U32)phiReferenceVel, 0, 360);
|
|
|
|
if(stream->writeFlag(phiVariance != gDefaultEmitterData.phiVariance))
|
|
stream->writeRangedU32((U32)phiVariance, 0, 360);
|
|
|
|
stream->writeFlag(overrideAdvance);
|
|
stream->writeFlag(orientParticles);
|
|
stream->writeFlag(orientOnVelocity);
|
|
stream->writeInt(lifetimeMS >> 5, 10);
|
|
stream->writeInt(lifetimeVarianceMS >> 5, 10);
|
|
stream->writeFlag(useEmitterSizes);
|
|
stream->writeFlag(useEmitterColors);
|
|
|
|
stream->write(dataBlockIds.size());
|
|
for (U32 i = 0; i < dataBlockIds.size(); i++)
|
|
stream->write(dataBlockIds[i]);
|
|
}
|
|
|
|
void ParticleEmitterData::unpackData(BitStream* stream)
|
|
{
|
|
Parent::unpackData(stream);
|
|
|
|
ejectionPeriodMS = stream->readInt(10);
|
|
periodVarianceMS = stream->readInt(10);
|
|
ejectionVelocity = stream->readInt(16) / 100.0f;
|
|
velocityVariance = stream->readInt(14) / 100.0f;
|
|
if(stream->readFlag())
|
|
ejectionOffset = stream->readInt(16) / 100.0f;
|
|
else
|
|
ejectionOffset = gDefaultEmitterData.ejectionOffset;
|
|
|
|
thetaMin = stream->readRangedU32(0, 180);
|
|
thetaMax = stream->readRangedU32(0, 180);
|
|
if(stream->readFlag())
|
|
phiReferenceVel = stream->readRangedU32(0, 360);
|
|
else
|
|
phiReferenceVel = gDefaultEmitterData.phiReferenceVel;
|
|
|
|
if(stream->readFlag())
|
|
phiVariance = stream->readRangedU32(0, 360);
|
|
else
|
|
phiVariance = gDefaultEmitterData.phiVariance;
|
|
|
|
overrideAdvance = stream->readFlag();
|
|
orientParticles = stream->readFlag();
|
|
orientOnVelocity = stream->readFlag();
|
|
lifetimeMS = stream->readInt(10) << 5;
|
|
lifetimeVarianceMS = stream->readInt(10) << 5;
|
|
useEmitterSizes = stream->readFlag();
|
|
useEmitterColors = stream->readFlag();
|
|
|
|
U32 size;
|
|
stream->read(&size);
|
|
dataBlockIds.setSize(size);
|
|
for (U32 i = 0; i < dataBlockIds.size(); i++)
|
|
stream->read(&dataBlockIds[i]);
|
|
}
|
|
|
|
bool ParticleEmitterData::onAdd()
|
|
{
|
|
if (Parent::onAdd() == false)
|
|
return false;
|
|
|
|
// if (overrideAdvance == true) {
|
|
// Con::errorf(ConsoleLogEntry::General, "ParticleEmitterData: Not going to work. Fix it!");
|
|
// return false;
|
|
// }
|
|
|
|
if (!loadParameters())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParticleEmitterData::loadParameters()
|
|
{
|
|
// Validate the parameters...
|
|
//
|
|
if (ejectionPeriodMS < 1)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) period < 1 ms", getName());
|
|
ejectionPeriodMS = 1;
|
|
}
|
|
|
|
if (periodVarianceMS >= ejectionPeriodMS)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) periodVariance >= period", getName());
|
|
periodVarianceMS = ejectionPeriodMS - 1;
|
|
}
|
|
|
|
if (ejectionVelocity < 0.0f)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) ejectionVelocity < 0.0f", getName());
|
|
ejectionVelocity = 0.0f;
|
|
}
|
|
|
|
if (velocityVariance > ejectionVelocity)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) velocityVariance > ejectionVelocity", getName());
|
|
velocityVariance = ejectionVelocity;
|
|
}
|
|
|
|
if (ejectionOffset < 0.0f)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) ejectionOffset < 0", getName());
|
|
ejectionOffset = 0.0f;
|
|
}
|
|
|
|
if (thetaMin < 0.0f)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) thetaMin < 0.0", getName());
|
|
thetaMin = 0.0f;
|
|
}
|
|
|
|
if (thetaMax > 180.0f)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) thetaMax > 180.0", getName());
|
|
thetaMax = 180.0f;
|
|
}
|
|
|
|
if (thetaMin > thetaMax)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) thetaMin > thetaMax", getName());
|
|
thetaMin = thetaMax;
|
|
}
|
|
|
|
if (phiVariance < 0.0f || phiVariance > 360.0f)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) invalid phiVariance", getName());
|
|
phiVariance = phiVariance < 0.0f ? 0.0f : 360.0f;
|
|
}
|
|
|
|
if (particleString == NULL && dataBlockIds.size() == 0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) no particleString, invalid datablock", getName());
|
|
return false;
|
|
}
|
|
|
|
if (particleString && particleString[0] == '\0')
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) no particleString, invalid datablock", getName());
|
|
return false;
|
|
}
|
|
|
|
if (particleString && dStrlen(particleString) > 255)
|
|
{
|
|
Con::errorf(ConsoleLogEntry::General, "ParticleEmitterData(%s) particle string too long [> 255 chars]", getName());
|
|
return false;
|
|
}
|
|
|
|
if (lifetimeMS < 0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) lifetimeMS < 0.0f", getName());
|
|
lifetimeMS = 0;
|
|
}
|
|
|
|
if (lifetimeVarianceMS > lifetimeMS )
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) lifetimeVarianceMS >= lifetimeMS", getName());
|
|
lifetimeVarianceMS = lifetimeMS;
|
|
}
|
|
|
|
// Tokenize and load the particle datablocks...
|
|
//
|
|
if (particleString != NULL)
|
|
{
|
|
Vector<char*> dataBlocks(__FILE__, __LINE__);
|
|
char* tokCopy = new char[dStrlen(particleString) + 1];
|
|
dStrcpy(tokCopy, particleString);
|
|
|
|
char* currTok = dStrtok(tokCopy, " \t");
|
|
while (currTok != NULL)
|
|
{
|
|
dataBlocks.push_back(currTok);
|
|
currTok = dStrtok(NULL, " \t");
|
|
}
|
|
|
|
if (dataBlocks.size() == 0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) invalid particles string. No datablocks found", getName());
|
|
delete [] tokCopy;
|
|
return false;
|
|
}
|
|
|
|
particleDataBlocks.clear();
|
|
dataBlockIds.clear();
|
|
|
|
for (U32 i = 0; i < dataBlocks.size(); i++)
|
|
{
|
|
ParticleData* pData = NULL;
|
|
|
|
if (Sim::findObject(dataBlocks[i], pData) == false)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) unable to find particle datablock: %s", getName(), dataBlocks[i]);
|
|
}
|
|
else
|
|
{
|
|
particleDataBlocks.push_back(pData);
|
|
dataBlockIds.push_back(pData->getId());
|
|
}
|
|
}
|
|
|
|
delete [] tokCopy;
|
|
|
|
if (particleDataBlocks.size() == 0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) unable to find any particle datablocks", getName());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParticleEmitterData::preload(bool server, char errorBuffer[256])
|
|
{
|
|
if (Parent::preload(server, errorBuffer) == false)
|
|
return false;
|
|
|
|
if (!reload())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParticleEmitterData::reload()
|
|
{
|
|
particleDataBlocks.clear();
|
|
for (U32 i = 0; i < dataBlockIds.size(); i++)
|
|
{
|
|
ParticleData* pData = NULL;
|
|
if (Sim::findObject(dataBlockIds[i], pData) == false)
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleEmitterData(%s) unable to find particle datablock: %d", getName(), dataBlockIds[i]);
|
|
else
|
|
particleDataBlocks.push_back(pData);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
IMPLEMENT_CO_DATABLOCK_V1(ParticleData);
|
|
|
|
ParticleData::ParticleData()
|
|
{
|
|
dragCoefficient = 0.0f;
|
|
windCoefficient = 1.0f;
|
|
gravityCoefficient = 0.0f;
|
|
inheritedVelFactor = 0.0f;
|
|
constantAcceleration = 0.0f;
|
|
lifetimeMS = 1000;
|
|
lifetimeVarianceMS = 0;
|
|
spinSpeed = 0.0;
|
|
spinRandomMin = 0.0;
|
|
spinRandomMax = 0.0;
|
|
useInvAlpha = false;
|
|
animateTexture = false;
|
|
|
|
numFrames = 1;
|
|
framesPerSec = numFrames;
|
|
|
|
S32 i;
|
|
for( i=0; i<ParticleEngine::PC_COLOR_KEYS; i++ )
|
|
{
|
|
colors[i].set( 1.0, 1.0, 1.0, 1.0 );
|
|
}
|
|
|
|
for( i=0; i<ParticleEngine::PC_SIZE_KEYS; i++ )
|
|
{
|
|
sizes[i] = 1;
|
|
}
|
|
|
|
times[0] = 0.0f;
|
|
times[1] = 1.0f;
|
|
times[2] = 2.0f;
|
|
times[3] = 2.0f;
|
|
|
|
dMemset( textureNameList, 0, sizeof( textureNameList ) );
|
|
dMemset( textureList, 0, sizeof( textureList ) );
|
|
}
|
|
|
|
static ParticleData gDefaultParticleData;
|
|
|
|
|
|
ParticleData::~ParticleData()
|
|
{
|
|
}
|
|
|
|
void ParticleData::initPersistFields()
|
|
{
|
|
Parent::initPersistFields();
|
|
|
|
addField("dragCoefficient", TypeF32, Offset(dragCoefficient, ParticleData));
|
|
addField("windCoefficient", TypeF32, Offset(windCoefficient, ParticleData));
|
|
addField("gravityCoefficient", TypeF32, Offset(gravityCoefficient, ParticleData));
|
|
addField("inheritedVelFactor", TypeF32, Offset(inheritedVelFactor, ParticleData));
|
|
addField("constantAcceleration", TypeF32, Offset(constantAcceleration, ParticleData));
|
|
addField("lifetimeMS", TypeS32, Offset(lifetimeMS, ParticleData));
|
|
addField("lifetimeVarianceMS", TypeS32, Offset(lifetimeVarianceMS, ParticleData));
|
|
addField("spinSpeed", TypeF32, Offset(spinSpeed, ParticleData));
|
|
addField("spinRandomMin", TypeF32, Offset(spinRandomMin, ParticleData));
|
|
addField("spinRandomMax", TypeF32, Offset(spinRandomMax, ParticleData));
|
|
addField("useInvAlpha", TypeBool, Offset(useInvAlpha, ParticleData));
|
|
addField("animateTexture", TypeBool, Offset(animateTexture, ParticleData));
|
|
addField("framesPerSec", TypeS32, Offset(framesPerSec, ParticleData));
|
|
|
|
addField("textureName", TypeFilename, Offset(textureNameList, ParticleData));
|
|
addField("animTexName", TypeFilename, Offset(textureNameList, ParticleData), PDC_MAX_TEX );
|
|
|
|
// Interpolation variables
|
|
addField("colors", TypeColorF, Offset(colors, ParticleData), ParticleEngine::PC_COLOR_KEYS);
|
|
addField("sizes", TypeF32, Offset(sizes, ParticleData), ParticleEngine::PC_SIZE_KEYS);
|
|
addField("times", TypeF32, Offset(times, ParticleData), 4);
|
|
}
|
|
|
|
void ParticleData::packData(BitStream* stream)
|
|
{
|
|
Parent::packData(stream);
|
|
|
|
stream->writeFloat(dragCoefficient / 5, 10);
|
|
|
|
if(stream->writeFlag(windCoefficient != gDefaultParticleData.windCoefficient))
|
|
stream->write(windCoefficient);
|
|
|
|
stream->writeSignedFloat(gravityCoefficient / 10, 12);
|
|
stream->writeFloat(inheritedVelFactor, 9);
|
|
|
|
if(stream->writeFlag(constantAcceleration != gDefaultParticleData.constantAcceleration))
|
|
stream->write(constantAcceleration);
|
|
|
|
stream->writeInt(lifetimeMS >> 5, 10);
|
|
stream->writeInt(lifetimeVarianceMS >> 5,10);
|
|
|
|
if(stream->writeFlag(spinSpeed != gDefaultParticleData.spinSpeed))
|
|
stream->write(spinSpeed);
|
|
|
|
if(stream->writeFlag(spinRandomMin != gDefaultParticleData.spinRandomMin || spinRandomMax != gDefaultParticleData.spinRandomMax))
|
|
{
|
|
stream->writeInt((S32)(spinRandomMin + 1000), 11);
|
|
stream->writeInt((S32)(spinRandomMax + 1000), 11);
|
|
}
|
|
stream->writeFlag(useInvAlpha);
|
|
|
|
S32 i, count;
|
|
|
|
// see how many frames there are:
|
|
for(count = 0; count < 3; count++)
|
|
if(times[count] >= 1)
|
|
break;
|
|
|
|
count++;
|
|
|
|
stream->writeInt(count-1, 2);
|
|
|
|
for( i=0; i<count; i++ )
|
|
{
|
|
stream->writeFloat( colors[i].red, 7);
|
|
stream->writeFloat( colors[i].green, 7);
|
|
stream->writeFloat( colors[i].blue, 7);
|
|
stream->writeFloat( colors[i].alpha, 7);
|
|
stream->writeFloat( sizes[i]/MaxParticleSize, 14);
|
|
stream->writeFloat( times[i], 8);
|
|
}
|
|
|
|
for( count=0; count<PDC_MAX_TEX; count++ )
|
|
if(!textureNameList[count])
|
|
break;
|
|
|
|
stream->writeInt(count, 6);
|
|
|
|
for(i = 0; i < count; i++)
|
|
stream->writeString( textureNameList[i] );
|
|
}
|
|
|
|
void ParticleData::unpackData(BitStream* stream)
|
|
{
|
|
Parent::unpackData(stream);
|
|
|
|
dragCoefficient = stream->readFloat(10) * 5;
|
|
|
|
if(stream->readFlag())
|
|
stream->read(&windCoefficient);
|
|
else
|
|
windCoefficient = gDefaultParticleData.windCoefficient;
|
|
|
|
gravityCoefficient = stream->readSignedFloat(12) * 10;
|
|
inheritedVelFactor = stream->readFloat(9);
|
|
|
|
if(stream->readFlag())
|
|
stream->read(&constantAcceleration);
|
|
else
|
|
constantAcceleration = gDefaultParticleData.constantAcceleration;
|
|
|
|
lifetimeMS = stream->readInt(10) << 5;
|
|
lifetimeVarianceMS = stream->readInt(10) << 5;
|
|
|
|
if(stream->readFlag())
|
|
stream->read(&spinSpeed);
|
|
else
|
|
spinSpeed = gDefaultParticleData.spinSpeed;
|
|
|
|
if(stream->readFlag())
|
|
{
|
|
spinRandomMin = stream->readInt(11) - 1000;
|
|
spinRandomMax = stream->readInt(11) - 1000;
|
|
}
|
|
else
|
|
{
|
|
spinRandomMin = gDefaultParticleData.spinRandomMin;
|
|
spinRandomMax = gDefaultParticleData.spinRandomMax;
|
|
}
|
|
|
|
useInvAlpha = stream->readFlag();
|
|
|
|
S32 i;
|
|
S32 count = stream->readInt(2) + 1;
|
|
for(i = 0;i < count; i++)
|
|
{
|
|
colors[i].red = stream->readFloat(7);
|
|
colors[i].green = stream->readFloat(7);
|
|
colors[i].blue = stream->readFloat(7);
|
|
colors[i].alpha = stream->readFloat(7);
|
|
|
|
sizes[i] = stream->readFloat(14) * MaxParticleSize;
|
|
times[i] = stream->readFloat(8);
|
|
}
|
|
count = stream->readInt(6);
|
|
for(i = 0; i < count;i ++)
|
|
textureNameList[i] = stream->readSTString();
|
|
}
|
|
|
|
bool ParticleData::onAdd()
|
|
{
|
|
if (Parent::onAdd() == false)
|
|
return false;
|
|
|
|
if (!loadParameters())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParticleData::loadParameters()
|
|
{
|
|
if (dragCoefficient < 0.0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) drag coeff less than 0", getName());
|
|
dragCoefficient = 0.0f;
|
|
}
|
|
|
|
if (lifetimeMS < 1)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) lifetime < 1 ms", getName());
|
|
lifetimeMS = 1;
|
|
}
|
|
|
|
if (lifetimeVarianceMS >= lifetimeMS)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) lifetimeVariance >= lifetime", getName());
|
|
lifetimeVarianceMS = lifetimeMS - 1;
|
|
}
|
|
|
|
if (spinSpeed > 10000.0 || spinSpeed < -10000.0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) spinSpeed invalid", getName());
|
|
return false;
|
|
}
|
|
|
|
if (spinRandomMin > 10000.0 || spinRandomMin < -10000.0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) spinRandomMin invalid", getName());
|
|
spinRandomMin = -360.0;
|
|
return false;
|
|
}
|
|
|
|
if (spinRandomMin > spinRandomMax)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) spinRandomMin greater than spinRandomMax", getName());
|
|
spinRandomMin = spinRandomMax - (spinRandomMin - spinRandomMax );
|
|
return false;
|
|
}
|
|
|
|
if (spinRandomMax > 10000.0 || spinRandomMax < -10000.0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) spinRandomMax invalid", getName());
|
|
spinRandomMax = 360.0;
|
|
return false;
|
|
}
|
|
|
|
if (numFrames > PDC_MAX_TEX)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) numFrames invalid", getName());
|
|
numFrames = PDC_MAX_TEX;
|
|
return false;
|
|
}
|
|
|
|
if (framesPerSec > 200)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) framesPerSec invalid", getName());
|
|
framesPerSec = 20;
|
|
return false;
|
|
}
|
|
|
|
times[0] = 0.0f;
|
|
for (U32 i = 1; i < 4; i++)
|
|
{
|
|
if (times[i] < times[i-1])
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "ParticleData(%s) times[%d] < times[%d]", getName(), i, i-1);
|
|
times[i] = times[i-1];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ParticleData::preload(bool server, char errorBuffer[256])
|
|
{
|
|
if (Parent::preload(server, errorBuffer) == false)
|
|
return false;
|
|
|
|
if(!server)
|
|
{
|
|
if (!reload(errorBuffer))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParticleData::reload(char errorBuffer[256])
|
|
{
|
|
bool error = false;
|
|
numFrames = 0;
|
|
for( int i=0; i<PDC_MAX_TEX; i++ )
|
|
{
|
|
if( textureNameList[i] && textureNameList[i][0] )
|
|
{
|
|
textureList[i] = TextureHandle( textureNameList[i], MeshTexture );
|
|
if (!textureList[i].getName())
|
|
{
|
|
dSprintf(errorBuffer, 256, "Missing particle texture: %s", textureNameList[i]);
|
|
error = true;
|
|
}
|
|
numFrames++;
|
|
}
|
|
}
|
|
return !error;
|
|
}
|
|
|
|
|
|
void ParticleData::initializeParticle(Particle* init, const Point3F& inheritVelocity)
|
|
{
|
|
init->dataBlock = this;
|
|
|
|
// Calculate the constant accleration...
|
|
init->vel += inheritVelocity * inheritedVelFactor;
|
|
init->acc = init->vel * constantAcceleration;
|
|
|
|
// Calculate this instance's lifetime...
|
|
init->totalLifetime = lifetimeMS;
|
|
if (lifetimeVarianceMS != 0)
|
|
init->totalLifetime += S32(sgRandom.randI() % (2 * lifetimeVarianceMS + 1)) - S32(lifetimeVarianceMS);
|
|
|
|
// assign spin amount
|
|
init->spinSpeed = spinSpeed + sgRandom.randF( spinRandomMin, spinRandomMax );
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//-------------------------------------- Emitter implementation
|
|
//
|
|
ParticleEmitter::ParticleEmitter()
|
|
{
|
|
mNeedTransformUpdate = true;
|
|
|
|
mDeleteWhenEmpty = false;
|
|
mDeleteOnTick = false;
|
|
|
|
mParticleListHead = NULL;
|
|
|
|
mInternalClock = 0;
|
|
mNextParticleTime = 0;
|
|
|
|
mLastPosition.set(0, 0, 0);
|
|
mHasLastPosition = false;
|
|
|
|
mLifetimeMS = 0;
|
|
mElapsedTimeMS = 0;
|
|
}
|
|
|
|
ParticleEmitter::~ParticleEmitter()
|
|
{
|
|
AssertFatal(mParticleListHead == NULL, "Error, particles remain in emitter after remove?");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool ParticleEmitter::onAdd()
|
|
{
|
|
if(!Parent::onAdd())
|
|
return false;
|
|
|
|
removeFromProcessList();
|
|
|
|
mLifetimeMS = mDataBlock->lifetimeMS;
|
|
if( mDataBlock->lifetimeVarianceMS )
|
|
{
|
|
mLifetimeMS += S32( sgRandom.randI() % (2 * mDataBlock->lifetimeVarianceMS + 1)) - S32(mDataBlock->lifetimeVarianceMS );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void ParticleEmitter::onRemove()
|
|
{
|
|
Particle* pProbe = mParticleListHead;
|
|
|
|
if(sgParticleEngine)
|
|
{
|
|
while (pProbe != NULL)
|
|
{
|
|
Particle* pRemove = pProbe;
|
|
pProbe = pProbe->nextInList;
|
|
|
|
pRemove->nextInList = NULL;
|
|
sgParticleEngine->releaseParticle(pRemove);
|
|
}
|
|
}
|
|
|
|
mParticleListHead = NULL;
|
|
|
|
if (mSceneManager != NULL)
|
|
{
|
|
gClientContainer.removeObject(this);
|
|
gClientSceneGraph->removeObjectFromScene(this);
|
|
}
|
|
|
|
Parent::onRemove();
|
|
}
|
|
|
|
|
|
bool ParticleEmitter::onNewDataBlock(GameBaseData* dptr)
|
|
{
|
|
mDataBlock = dynamic_cast<ParticleEmitterData*>(dptr);
|
|
if (!mDataBlock || !Parent::onNewDataBlock(dptr))
|
|
return false;
|
|
|
|
scriptOnNewDataBlock();
|
|
return true;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool ParticleEmitter::prepRenderImage(SceneState* state, const U32 stateKey,
|
|
const U32 /*startZone*/, const bool /*modifyBaseState*/)
|
|
{
|
|
if (isLastState(state, stateKey))
|
|
return false;
|
|
setLastState(state, stateKey);
|
|
|
|
// This should be sufficient for most objects that don't manage zones, and
|
|
// don't need to return a specialized RenderImage...
|
|
if (state->isObjectRendered(this))
|
|
{
|
|
SceneRenderImage* image = new SceneRenderImage;
|
|
image->obj = this;
|
|
image->isTranslucent = true;
|
|
image->sortType = SceneRenderImage::Point;
|
|
state->setImageRefPoint(this, image);
|
|
|
|
state->insertRenderImage(image);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
struct SortParticle
|
|
{
|
|
Particle* p;
|
|
F32 k;
|
|
};
|
|
|
|
int QSORT_CALLBACK cmpSortParticles(const void* p1, const void* p2)
|
|
{
|
|
const SortParticle* sp1 = (const SortParticle*)p1;
|
|
const SortParticle* sp2 = (const SortParticle*)p2;
|
|
|
|
if (sp2->k > sp1->k)
|
|
return 1;
|
|
else if (sp2->k == sp1->k)
|
|
return 0;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
void ParticleEmitter::renderObject(SceneState* state, SceneRenderImage*)
|
|
{
|
|
AssertFatal(dglIsInCanonicalState(), "Error, GL not in canonical state on entry");
|
|
|
|
RectI viewport;
|
|
dglGetViewport(&viewport);
|
|
|
|
// Uncomment this if this is a "simple" (non-zone managing) object
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
state->setupObjectProjection(this);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
dglMultMatrix(&mObjToWorld);
|
|
|
|
MatrixF modelview;
|
|
dglGetModelview(&modelview);
|
|
|
|
Point3F x, y, viewvec;
|
|
modelview.getRow(0, &x);
|
|
modelview.getRow(2, &y);
|
|
modelview.getRow(1, &viewvec);
|
|
|
|
MatrixF camView;
|
|
modelview.transposeTo( (F32*) &camView );
|
|
|
|
// DMMFIX: slow!
|
|
//
|
|
static Vector<SortParticle> orderedVector(__FILE__, __LINE__);
|
|
orderedVector.clear();
|
|
|
|
Particle* pProbe = mParticleListHead;
|
|
while (pProbe)
|
|
{
|
|
orderedVector.increment();
|
|
orderedVector.last().p = pProbe;
|
|
orderedVector.last().k = mDot(pProbe->pos, viewvec);
|
|
pProbe = pProbe->nextInList;
|
|
}
|
|
|
|
glEnable(GL_BLEND);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
|
glDepthMask(GL_FALSE);
|
|
|
|
Point3F basePoints[4];
|
|
basePoints[0] = Point3F(-1.0, 0.0, -1.0);
|
|
basePoints[1] = Point3F( 1.0, 0.0, -1.0);
|
|
basePoints[2] = Point3F( 1.0, 0.0, 1.0);
|
|
basePoints[3] = Point3F(-1.0, 0.0, 1.0);
|
|
|
|
const F32 spinFactor = (1.0/1000.0) * (1.0/360.0) * M_PI * 2.0;
|
|
|
|
bool prevInvAlpha = false;
|
|
|
|
for (U32 i = 0; i < orderedVector.size(); i++)
|
|
{
|
|
Particle* particle = orderedVector[i].p;
|
|
|
|
// Set our blend mode, where appropriate.
|
|
if (particle->dataBlock->useInvAlpha != prevInvAlpha)
|
|
{
|
|
if (particle->dataBlock->useInvAlpha)
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
else
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
|
|
|
prevInvAlpha = particle->dataBlock->useInvAlpha;
|
|
}
|
|
|
|
if( particle->dataBlock->animateTexture )
|
|
{
|
|
U32 texNum = (U32)(particle->currentAge * (1.0/1000.0) * particle->dataBlock->framesPerSec);
|
|
texNum %= particle->dataBlock->numFrames;
|
|
glBindTexture(GL_TEXTURE_2D, particle->dataBlock->textureList[texNum].getGLName());
|
|
}
|
|
else
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, particle->dataBlock->textureList[0].getGLName());
|
|
}
|
|
|
|
if( mDataBlock->orientParticles )
|
|
{
|
|
renderOrientedParticle( *particle, state->getCameraPosition() );
|
|
}
|
|
else
|
|
{
|
|
renderBillboardParticle( *particle, basePoints, camView, spinFactor );
|
|
}
|
|
|
|
}
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glDisable(GL_BLEND);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
glDepthMask(GL_TRUE);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
dglSetViewport(viewport);
|
|
|
|
AssertFatal(dglIsInCanonicalState(), "Error, GL not in canonical state on exit");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
inline void ParticleEmitter::renderBillboardParticle( Particle &part, Point3F *basePnts,
|
|
MatrixF &camView, F32 spinFactor )
|
|
{
|
|
glBegin(GL_QUADS);
|
|
|
|
glColor4f(part.color.red,
|
|
part.color.green,
|
|
part.color.blue,
|
|
part.color.alpha);
|
|
|
|
|
|
F32 width = part.size * 0.5;
|
|
F32 spinAngle = part.spinSpeed * part.currentAge * spinFactor;
|
|
|
|
F32 sy, cy;
|
|
mSinCos(spinAngle, sy, cy);
|
|
Point3F points[4];
|
|
|
|
for( int i=0; i<4; i++ )
|
|
{
|
|
points[i].x = cy * basePnts[i].x - sy * basePnts[i].z;
|
|
points[i].y = basePnts[i].y;
|
|
points[i].z = sy * basePnts[i].x + cy * basePnts[i].z;
|
|
camView.mulP( points[i] );
|
|
points[i] *= width;
|
|
points[i] += part.pos;
|
|
}
|
|
|
|
glTexCoord2f(0, 1);
|
|
glVertex3fv(points[0]);
|
|
glTexCoord2f(1, 1);
|
|
glVertex3fv(points[1]);
|
|
glTexCoord2f(1, 0);
|
|
glVertex3fv(points[2]);
|
|
glTexCoord2f(0, 0);
|
|
glVertex3fv(points[3]);
|
|
|
|
glEnd();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
inline void ParticleEmitter::renderOrientedParticle( Particle &part, const Point3F &camPos )
|
|
{
|
|
Point3F dir;
|
|
|
|
if( mDataBlock->orientOnVelocity )
|
|
{
|
|
// don't render oriented particle if it has no velocity
|
|
if( part.vel.magnitudeSafe() == 0.0 ) return;
|
|
dir = part.vel;
|
|
}
|
|
else
|
|
{
|
|
dir = part.orientDir;
|
|
}
|
|
|
|
Point3F dirFromCam = part.pos - camPos;
|
|
Point3F crossDir;
|
|
mCross( dirFromCam, dir, &crossDir );
|
|
crossDir.normalize();
|
|
dir.normalize();
|
|
|
|
glBegin(GL_QUADS);
|
|
|
|
glColor4f(part.color.red,
|
|
part.color.green,
|
|
part.color.blue,
|
|
part.color.alpha);
|
|
|
|
|
|
F32 width = part.size * 0.5;
|
|
|
|
dir *= width;
|
|
crossDir *= width;
|
|
Point3F start = part.pos - dir;
|
|
Point3F end = part.pos + dir;
|
|
|
|
|
|
glTexCoord2f(0, 0);
|
|
glVertex3fv( start + crossDir );
|
|
|
|
glTexCoord2f(0, 1);
|
|
glVertex3fv( start - crossDir );
|
|
|
|
glTexCoord2f(1, 1);
|
|
glVertex3fv( end - crossDir );
|
|
|
|
glTexCoord2f(1, 0);
|
|
glVertex3fv( end + crossDir );
|
|
|
|
glEnd();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void ParticleEmitter::stealParticle(Particle* steal)
|
|
{
|
|
Particle** ppParticle = &mParticleListHead;
|
|
while (*ppParticle)
|
|
{
|
|
if (*ppParticle == steal)
|
|
{
|
|
*ppParticle = (*ppParticle)->nextInList;
|
|
steal->nextInList = NULL;
|
|
return;
|
|
}
|
|
|
|
ppParticle = &((*ppParticle)->nextInList);
|
|
}
|
|
AssertFatal(false, "Trying to steal a particle that doesn't belong to this emitter!");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
void ParticleEmitter::setSizes( F32 *sizeList )
|
|
{
|
|
for( int i=0; i<ParticleEngine::PC_SIZE_KEYS; i++ )
|
|
sizes[i] = sizeList[i];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
void ParticleEmitter::setColors( ColorF *colorList )
|
|
{
|
|
for( int i=0; i<ParticleEngine::PC_COLOR_KEYS; i++ )
|
|
colors[i] = colorList[i];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
void ParticleEmitter::deleteWhenEmpty()
|
|
{
|
|
mDeleteWhenEmpty = true;
|
|
}
|
|
|
|
void ParticleEmitter::emitParticles(const Point3F& point,
|
|
const bool useLastPosition,
|
|
const Point3F& axis,
|
|
const Point3F& velocity,
|
|
const U32 numMilliseconds)
|
|
{
|
|
// lifetime over - no more particles
|
|
if( mLifetimeMS > 0 && mElapsedTimeMS > mLifetimeMS )
|
|
return;
|
|
|
|
Point3F realStart;
|
|
if (useLastPosition && mHasLastPosition)
|
|
realStart = mLastPosition;
|
|
else
|
|
realStart = point;
|
|
|
|
emitParticles(realStart, point,
|
|
axis,
|
|
velocity,
|
|
numMilliseconds);
|
|
}
|
|
|
|
void ParticleEmitter::emitParticles(const Point3F& start,
|
|
const Point3F& end,
|
|
const Point3F& axis,
|
|
const Point3F& velocity,
|
|
const U32 numMilliseconds)
|
|
{
|
|
// lifetime over - no more particles
|
|
if( mLifetimeMS > 0 && mElapsedTimeMS > mLifetimeMS )
|
|
return;
|
|
|
|
U32 currTime = 0;
|
|
bool updatedBBox = false;
|
|
|
|
Point3F axisx;
|
|
if (mFabs(axis.z) < 0.9f)
|
|
mCross(axis, Point3F(0, 0, 1), &axisx);
|
|
else
|
|
mCross(axis, Point3F(0, 1, 0), &axisx);
|
|
axisx.normalize();
|
|
|
|
if (mNextParticleTime != 0)
|
|
{
|
|
// Need to handle next particle
|
|
//
|
|
if (mNextParticleTime > numMilliseconds)
|
|
{
|
|
// Defer to next update
|
|
// (Note that this introduces a potential spatial irregularity if the owning
|
|
// object is accelerating, and updating at a low frequency)
|
|
//
|
|
mNextParticleTime -= numMilliseconds;
|
|
mInternalClock += numMilliseconds;
|
|
mLastPosition = end;
|
|
mHasLastPosition = true;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
currTime += mNextParticleTime;
|
|
mInternalClock += mNextParticleTime;
|
|
// Emit particle at curr time
|
|
|
|
// Create particle at the correct position
|
|
Point3F pos;
|
|
pos.interpolate(start, end, F32(currTime) / F32(numMilliseconds));
|
|
addParticle(pos, axis, velocity, axisx);
|
|
updatedBBox |= updateBBox(pos);
|
|
|
|
U32 advanceMS = numMilliseconds - currTime;
|
|
if (advanceMS > mParticleListHead->totalLifetime)
|
|
{
|
|
// Well, shoot, why did we create this in the first place?
|
|
Particle* old = mParticleListHead;
|
|
mParticleListHead = old->nextInList;
|
|
old->nextInList = NULL;
|
|
sgParticleEngine->releaseParticle(old);
|
|
}
|
|
else
|
|
{
|
|
if (advanceMS != 0)
|
|
sgParticleEngine->updateSingleParticle(mParticleListHead, *this, advanceMS);
|
|
}
|
|
mNextParticleTime = 0;
|
|
}
|
|
}
|
|
|
|
while (currTime < numMilliseconds)
|
|
{
|
|
S32 nextTime = mDataBlock->ejectionPeriodMS;
|
|
if (mDataBlock->periodVarianceMS != 0)
|
|
{
|
|
nextTime += S32(sgRandom.randI() % (2 * mDataBlock->periodVarianceMS + 1)) -
|
|
S32(mDataBlock->periodVarianceMS);
|
|
}
|
|
AssertFatal(nextTime > 0, "Error, next particle ejection time must always be greater than 0");
|
|
|
|
if (currTime + nextTime > numMilliseconds)
|
|
{
|
|
mNextParticleTime = (currTime + nextTime) - numMilliseconds;
|
|
mInternalClock += numMilliseconds - currTime;
|
|
AssertFatal(mNextParticleTime > 0, "Error, should not have deferred this particle!");
|
|
break;
|
|
}
|
|
|
|
currTime += nextTime;
|
|
mInternalClock += nextTime;
|
|
|
|
// Create particle at the correct position
|
|
Point3F pos;
|
|
pos.interpolate(start, end, F32(currTime) / F32(numMilliseconds));
|
|
addParticle(pos, axis, velocity, axisx);
|
|
updatedBBox |= updateBBox(pos);
|
|
|
|
// NOTE: We are assuming that the just added particle is at the head of our
|
|
// list. If that changes, so must this...
|
|
U32 advanceMS = numMilliseconds - currTime;
|
|
if (mDataBlock->overrideAdvance == false && advanceMS != 0)
|
|
{
|
|
if (advanceMS > mParticleListHead->totalLifetime)
|
|
{
|
|
// Well, shoot, why did we create this in the first place?
|
|
Particle* old = mParticleListHead;
|
|
mParticleListHead = old->nextInList;
|
|
old->nextInList = NULL;
|
|
sgParticleEngine->releaseParticle(old);
|
|
}
|
|
else
|
|
{
|
|
if (advanceMS != 0)
|
|
sgParticleEngine->updateSingleParticle(mParticleListHead, *this, advanceMS);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(updatedBBox)
|
|
mNeedTransformUpdate = true;
|
|
|
|
if (mParticleListHead != NULL && mSceneManager == NULL)
|
|
{
|
|
gClientSceneGraph->addObjectToScene(this);
|
|
gClientContainer.addObject(this);
|
|
gClientProcessList.addObject(this);
|
|
}
|
|
|
|
mLastPosition = end;
|
|
mHasLastPosition = true;
|
|
}
|
|
|
|
bool ParticleEmitter::updateBBox(const Point3F &position)
|
|
{
|
|
// rdb:
|
|
// we just feed it individual particles now
|
|
// should be faster
|
|
if(mObjBox.isContained(position))
|
|
return false;
|
|
|
|
mObjBox.intersect(position);
|
|
return true;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
void ParticleEmitter::emitParticles(const Point3F& rCenter,
|
|
const Point3F& rNormal,
|
|
const F32 radius,
|
|
const Point3F& velocity,
|
|
S32 count)
|
|
{
|
|
// lifetime over - no more particles
|
|
if( mLifetimeMS > 0 && mElapsedTimeMS > mLifetimeMS )
|
|
return;
|
|
|
|
Point3F axisx, axisy;
|
|
Point3F axisz = rNormal;
|
|
|
|
if( axisz.isZero() )
|
|
axisz.set( 0.0, 0.0, 1.0 );
|
|
|
|
if (mFabs(axisz.z) < 0.98)
|
|
{
|
|
mCross(axisz, Point3F(0, 0, 1), &axisy);
|
|
axisy.normalize();
|
|
}
|
|
else
|
|
{
|
|
mCross(axisz, Point3F(0, 1, 0), &axisy);
|
|
axisy.normalize();
|
|
}
|
|
mCross(axisz, axisy, &axisx);
|
|
axisx.normalize();
|
|
|
|
// Should think of a better way to distribute the
|
|
// particles within the hemisphere.
|
|
for (S32 i = 0; i < count; i++)
|
|
{
|
|
Point3F pos = axisx * (radius * (1 - (2 * sgRandom.randF())));
|
|
pos += axisy * (radius * (1 - (2 * sgRandom.randF())));
|
|
pos += axisz * (radius * sgRandom.randF());
|
|
|
|
Point3F axis = pos;
|
|
axis.normalize();
|
|
pos += rCenter;
|
|
|
|
addParticle(pos, axis, velocity, axisz);
|
|
}
|
|
|
|
// Set world bounding box
|
|
mObjBox.min = rCenter - Point3F(radius, radius, radius);
|
|
mObjBox.max = rCenter + Point3F(radius, radius, radius);
|
|
resetWorldBox();
|
|
|
|
// Make sure we're part of the world
|
|
if (mParticleListHead != NULL && mSceneManager == NULL)
|
|
{
|
|
gClientSceneGraph->addObjectToScene(this);
|
|
gClientContainer.addObject(this);
|
|
gClientProcessList.addObject(this);
|
|
}
|
|
|
|
mHasLastPosition = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
void ParticleEmitter::setTransform(const MatrixF & mat)
|
|
{
|
|
mNeedTransformUpdate = false;
|
|
Parent::setTransform(mat);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
void ParticleEmitter::addParticle(const Point3F& pos,
|
|
const Point3F& axis,
|
|
const Point3F& vel,
|
|
const Point3F& axisx)
|
|
{
|
|
Particle* pNew = sgParticleEngine->allocateParticle(this);
|
|
pNew->nextInList = mParticleListHead;
|
|
mParticleListHead = pNew;
|
|
|
|
Point3F ejectionAxis = axis;
|
|
F32 theta = (mDataBlock->thetaMax - mDataBlock->thetaMin) * sgRandom.randF() +
|
|
mDataBlock->thetaMin;
|
|
|
|
F32 ref = (F32(mInternalClock) / 1000.0) * mDataBlock->phiReferenceVel;
|
|
F32 phi = ref + sgRandom.randF() * mDataBlock->phiVariance;
|
|
|
|
// Both phi and theta are in degs. Create axis angles out of them, and create the
|
|
// appropriate rotation matrix...
|
|
AngAxisF thetaRot(axisx, theta * (M_PI / 180.0));
|
|
AngAxisF phiRot(axis, phi * (M_PI / 180.0));
|
|
|
|
MatrixF temp(true);
|
|
thetaRot.setMatrix(&temp);
|
|
temp.mulP(ejectionAxis);
|
|
phiRot.setMatrix(&temp);
|
|
temp.mulP(ejectionAxis);
|
|
|
|
F32 initialVel = mDataBlock->ejectionVelocity;
|
|
initialVel += (mDataBlock->velocityVariance * 2.0f * sgRandom.randF()) - mDataBlock->velocityVariance;
|
|
|
|
pNew->pos = pos + (ejectionAxis * mDataBlock->ejectionOffset);
|
|
pNew->vel = ejectionAxis * initialVel;
|
|
pNew->orientDir = ejectionAxis;
|
|
pNew->acc.set(0, 0, 0);
|
|
pNew->currentAge = 0;
|
|
|
|
// Select a datablock for this particle
|
|
U32 dBlockIndex = (U32)(mCeil(sgRandom.randF() * F32(mDataBlock->particleDataBlocks.size())) - 1);
|
|
mDataBlock->particleDataBlocks[dBlockIndex]->initializeParticle(pNew, vel);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void ParticleEmitter::processTick(const Move*)
|
|
{
|
|
if(mNeedTransformUpdate)
|
|
{
|
|
// Force update our transform.
|
|
setTransform(getTransform());
|
|
}
|
|
|
|
if (mDeleteOnTick == true)
|
|
deleteObject();
|
|
}
|
|
|
|
|
|
void ParticleEmitter::advanceTime(F32 dt)
|
|
{
|
|
Parent::advanceTime(dt);
|
|
|
|
mElapsedTimeMS += (S32)(dt * 1000.0f);
|
|
|
|
U32 numMSToUpdate = (U32)(dt * 1000.0f);
|
|
if (numMSToUpdate == 0)
|
|
return;
|
|
|
|
Particle** ppProbe = &mParticleListHead;
|
|
while (*ppProbe != NULL)
|
|
{
|
|
(*ppProbe)->currentAge += numMSToUpdate;
|
|
|
|
if ((*ppProbe)->currentAge >= (*ppProbe)->totalLifetime)
|
|
{
|
|
// Remove this particle
|
|
Particle* remove = *ppProbe;
|
|
*ppProbe = remove->nextInList;
|
|
remove->nextInList = NULL;
|
|
sgParticleEngine->releaseParticle(remove);
|
|
}
|
|
else
|
|
{
|
|
ppProbe = &((*ppProbe)->nextInList);
|
|
}
|
|
}
|
|
|
|
if (mParticleListHead == NULL && mDeleteWhenEmpty)
|
|
{
|
|
mDeleteOnTick = true;
|
|
}
|
|
else
|
|
{
|
|
if (numMSToUpdate != 0 && mParticleListHead)
|
|
sgParticleEngine->updateParticles(mParticleListHead, *this, numMSToUpdate);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
//--------------------------------------
|
|
//
|
|
namespace ParticleEngine {
|
|
|
|
Point3F windVelocity(0.f, 0.f, 0.f);
|
|
|
|
void init()
|
|
{
|
|
AssertFatal(sgParticleEngine == NULL, "ParticleEngine::init: engine already initialized");
|
|
|
|
sgParticleEngine = new PEngine;
|
|
}
|
|
|
|
void destroy()
|
|
{
|
|
AssertFatal(sgParticleEngine != NULL, "ParticleEngine::destroy: engine not initialized");
|
|
|
|
delete sgParticleEngine;
|
|
sgParticleEngine = NULL;
|
|
}
|
|
|
|
} // namespace ParticleEngine
|
|
|
|
//--------------------------------------------------------------------------
|
|
PEngine::PEngine()
|
|
{
|
|
mFreeList = NULL;
|
|
}
|
|
|
|
|
|
PEngine::~PEngine()
|
|
{
|
|
mFreeList = NULL;
|
|
for (U32 i = 0; i < mAllocatedBlocks.size(); i++)
|
|
{
|
|
delete [] mAllocatedBlocks[i];
|
|
mAllocatedBlocks[i] = NULL;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
Particle* PEngine::allocateParticle(ParticleEmitter* emitter)
|
|
{
|
|
if (mFreeList == NULL)
|
|
{
|
|
// Add a new block to the free list...
|
|
mAllocatedBlocks.push_back(new Particle[csmBlockSize]);
|
|
Particle* pArray = mAllocatedBlocks.last();
|
|
for (U32 i = 0; i < csmBlockSize - 1; i++)
|
|
pArray[i].nextInEngine = &pArray[i + 1];
|
|
pArray[csmBlockSize - 1].nextInEngine = NULL;
|
|
mFreeList = &pArray[0];
|
|
}
|
|
AssertFatal(mFreeList != NULL, "Error, must have a free list here!");
|
|
|
|
Particle* pParticle = mFreeList;
|
|
mFreeList = pParticle->nextInEngine;
|
|
|
|
dMemset(pParticle, 0, sizeof(Particle));
|
|
pParticle->nextInEngine = NULL;
|
|
pParticle->currentOwner = emitter;
|
|
|
|
return pParticle;
|
|
}
|
|
|
|
void PEngine::releaseParticle(Particle* release)
|
|
{
|
|
release->nextInEngine = mFreeList;
|
|
mFreeList = release;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void PEngine::updateParticles(Particle* particles, ParticleEmitter &emitter, const U32 ms)
|
|
{
|
|
AssertFatal(particles != NULL, "PEngine::updateParticles: Error, must have particles to process in this function");
|
|
AssertFatal(ms != 0, "PEngine::updateParticles: error, no time to update?");
|
|
|
|
Particle* pProbe = particles;
|
|
while (pProbe != NULL)
|
|
{
|
|
updateSingleParticle(pProbe, emitter, ms);
|
|
pProbe = pProbe->nextInList;
|
|
}
|
|
}
|
|
|
|
void PEngine::updateSingleParticle(Particle* particle, ParticleEmitter &emitter, const U32 ms)
|
|
{
|
|
AssertFatal(particle != NULL, "PEngine::updateSingleParticle: Error, must have a particle to process in this function");
|
|
AssertFatal(ms != 0, "PEngine::updateSingleParticle: error, no time to update?");
|
|
|
|
F32 t = F32(ms) / 1000.0;
|
|
|
|
Point3F a = particle->acc;
|
|
a -= particle->vel * particle->dataBlock->dragCoefficient;
|
|
a -= ParticleEngine::windVelocity * particle->dataBlock->windCoefficient;
|
|
a += Point3F(0, 0, -9.81) * particle->dataBlock->gravityCoefficient;
|
|
|
|
particle->vel += a * t;
|
|
particle->pos += particle->vel * t;
|
|
|
|
// Now update the particle's color
|
|
t = F32(particle->currentAge) / F32(particle->totalLifetime);
|
|
AssertFatal(t <= 1.0f, "Out out bounds filter function for particle.");
|
|
|
|
for (U32 i = 1; i < 4; i++)
|
|
{
|
|
if (particle->dataBlock->times[i] >= t)
|
|
{
|
|
F32 firstPart = t - particle->dataBlock->times[i-1];
|
|
F32 total = particle->dataBlock->times[i] -
|
|
particle->dataBlock->times[i-1];
|
|
|
|
firstPart /= total;
|
|
|
|
if( emitter.getDataBlock()->useEmitterColors )
|
|
{
|
|
particle->color.interpolate(emitter.colors[i-1], emitter.colors[i], firstPart);
|
|
}
|
|
else
|
|
{
|
|
particle->color.interpolate(particle->dataBlock->colors[i-1],
|
|
particle->dataBlock->colors[i],
|
|
firstPart);
|
|
}
|
|
|
|
if( emitter.getDataBlock()->useEmitterSizes )
|
|
{
|
|
particle->size = (emitter.sizes[i-1] * (1.0 - firstPart)) +
|
|
(emitter.sizes[i] * firstPart);
|
|
}
|
|
else
|
|
{
|
|
particle->size = (particle->dataBlock->sizes[i-1] * (1.0 - firstPart)) +
|
|
(particle->dataBlock->sizes[i] * firstPart);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
particle->color = particle->dataBlock->colors[ParticleEngine::PC_COLOR_KEYS - 1];
|
|
particle->size = particle->dataBlock->sizes[ParticleEngine::PC_SIZE_KEYS - 1];
|
|
}
|
|
|
|
|
|
ConsoleMethod(ParticleEmitterData, reload, void, 2, 2, "(void)"
|
|
"Reloads this emitter")
|
|
{
|
|
object->loadParameters();
|
|
object->reload();
|
|
}
|
|
|
|
ConsoleMethod(ParticleData, reload, void, 2, 2, "(void)"
|
|
"Reloads this particle")
|
|
{
|
|
object->loadParameters();
|
|
char errorBuffer[256];
|
|
object->reload(errorBuffer);
|
|
} |