// |----------------------------------------------------------------------------|
// | Logic() |
// |----------------------------------------------------------------------------|
bool ParticleSystem::Logic() {
DebugLog ("ParticleSystem: Logic() called.", DB_LOGIC, 10);
// Increment the frame time.
float time = TimerManager::GetRef()->GetTime() / 1000;
m_accumulatedTime += time;
// Set emit particle to false for now.
bool emitParticle = false;
// Check if it is time to emit a new particle or not.
if(m_accumulatedTime > (m_particleSpawnFrequency))
{
m_accumulatedTime = 0.0f;
emitParticle = true;
}
if(m_spawnParticles && (emitParticle == true) && (m_particles.size() < (m_maxParticles - 1)))
{
// Emit new particles.
EmitParticle();
}
// Update the position of the particles.
UpdateParticles();
// Release old particles.
KillParticles();
return true;
}
//--------------------------------------------------------------------------------------
// Create a VB for particles
//--------------------------------------------------------------------------------------
void SoftParticles::AdvanceParticles(double fTime, float fTimeDelta )
{
//emit new particles
static double fLastEmitTime = 0;
static UINT iLastParticleEmitted = 0;
if( !g_bAnimateParticles )
{
fLastEmitTime = fTime;
return;
}
float fEmitRate = g_fEmitRate;
float fParticleMaxSize = g_fParticleMaxSize;
float fParticleMinSize = g_fParticleMinSize;
if( PT_VOLUME_HARD == g_ParticleTechnique ||
PT_VOLUME_SOFT == g_ParticleTechnique )
{
fEmitRate *= 3.0f; //emit 1/3 less particles if we're doing volume
fParticleMaxSize *= 1.5f; //1.5x the max radius
fParticleMinSize *= 1.5f; //1.5x the min radius
}
UINT NumParticlesToEmit = (UINT)( (fTime - fLastEmitTime)/fEmitRate );
if( NumParticlesToEmit > 0 )
{
for( UINT i=0; i<NumParticlesToEmit; i++ )
{
EmitParticle( &g_pCPUParticles[iLastParticleEmitted] );
iLastParticleEmitted = (iLastParticleEmitted+1) % MAX_PARTICLES;
}
fLastEmitTime = fTime;
}
D3DXVECTOR3 vel;
float lifeSq = 0;
for( UINT i=0; i<MAX_PARTICLES; i++ )
{
if( g_pCPUParticles[i].Life > -1 )
{
// squared velocity falloff
lifeSq = g_pCPUParticles[i].Life*g_pCPUParticles[i].Life;
// Slow down by 50% as we age
vel = g_pCPUParticles[i].Vel * (1 - 0.5f*lifeSq);
vel.y += 0.5f; //(add some to the up direction, becuase of buoyancy)
g_pCPUParticles[i].Pos += vel*fTimeDelta;
g_pCPUParticles[i].Life += fTimeDelta/g_fParticleLifeSpan;
g_pCPUParticles[i].Size = fParticleMinSize + (fParticleMaxSize-fParticleMinSize) * g_pCPUParticles[i].Life;
if( g_pCPUParticles[i].Life > 0.99f )
g_pCPUParticles[i].Life = -1;
}
}
}
void MovingTile::OnTopCollision(Entity* collider, sf::FloatRect intersection)
{
SpecialTile::OnTopCollision(collider, intersection);
EmitParticle(sf::milliseconds(500), false);
if (collider->IsUnit())
collider->ToUnit()->Vehicle = this;
Passengers.insert(collider);
}
// |----------------------------------------------------------------------------|
// | EmitAllParticles() |
// |----------------------------------------------------------------------------|
void ParticleSystem::EmitAllParticles() {
DebugLog ("ParticleSystem: EmitAllParticles() called.", DB_LOGIC, 10);
while(m_particles.size() < m_maxParticles)
{
// Emit new particles.
EmitParticle();
}
return;
}
void ParticleEmitterInstance::UpdateEmitter(float aDeltaTime, const CU::Matrix44f& aWorldMatrix)
{
myEmissionTime -= aDeltaTime;
myEmitterLife -= aDeltaTime;
UpdateParticle(aDeltaTime);
if (myEmissionTime <= 0.f && (myEmitterLife > 0.f || myParticleEmitterData->myUseEmitterLifeTime == false)
&& myShouldLive == true)
{
EmitParticle(aWorldMatrix);
myEmissionTime = myParticleEmitterData->myEmissionRate * 8.f;
if (myIsCloseToPlayer == false)
myEmissionTime = myParticleEmitterData->myEmissionRate;
}
if (myEmitterLife <= 0.f && myDeadParticleCount == myLogicalParticles.Size())
{
myIsActive = false;
}
}
void UpdBls()
{
#if 0
static float completion = 2.0f;
if(completion+EPSILON >= 1 && completion-EPSILON <= 1)
Explode(&g_building[1]);
#if 1
//StageCopyVA(&g_building[0].drawva, &g_model[g_bltype[g_building[0].type].model].m_va[0], completion);
HeightCopyVA(&g_building[1].drawva, &g_model[g_bltype[g_building[1].type].model].m_va[0], Clipf(completion, 0, 1));
completion -= 0.01f;
if(completion < -1.0f)
completion = 2.0f;
#elif 1
HeightCopyVA(&g_building[0].drawva, &g_model[g_bltype[g_building[0].type].model].m_va[0], completion);
completion *= 0.95f;
if(completion < 0.001f)
completion = 1.0f;
#endif
#elif 0
static float completion = 2.0f;
StageCopyVA(&g_building[0].drawva, &g_model[g_bltype[g_building[0].type].cmodel].m_va[0], completion);
completion += 0.005f;
if(completion < 2.0f && completion >= 1.0f)
{
g_building[0].finished = true;
CopyVA(&g_building[0].drawva, &g_model[g_bltype[g_building[0].type].model].m_va[0]);
}
if(completion >= 2.0f)
{
completion = 0.1f;
g_building[0].finished = false;
}
#endif
for(int i=0; i<BUILDINGS; i++)
{
Building* b = &g_building[i];
if(!b->on)
continue;
BuildingT* t = &g_bltype[b->type];
EmitterPlace* ep;
ParticleT* pt;
if(!b->finished)
continue;
for(int j=0; j<MAX_B_EMITTERS; j++)
{
//first = true;
//if(completion < 1)
// continue;
ep = &t->emitterpl[j];
if(!ep->on)
continue;
pt = &g_particleT[ep->type];
if(b->emitterco[j].EmitNext(pt->delay))
EmitParticle(ep->type, b->drawpos + ep->offset);
}
}
}
void SceneObject_ParticleEmitter_Sprite::Logic()
{
// ----------------------- Spawning -----------------------
if(m_emit)
{
m_spawnTimer += GetScene()->m_frameTimer.GetTimeMultiplier();
if(m_spawnTimer > m_spawnTime)
{
// Spawn multiple per frame, if went over more than one multiple of the spawn time
int numSpawn = static_cast<int>(m_spawnTimer / m_spawnTime);
// Spawn particles
for(int i = 0; i < numSpawn; i++)
m_pParticles.push_back(EmitParticle());
// Reset timer, keep overflow (fmodf equivalent)
m_spawnTimer -= numSpawn * m_spawnTime;
// Pick new random spawn time
m_spawnTime = Randf(m_minSpawnTime, m_maxSpawnTime);
}
}
// ----------------------- Updating -----------------------
if(m_pParticles.empty())
{
if(m_autoDestruct)
Destroy();
}
else
{
// Recalculate AABB while at it
m_aabb.m_lowerBound = m_pParticles.front()->m_position;
m_aabb.m_upperBound = m_aabb.m_lowerBound;
for(std::list<Particle_Sprite*>::iterator it = m_pParticles.begin(); it != m_pParticles.end();)
{
Particle_Sprite* pParticle = *it;
if(pParticle->Logic())
{
// Destroy particle
delete pParticle;
it = m_pParticles.erase(it);
}
else
{
// Affect particle
for(unsigned int i = 0, size = m_pAffectorFuncs.size(); i < size; i++)
m_pAffectorFuncs[i](pParticle);
// Grow AABB
float radius = pParticle->GetRadius();
Vec3f particleLower(pParticle->m_position - Vec3f(radius, radius, radius));
Vec3f particleUpper(pParticle->m_position + Vec3f(radius, radius, radius));
if(particleLower.x < m_aabb.m_lowerBound.x)
m_aabb.m_lowerBound.x = pParticle->m_position.x - pParticle->m_radius;
if(particleLower.y < m_aabb.m_lowerBound.y)
m_aabb.m_lowerBound.y = pParticle->m_position.y - pParticle->m_radius;
if(particleLower.z < m_aabb.m_lowerBound.z)
m_aabb.m_lowerBound.z = pParticle->m_position.z - pParticle->m_radius;
if(particleUpper.x > m_aabb.m_upperBound.x)
m_aabb.m_upperBound.x = pParticle->m_position.x + pParticle->m_radius;
if(particleUpper.y > m_aabb.m_upperBound.y)
m_aabb.m_upperBound.y = pParticle->m_position.y + pParticle->m_radius;
if(particleUpper.z > m_aabb.m_upperBound.z)
m_aabb.m_upperBound.z = pParticle->m_position.z + pParticle->m_radius;
it++;
}
}
if(IsSPTManaged())
TreeUpdate();
}
}
void SceneObject_ParticleEmitter_Sprite::SpawnBurst(int numParticles)
{
for(int i = 0; i < numParticles; i++)
m_pParticles.push_back(EmitParticle());
}
