d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
55 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 850fca74ee
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '850fca74ee'
${ noResults }
source-engine/particles/builtin_particle_emitters.cpp

876 lines
29 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: particle system code
//
//===========================================================================//
#include "tier0/platform.h"
#include "particles/particles.h"
#include "filesystem.h"
#include "tier2/tier2.h"
#include "tier2/fileutils.h"
#include "tier1/UtlStringMap.h"
#include "tier1/strtools.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern int g_nParticle_Multiplier;
//-----------------------------------------------------------------------------
// Emits particles immediately
//-----------------------------------------------------------------------------
struct InstantaneousEmitterContext_t
{
int m_nRemainingParticles;
int m_ActualParticlesToEmit;
float m_flTimeOffset;
bool m_bReadScaleFactor;
};
class C_OP_InstantaneousEmitter : public CParticleOperatorInstance
{
DECLARE_PARTICLE_OPERATOR( C_OP_InstantaneousEmitter );
uint32 GetWrittenAttributes( void ) const
{
return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
}
uint32 GetReadAttributes( void ) const
{
return 0;
}
virtual uint64 GetReadControlPointMask() const
{
if ( m_nScaleControlPoint >= 0 )
return ( 1ULL << m_nScaleControlPoint );
return 0;
}
virtual uint32 Emit( CParticleCollection *pParticles, float flCurStrength,
void *pContext ) const;
// unpack structure will be applied by creator. add extra initialization needed here
virtual void InitParams( CParticleSystemDefinition *pDef, CDmxElement *pElement )
{
if ( m_nMinParticlesToEmit >= 0 )
{
if ( m_nMinParticlesToEmit > m_nParticlesToEmit )
{
V_swap( m_nParticlesToEmit, m_nMinParticlesToEmit );
}
}
if ( m_nPerFrameNum < 0 )
{
m_nPerFrameNum = INT_MAX;
}
m_nScaleControlPointField = clamp( m_nScaleControlPointField, 0, 2 );
}
virtual void StopEmission( CParticleCollection *pParticles, void *pContext, bool bInfiniteOnly ) const
{
InstantaneousEmitterContext_t *pCtx = reinterpret_cast<InstantaneousEmitterContext_t *>( pContext );
if ( !bInfiniteOnly )
{
pCtx->m_nRemainingParticles = 0;
}
}
virtual void StartEmission( CParticleCollection *pParticles, void *pContext, bool bInfiniteOnly ) const
{
InstantaneousEmitterContext_t *pCtx = reinterpret_cast<InstantaneousEmitterContext_t *>( pContext );
if ( !bInfiniteOnly )
{
pCtx->m_nRemainingParticles = pCtx->m_ActualParticlesToEmit;
SkipToTime( pParticles->m_flCurTime, pParticles, pCtx );
}
}
// Called when the SFM wants to skip forward in time
virtual void SkipToTime( float flTime, CParticleCollection *pParticles, void *pContext ) const
{
// NOTE: This is a bit of a hack. We're saying that if we're skipping more than two seconds, that we're
// probably not going to bother emitting at all. Really, this would have to know the maximum
// lifetime of the child particles and only skip if past that.
InstantaneousEmitterContext_t *pCtx = reinterpret_cast<InstantaneousEmitterContext_t *>( pContext );
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( flTime > ( flStartTime + 2.0f ) )
{
pCtx->m_nRemainingParticles = 0;
}
}
virtual void InitializeContextData( CParticleCollection *pParticles, void *pContext ) const
{
InstantaneousEmitterContext_t *pCtx = reinterpret_cast<InstantaneousEmitterContext_t *>( pContext );
if ( m_nMinParticlesToEmit >= 0 )
{
pCtx->m_ActualParticlesToEmit = pParticles->RandomInt( m_nMinParticlesToEmit, m_nParticlesToEmit );
}
else
{
pCtx->m_ActualParticlesToEmit = m_nParticlesToEmit;
}
pCtx->m_nRemainingParticles = pCtx->m_ActualParticlesToEmit;
pCtx->m_flTimeOffset = 0.0f;
pCtx->m_bReadScaleFactor = false;
}
virtual void Restart( CParticleCollection *pParticles, void *pContext )
{
InstantaneousEmitterContext_t *pCtx = reinterpret_cast<InstantaneousEmitterContext_t *>( pContext );
pCtx->m_nRemainingParticles = pCtx->m_ActualParticlesToEmit;
pCtx->m_flTimeOffset = pParticles->m_flCurTime;
pCtx->m_bReadScaleFactor = false;
}
size_t GetRequiredContextBytes( void ) const
{
return sizeof( InstantaneousEmitterContext_t );
}
virtual bool MayCreateMoreParticles( CParticleCollection *pParticles, void *pContext ) const
{
InstantaneousEmitterContext_t *pCtx = reinterpret_cast<InstantaneousEmitterContext_t *>( pContext );
return !(pCtx->m_nRemainingParticles <= 0);
}
int m_nParticlesToEmit;
int m_nMinParticlesToEmit;
float m_flStartTime;
int m_nPerFrameNum;
int m_nScaleControlPoint;
int m_nScaleControlPointField;
};
DEFINE_PARTICLE_OPERATOR( C_OP_InstantaneousEmitter, "emit_instantaneously", OPERATOR_GENERIC );
BEGIN_PARTICLE_OPERATOR_UNPACK( C_OP_InstantaneousEmitter )
DMXELEMENT_UNPACK_FIELD( "emission_start_time", "0", float, m_flStartTime )
DMXELEMENT_UNPACK_FIELD( "num_to_emit_minimum", "-1", int, m_nMinParticlesToEmit )
DMXELEMENT_UNPACK_FIELD( "num_to_emit", "100", int, m_nParticlesToEmit )
DMXELEMENT_UNPACK_FIELD( "maximum emission per frame", "-1", int, m_nPerFrameNum )
DMXELEMENT_UNPACK_FIELD( "emission count scale control point", "-1", int, m_nScaleControlPoint )
DMXELEMENT_UNPACK_FIELD( "emission count scale control point field", "0", int, m_nScaleControlPointField )
END_PARTICLE_OPERATOR_UNPACK( C_OP_InstantaneousEmitter )
uint32 C_OP_InstantaneousEmitter::Emit( CParticleCollection *pParticles, float flCurStrength,
void *pContext ) const
{
// Don't emit any more if the particle system has emitted all it's supposed to.
InstantaneousEmitterContext_t *pCtx = reinterpret_cast<InstantaneousEmitterContext_t *>( pContext );
if ( pCtx->m_nRemainingParticles <= 0 )
return 0;
// Wait until we're told to start emitting
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( pParticles->m_flCurTime < flStartTime )
return 0;
if ( pCtx->m_ActualParticlesToEmit == 0 )
return 0;
if ( ( m_nScaleControlPoint >= 0 ) && !pCtx->m_bReadScaleFactor )
{
Vector vecScale;
if ( flStartTime <= pParticles->m_flCurTime && flStartTime >= pParticles->m_flCurTime - pParticles->m_flPreviousDt )
{
pParticles->GetControlPointAtTime( m_nScaleControlPoint, flStartTime, &vecScale );
}
else
{
pParticles->GetControlPointAtPrevTime( m_nScaleControlPoint, &vecScale );
}
pCtx->m_ActualParticlesToEmit *= vecScale[m_nScaleControlPointField];
pCtx->m_nRemainingParticles *= vecScale[m_nScaleControlPointField];
pCtx->m_bReadScaleFactor = true;
}
pCtx->m_nRemainingParticles = max( pCtx->m_nRemainingParticles, 0 );
// NOTE: Applying the scale here because I don't believe we can sample the control point
// values inside
// We're only allowed to emit so many particles, though..
// If we run out of room, only emit the last N particles
int nAllowedParticlesToEmit = pParticles->m_nMaxAllowedParticles - pParticles->m_nActiveParticles;
// Cap to the maximum emission per frame
int nParticlesThisFrame = min( m_nPerFrameNum, pCtx->m_nRemainingParticles );
nAllowedParticlesToEmit = min( nAllowedParticlesToEmit, nParticlesThisFrame );
int nActualParticlesToEmit = min( nAllowedParticlesToEmit, pCtx->m_ActualParticlesToEmit * g_nParticle_Multiplier );
pCtx->m_nRemainingParticles -= nParticlesThisFrame;
Assert( pCtx->m_nRemainingParticles >= 0 );
if ( nActualParticlesToEmit == 0 )
return 0;
int nStartParticle = pParticles->m_nActiveParticles;
pParticles->SetNActiveParticles( nActualParticlesToEmit + pParticles->m_nActiveParticles );
// !! speed!! do sse init here
for( int i = nStartParticle; i < nStartParticle + nActualParticlesToEmit; i++ )
{
float *pTimeStamp = pParticles->GetFloatAttributePtrForWrite( PARTICLE_ATTRIBUTE_CREATION_TIME, i );
*pTimeStamp = flStartTime;
}
return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
}
//-----------------------------------------------------------------------------
// Emits particles over time
//-----------------------------------------------------------------------------
struct ContinuousEmitterContext_t
{
float m_flTotalActualParticlesSoFar;
int m_nTotalEmittedSoFar;
float m_flNextEmitTime;
float m_flTimeOffset;
bool m_bStoppedEmission;
};
bool g_bDontMakeSkipToTimeTakeForever = false;
class C_OP_ContinuousEmitter : public CParticleOperatorInstance
{
DECLARE_PARTICLE_OPERATOR( C_OP_ContinuousEmitter );
uint32 GetWrittenAttributes( void ) const
{
return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
}
uint32 GetReadAttributes( void ) const
{
return 0;
}
virtual void InitParams( CParticleSystemDefinition *pDef, CDmxElement *pElement )
{
if ( m_flEmitRate < 0.0f )
{
m_flEmitRate = 0.0f;
}
if ( m_flEmissionDuration < 0.0f )
{
m_flEmissionDuration = 0.0f;
}
m_flEmitRate *= g_nParticle_Multiplier;
}
virtual uint32 Emit( CParticleCollection *pParticles, float flCurStrength,
void *pContext ) const ;
inline bool IsInfinitelyEmitting() const
{
return ( m_flEmissionDuration == 0.0f );
}
virtual void StopEmission( CParticleCollection *pParticles, void *pContext, bool bInfiniteOnly ) const
{
ContinuousEmitterContext_t *pCtx = reinterpret_cast<ContinuousEmitterContext_t *>( pContext );
if ( !bInfiniteOnly || IsInfinitelyEmitting() )
{
pCtx->m_bStoppedEmission = true;
}
}
virtual void StartEmission( CParticleCollection *pParticles, void *pContext, bool bInfiniteOnly ) const
{
ContinuousEmitterContext_t *pCtx = reinterpret_cast<ContinuousEmitterContext_t *>( pContext );
if ( !bInfiniteOnly || IsInfinitelyEmitting() )
{
pCtx->m_bStoppedEmission = false;
SkipToTime( pParticles->m_flCurTime, pParticles, pCtx );
}
}
virtual void InitializeContextData( CParticleCollection *pParticles, void *pContext ) const
{
ContinuousEmitterContext_t *pCtx = reinterpret_cast<ContinuousEmitterContext_t *>( pContext );
pCtx->m_flNextEmitTime = m_flStartTime;
pCtx->m_flTotalActualParticlesSoFar = 0.0f;
pCtx->m_nTotalEmittedSoFar = 0;
pCtx->m_flTimeOffset = 0.0f;
pCtx->m_bStoppedEmission = false;
}
virtual void Restart( CParticleCollection *pParticles, void *pContext )
{
if ( !IsInfinitelyEmitting() )
{
ContinuousEmitterContext_t *pCtx = reinterpret_cast<ContinuousEmitterContext_t *>( pContext );
pCtx->m_flNextEmitTime = pParticles->m_flCurTime + m_flStartTime;
pCtx->m_flTotalActualParticlesSoFar = 0.0f;
pCtx->m_nTotalEmittedSoFar = 0;
pCtx->m_flTimeOffset = pParticles->m_flCurTime;
}
}
// Called when the SFM wants to skip forward in time
// Currently hacked for save/load pre-sim - correct solution is to serialize rather
// than skip-to-time and simulate
virtual void SkipToTime( float flTime, CParticleCollection *pParticles, void *pContext ) const
{
ContinuousEmitterContext_t *pCtx = reinterpret_cast<ContinuousEmitterContext_t *>( pContext );
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( flTime <= flStartTime )
return;
float flControlPointScale = pParticles->GetHighestControlPoint();
flControlPointScale *= m_flEmissionScale;
float flEmissionRate = m_flEmitRate;
float flEmitStrength;
if ( pParticles->CheckIfOperatorShouldRun( this, &flEmitStrength ) )
{
flEmissionRate *= flEmitStrength;
}
if ( flControlPointScale != 0.0f )
{
flEmissionRate *= flControlPointScale;
}
float flPrevDrawTime = pParticles->m_flCurTime - flTime;
float flCurrDrawTime = pParticles->m_flCurTime;
if ( !IsInfinitelyEmitting() )
{
if ( flPrevDrawTime < flStartTime )
{
flPrevDrawTime = flStartTime;
}
//if ( flCurrDrawTime > flStartTime + m_flEmissionDuration )
//{
// flCurrDrawTime = flStartTime + m_flEmissionDuration;
//}
}
float flDeltaTime = flCurrDrawTime - flPrevDrawTime;
flDeltaTime = min( flDeltaTime, 4.f );
flPrevDrawTime = flCurrDrawTime - flDeltaTime;
//disabled for now
pCtx->m_flTotalActualParticlesSoFar = flDeltaTime * flEmissionRate;
//if ( !IsInfinitelyEmitting() )
// pCtx->m_flTotalActualParticlesSoFar = min( pCtx->m_ActualParticlesToEmit, pCtx->m_flTotalActualParticlesSoFar );
pCtx->m_nTotalEmittedSoFar = 0;
//simulate a bunch
int nActualParticlesToEmit = floor (pCtx->m_flTotalActualParticlesSoFar);
int nStartParticle = pParticles->m_nActiveParticles;
if ( pParticles->m_nMaxAllowedParticles < nStartParticle + nActualParticlesToEmit )
{
nActualParticlesToEmit = pParticles->m_nMaxAllowedParticles - nStartParticle;
}
pParticles->SetNActiveParticles( nActualParticlesToEmit + pParticles->m_nActiveParticles );
float flTimeStampStep = ( flDeltaTime ) / ( nActualParticlesToEmit );
float flTimeStep = flPrevDrawTime + flTimeStampStep;
// Set the particle creation time to the exact sub-frame particle emission time
// !! speed!! do sse init here
for( int i = nStartParticle; i < nStartParticle + nActualParticlesToEmit; i++ )
{
float *pTimeStamp = pParticles->GetFloatAttributePtrForWrite( PARTICLE_ATTRIBUTE_CREATION_TIME, i );
flTimeStep = min( flTimeStep, flCurrDrawTime );
*pTimeStamp = flTimeStep;
flTimeStep += flTimeStampStep;
}
if ( !g_bDontMakeSkipToTimeTakeForever )
{
flPrevDrawTime = max( flPrevDrawTime, flCurrDrawTime - pParticles->m_pDef->m_flNoDrawTimeToGoToSleep );
pParticles->m_flCurTime = flPrevDrawTime;
pParticles->m_fl4CurTime = ReplicateX4( flPrevDrawTime );
for( float i = flPrevDrawTime; i < flCurrDrawTime; i += 0.1 )
{
pParticles->Simulate( .1, false );
}
}
}
size_t GetRequiredContextBytes( void ) const
{
return sizeof( ContinuousEmitterContext_t );
}
virtual bool MayCreateMoreParticles( CParticleCollection *pParticles, void *pContext ) const
{
ContinuousEmitterContext_t *pCtx = reinterpret_cast<ContinuousEmitterContext_t *>( pContext );
if ( pCtx->m_bStoppedEmission )
return false;
if ( m_flEmitRate <= 0.0f )
return false;
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( m_flEmissionDuration != 0.0f && ( pParticles->m_flCurTime - pParticles->m_flDt ) > ( flStartTime + m_flEmissionDuration ) )
return false;
return true;
}
float m_flEmissionDuration;
float m_flStartTime;
float m_flEmitRate;
float m_flTimePerEmission;
float m_flEmissionScale;
bool m_bScalePerParticle;
};
DEFINE_PARTICLE_OPERATOR( C_OP_ContinuousEmitter, "emit_continuously", OPERATOR_GENERIC );
BEGIN_PARTICLE_OPERATOR_UNPACK( C_OP_ContinuousEmitter )
DMXELEMENT_UNPACK_FIELD( "emission_start_time", "0", float, m_flStartTime )
DMXELEMENT_UNPACK_FIELD( "emission_rate", "100", float, m_flEmitRate )
DMXELEMENT_UNPACK_FIELD( "emission_duration", "0", float, m_flEmissionDuration )
DMXELEMENT_UNPACK_FIELD( "scale emission to used control points", "0.0", float, m_flEmissionScale )
DMXELEMENT_UNPACK_FIELD( "use parent particles for emission scaling", "0", bool, m_bScalePerParticle )
END_PARTICLE_OPERATOR_UNPACK( C_OP_ContinuousEmitter )
uint32 C_OP_ContinuousEmitter::Emit( CParticleCollection *pParticles, float flCurStrength,
void *pContext ) const
{
// Have we emitted all the particles we're going to emit?
// NOTE: Using C_OP_ContinuousEmitter:: avoids a virtual function call
ContinuousEmitterContext_t *pCtx = reinterpret_cast<ContinuousEmitterContext_t *>( pContext );
//Allows for dynamic scaling via changes in number of control points.
float flControlPointScale = pParticles->GetHighestControlPoint();
//The emission scale here allows for a scalar value per controlpoint, like 2 or .25...
flControlPointScale *= m_flEmissionScale;
//Global strength scale brought in by operator fade in/fade out/oscillate
float flEmissionRate = m_flEmitRate * flCurStrength;
if ( flControlPointScale != 0.0f || m_bScalePerParticle )
{
if ( m_bScalePerParticle )
{
if ( pParticles->m_pParent )
{
flControlPointScale = pParticles->m_pParent->m_nActiveParticles * m_flEmissionScale;
}
else
{
flControlPointScale = m_flEmissionScale;
}
}
flEmissionRate *= flControlPointScale;
}
if ( flEmissionRate == 0.0f )
return 0;
if ( !C_OP_ContinuousEmitter::MayCreateMoreParticles( pParticles, pContext ) )
return 0;
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( pParticles->m_flCurTime < flStartTime )
return 0;
Assert( flEmissionRate != 0.0f );
// determine our previous and current draw times and clamp them to start time and emission duration
float flPrevDrawTime = pParticles->m_flCurTime - pParticles->m_flDt;
float flCurrDrawTime = pParticles->m_flCurTime;
if ( !IsInfinitelyEmitting() )
{
if ( flPrevDrawTime < flStartTime )
{
flPrevDrawTime = flStartTime;
}
if ( flCurrDrawTime > flStartTime + m_flEmissionDuration )
{
flCurrDrawTime = flStartTime + m_flEmissionDuration;
}
}
float flDeltaTime = flCurrDrawTime - flPrevDrawTime;
//Calculate emission rate by delta time from last frame to determine number of particles to emit this frame as a fractional float
float flActualParticlesToEmit = flEmissionRate * flDeltaTime;
//Add emitted particle to float counter to allow for fractional emission
pCtx->m_flTotalActualParticlesSoFar += flActualParticlesToEmit;
//Floor float accumulated value and subtract whole int emitted so far from the result to determine total whole particles to emit this frame
int nParticlesToEmit = floor ( pCtx->m_flTotalActualParticlesSoFar ) - pCtx->m_nTotalEmittedSoFar;
//Add emitted particles to running int total.
pCtx->m_nTotalEmittedSoFar += nParticlesToEmit;
if ( nParticlesToEmit == 0 )
return 0;
// We're only allowed to emit so many particles, though..
// If we run out of room, only emit the last N particles
int nActualParticlesToEmit = nParticlesToEmit;
int nAllowedParticlesToEmit = pParticles->m_nMaxAllowedParticles - pParticles->m_nActiveParticles;
if ( nAllowedParticlesToEmit < nParticlesToEmit )
{
nActualParticlesToEmit = nAllowedParticlesToEmit;
//flStartEmissionTime = pCtx->m_flNextEmitTime - flTimePerEmission * nActualParticlesToEmit;
}
if ( nActualParticlesToEmit == 0 )
return 0;
int nStartParticle = pParticles->m_nActiveParticles;
pParticles->SetNActiveParticles( nActualParticlesToEmit + pParticles->m_nActiveParticles );
float flTimeStampStep = ( flDeltaTime ) / ( nActualParticlesToEmit );
float flTimeStep = flPrevDrawTime + flTimeStampStep;
// Set the particle creation time to the exact sub-frame particle emission time
// !! speed!! do sse init here
for( int i = nStartParticle; i < nStartParticle + nActualParticlesToEmit; i++ )
{
float *pTimeStamp = pParticles->GetFloatAttributePtrForWrite( PARTICLE_ATTRIBUTE_CREATION_TIME, i );
flTimeStep = min( flTimeStep, flCurrDrawTime );
*pTimeStamp = flTimeStep;
flTimeStep += flTimeStampStep;
}
return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
}
//-----------------------------------------------------------------------------
// Noise Emitter
//-----------------------------------------------------------------------------
struct NoiseEmitterContext_t
{
float m_flTotalActualParticlesSoFar;
int m_nTotalEmittedSoFar;
float m_flNextEmitTime;
float m_flTimeOffset;
bool m_bStoppedEmission;
};
class C_OP_NoiseEmitter : public CParticleOperatorInstance
{
DECLARE_PARTICLE_OPERATOR( C_OP_NoiseEmitter );
uint32 GetWrittenAttributes( void ) const
{
return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
}
uint32 GetReadAttributes( void ) const
{
return 0;
}
virtual void InitParams( CParticleSystemDefinition *pDef, CDmxElement *pElement )
{
if ( m_flEmitRate < 0.0f )
{
m_flEmitRate = 0.0f;
}
if ( m_flEmissionDuration < 0.0f )
{
m_flEmissionDuration = 0.0f;
}
m_flEmitRate *= g_nParticle_Multiplier;
}
virtual uint32 Emit( CParticleCollection *pParticles, float flCurStrength,
void *pContext ) const ;
inline bool IsInfinitelyEmitting() const
{
return ( m_flEmissionDuration == 0.0f );
}
virtual void StopEmission( CParticleCollection *pParticles, void *pContext, bool bInfiniteOnly ) const
{
NoiseEmitterContext_t *pCtx = reinterpret_cast<NoiseEmitterContext_t *>( pContext );
if ( !bInfiniteOnly || IsInfinitelyEmitting() )
{
pCtx->m_bStoppedEmission = true;
}
}
virtual void StartEmission( CParticleCollection *pParticles, void *pContext, bool bInfiniteOnly ) const
{
NoiseEmitterContext_t *pCtx = reinterpret_cast<NoiseEmitterContext_t *>( pContext );
if ( !bInfiniteOnly || IsInfinitelyEmitting() )
{
pCtx->m_bStoppedEmission = false;
SkipToTime( pParticles->m_flCurTime, pParticles, pCtx );
}
}
virtual void InitializeContextData( CParticleCollection *pParticles, void *pContext ) const
{
NoiseEmitterContext_t *pCtx = reinterpret_cast<NoiseEmitterContext_t *>( pContext );
pCtx->m_flNextEmitTime = m_flStartTime;
pCtx->m_flTotalActualParticlesSoFar = 1.0f;
pCtx->m_nTotalEmittedSoFar = 0;
pCtx->m_flTimeOffset = 0.0f;
pCtx->m_bStoppedEmission = false;
}
virtual void Restart( CParticleCollection *pParticles, void *pContext )
{
if ( !IsInfinitelyEmitting() )
{
NoiseEmitterContext_t *pCtx = reinterpret_cast<NoiseEmitterContext_t *>( pContext );
pCtx->m_flNextEmitTime = m_flStartTime + pParticles->m_flCurTime;
pCtx->m_flTotalActualParticlesSoFar = 1.0f;
pCtx->m_nTotalEmittedSoFar = 0;
pCtx->m_flTimeOffset = pParticles->m_flCurTime;
}
}
// Called when the SFM wants to skip forward in time
virtual void SkipToTime( float flTime, CParticleCollection *pParticles, void *pContext ) const
{
NoiseEmitterContext_t *pCtx = reinterpret_cast<NoiseEmitterContext_t *>( pContext );
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( flTime <= flStartTime )
return;
float flControlPointScale = pParticles->GetHighestControlPoint();
flControlPointScale *= m_flEmissionScale;
float flEmissionRate = m_flEmitRate;
float flEmitStrength;
if ( pParticles->CheckIfOperatorShouldRun( this, &flEmitStrength ) )
{
flEmissionRate *= flEmitStrength;
}
if ( flControlPointScale != 0.0f )
{
flEmissionRate *= flControlPointScale;
}
pCtx->m_flTotalActualParticlesSoFar = ( pParticles->m_flCurTime - flStartTime ) * flEmissionRate + 1;
//if ( !IsInfinitelyEmitting() )
// pCtx->m_flTotalActualParticlesSoFar = min( pCtx->m_ActualParticlesToEmit, pCtx->m_flTotalActualParticlesSoFar );
pCtx->m_nTotalEmittedSoFar = 0;
}
size_t GetRequiredContextBytes( void ) const
{
return sizeof( NoiseEmitterContext_t );
}
virtual bool MayCreateMoreParticles( CParticleCollection *pParticles, void *pContext ) const
{
NoiseEmitterContext_t *pCtx = reinterpret_cast<NoiseEmitterContext_t *>( pContext );
if ( pCtx->m_bStoppedEmission )
return false;
if ( m_flEmitRate <= 0.0f )
return false;
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( m_flEmissionDuration != 0.0f && ( pParticles->m_flCurTime - pParticles->m_flDt ) > ( flStartTime + m_flEmissionDuration ) )
return false;
return true;
}
float m_flEmissionDuration;
float m_flStartTime;
float m_flEmitRate;
float m_flTimePerEmission;
float m_flEmissionScale;
bool m_bAbsVal, m_bAbsValInv;
float m_flOffset;
float m_flOutputMin;
float m_flOutputMax;
float m_flNoiseScale, m_flNoiseScaleLoc;
Vector m_vecOffsetLoc;
float m_flWorldTimeScale;
};
DEFINE_PARTICLE_OPERATOR( C_OP_NoiseEmitter, "emit noise", OPERATOR_GENERIC );
BEGIN_PARTICLE_OPERATOR_UNPACK( C_OP_NoiseEmitter )
DMXELEMENT_UNPACK_FIELD( "emission_start_time", "0", float, m_flStartTime )
DMXELEMENT_UNPACK_FIELD( "emission_duration", "0", float, m_flEmissionDuration )
DMXELEMENT_UNPACK_FIELD( "scale emission to used control points", "0.0", float, m_flEmissionScale )
DMXELEMENT_UNPACK_FIELD( "time noise coordinate scale","0.1",float,m_flNoiseScale)
//DMXELEMENT_UNPACK_FIELD( "spatial noise coordinate scale","0.001",float,m_flNoiseScaleLoc)
DMXELEMENT_UNPACK_FIELD( "time coordinate offset","0", float, m_flOffset )
//DMXELEMENT_UNPACK_FIELD( "spatial coordinate offset","0 0 0", Vector, m_vecOffsetLoc )
DMXELEMENT_UNPACK_FIELD( "absolute value","0", bool, m_bAbsVal )
DMXELEMENT_UNPACK_FIELD( "invert absolute value","0", bool, m_bAbsValInv )
DMXELEMENT_UNPACK_FIELD( "emission minimum","0", float, m_flOutputMin )
DMXELEMENT_UNPACK_FIELD( "emission maximum","100", float, m_flOutputMax )
DMXELEMENT_UNPACK_FIELD( "world time noise coordinate scale","0", float, m_flWorldTimeScale )
END_PARTICLE_OPERATOR_UNPACK( C_OP_NoiseEmitter )
uint32 C_OP_NoiseEmitter::Emit( CParticleCollection *pParticles, float flCurStrength,
void *pContext ) const
{
// Have we emitted all the particles we're going to emit?
// NOTE: Using C_OP_ContinuousEmitter:: avoids a virtual function call
NoiseEmitterContext_t *pCtx = reinterpret_cast<NoiseEmitterContext_t *>( pContext );
//Allows for dynamic scaling via changes in number of control points.
float flControlPointScale = pParticles->GetHighestControlPoint();
//The emission scale here allows for a scalar value per controlpoint, like 2 or .25...
flControlPointScale *= m_flEmissionScale;
float flAbsScale;
int nAbsVal;
nAbsVal = 0xffffffff;
flAbsScale = 0.5;
if ( m_bAbsVal )
{
nAbsVal = 0x7fffffff;
flAbsScale = 1.0;
}
float fMin = m_flOutputMin;
float fMax = m_flOutputMax;
float CoordScale = m_flNoiseScale;
//float CoordScaleLoc = m_flNoiseScaleLoc;
float ValueScale, ValueBase;
Vector Coord, CoordLoc, CoordWorldTime;
//CoordLoc.x = pxyz[0];
//CoordLoc.y = pxyz[4];
//CoordLoc.z = pxyz[8];
//CoordLoc += m_vecOffsetLoc;
float Offset = m_flOffset;
Coord = Vector ( (pParticles->m_flCurTime + Offset), (pParticles->m_flCurTime + Offset), (pParticles->m_flCurTime + Offset) );
Coord *= CoordScale;
//CoordLoc *= CoordScaleLoc;
//Coord += CoordLoc;
CoordWorldTime = Vector( (Plat_MSTime() * m_flWorldTimeScale), (Plat_MSTime() * m_flWorldTimeScale), (Plat_MSTime() * m_flWorldTimeScale) );
Coord += CoordWorldTime;
fltx4 flNoise128;
FourVectors fvNoise;
fvNoise.DuplicateVector( Coord );
flNoise128 = NoiseSIMD( fvNoise );
float flNoise = SubFloat( flNoise128, 0 );
*( (int *) &flNoise) &= nAbsVal;
ValueScale = ( flAbsScale *( fMax - fMin ) );
ValueBase = ( fMin+ ( ( 1.0 - flAbsScale ) *( fMax - fMin ) ) );
if ( m_bAbsValInv )
{
flNoise = 1.0 - flNoise;
}
float flInitialNoise = ( ValueBase + ( ValueScale * flNoise ) );
flInitialNoise = clamp(flInitialNoise, 0.0f, (float) INT_MAX );
//Global strength scale brought in by operator fade in/fade out/oscillate
float flEmissionRate = flInitialNoise * flCurStrength;
if ( flControlPointScale != 0.0f )
{
flEmissionRate *= flControlPointScale;
}
if ( flEmissionRate == 0.0f )
return 0;
if ( !C_OP_NoiseEmitter::MayCreateMoreParticles( pParticles, pContext ) )
return 0;
float flStartTime = m_flStartTime + pCtx->m_flTimeOffset;
if ( pParticles->m_flCurTime < flStartTime )
return 0;
Assert( flEmissionRate != 0.0f );
// determine our previous and current draw times and clamp them to start time and emission duration
float flPrevDrawTime = pParticles->m_flCurTime - pParticles->m_flDt;
float flCurrDrawTime = pParticles->m_flCurTime;
if ( !IsInfinitelyEmitting() )
{
if ( flPrevDrawTime < flStartTime )
{
flPrevDrawTime = flStartTime;
}
if ( flCurrDrawTime > flStartTime + m_flEmissionDuration )
{
flCurrDrawTime = flStartTime + m_flEmissionDuration;
}
}
float flDeltaTime = flCurrDrawTime - flPrevDrawTime;
//Calculate emission rate by delta time from last frame to determine number of particles to emit this frame as a fractional float
float flActualParticlesToEmit = flEmissionRate * flDeltaTime;
//Add emitted particle to float counter to allow for fractional emission
pCtx->m_flTotalActualParticlesSoFar += flActualParticlesToEmit;
//Floor float accumulated value and subtract whole int emitted so far from the result to determine total whole particles to emit this frame
int nParticlesToEmit = floor ( pCtx->m_flTotalActualParticlesSoFar ) - pCtx->m_nTotalEmittedSoFar;
//Add emitted particles to running int total.
pCtx->m_nTotalEmittedSoFar += nParticlesToEmit;
if ( nParticlesToEmit == 0 )
return 0;
// We're only allowed to emit so many particles, though..
// If we run out of room, only emit the last N particles
int nActualParticlesToEmit = nParticlesToEmit;
int nAllowedParticlesToEmit = pParticles->m_nMaxAllowedParticles - pParticles->m_nActiveParticles;
if ( nAllowedParticlesToEmit < nParticlesToEmit )
{
nActualParticlesToEmit = nAllowedParticlesToEmit;
//flStartEmissionTime = pCtx->m_flNextEmitTime - flTimePerEmission * nActualParticlesToEmit;
}
if ( nActualParticlesToEmit == 0 )
return 0;
int nStartParticle = pParticles->m_nActiveParticles;
pParticles->SetNActiveParticles( nActualParticlesToEmit + pParticles->m_nActiveParticles );
float flTimeStampStep = ( flCurrDrawTime - flPrevDrawTime ) / ( nActualParticlesToEmit );
float flTimeStep = flPrevDrawTime + flTimeStampStep;
// Set the particle creation time to the exact sub-frame particle emission time
// !! speed!! do sse init here
for( int i = nStartParticle; i < nStartParticle + nActualParticlesToEmit; i++ )
{
float *pTimeStamp = pParticles->GetFloatAttributePtrForWrite( PARTICLE_ATTRIBUTE_CREATION_TIME, i );
flTimeStep = min( flTimeStep, flCurrDrawTime );
*pTimeStamp = flTimeStep;
flTimeStep += flTimeStampStep;
}
return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
}
void AddBuiltInParticleEmitters( void )
{
REGISTER_PARTICLE_OPERATOR( FUNCTION_EMITTER, C_OP_ContinuousEmitter );
REGISTER_PARTICLE_OPERATOR( FUNCTION_EMITTER, C_OP_InstantaneousEmitter );
REGISTER_PARTICLE_OPERATOR( FUNCTION_EMITTER, C_OP_NoiseEmitter );
}