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.
 
 
 
 
 
 

691 lines
23 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "particle_property.h"
#include "utlvector.h"
#ifdef CLIENT_DLL
#include "c_baseentity.h"
#include "c_baseanimating.h"
#include "recvproxy.h"
#include "particles_new.h"
#include "engine/ivdebugoverlay.h"
#include "bone_setup.h"
#else
#include "baseentity.h"
#include "baseanimating.h"
#include "sendproxy.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#ifdef STAGING_ONLY
#ifdef TF_CLIENT_DLL
extern ConVar tf_unusual_effect_offset;
#endif
#endif
//-----------------------------------------------------------------------------
// Save/load
//-----------------------------------------------------------------------------
BEGIN_DATADESC_NO_BASE( CParticleProperty )
// DEFINE_FIELD( m_pOuter, FIELD_CLASSPTR ),
END_DATADESC()
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Prediction
//-----------------------------------------------------------------------------
BEGIN_PREDICTION_DATA_NO_BASE( CParticleProperty )
//DEFINE_PRED_FIELD( m_vecMins, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
END_PREDICTION_DATA()
#endif
//-----------------------------------------------------------------------------
// Networking
//-----------------------------------------------------------------------------
BEGIN_NETWORK_TABLE_NOBASE( CParticleProperty, DT_ParticleProperty )
#ifdef CLIENT_DLL
//RecvPropVector( RECVINFO(m_vecMins), 0, RecvProxy_OBBMins ),
#else
//SendPropVector( SENDINFO(m_vecMins), 0, SPROP_NOSCALE),
#endif
END_NETWORK_TABLE()
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CParticleProperty::CParticleProperty()
{
Init( NULL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CParticleProperty::~CParticleProperty()
{
// We're being removed. Call StopEmission() on any particle system
// that has an unlimited number of particles to emit.
StopEmission( NULL, false, true );
}
//-----------------------------------------------------------------------------
// Initialization
//-----------------------------------------------------------------------------
void CParticleProperty::Init( CBaseEntity *pEntity )
{
m_pOuter = pEntity;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CParticleProperty::GetParticleAttachment( C_BaseEntity *pEntity, const char *pszAttachmentName, const char *pszParticleName )
{
Assert( pEntity && pEntity->GetBaseAnimating() );
if ( !pEntity || !pEntity->GetBaseAnimating() )
return INVALID_PARTICLE_ATTACHMENT;
// Find the attachment point index
int iAttachment = pEntity->GetBaseAnimating()->LookupAttachment( pszAttachmentName );
if ( iAttachment == INVALID_PARTICLE_ATTACHMENT )
{
Warning("Model '%s' doesn't have attachment '%s' to attach particle system '%s' to.\n", STRING(pEntity->GetBaseAnimating()->GetModelName()), pszAttachmentName, pszParticleName );
}
return iAttachment;
}
//-----------------------------------------------------------------------------
// Purpose: Create a new particle system and attach it to our owner
//-----------------------------------------------------------------------------
CNewParticleEffect *CParticleProperty::Create( const char *pszParticleName, ParticleAttachment_t iAttachType, const char *pszAttachmentName )
{
int iAttachment = GetParticleAttachment( GetOuter(), pszAttachmentName, pszParticleName );
if ( iAttachment == INVALID_PARTICLE_ATTACHMENT )
return NULL;
// Create the system
return Create( pszParticleName, iAttachType, iAttachment );
}
//-----------------------------------------------------------------------------
// Purpose: Create a new particle system and attach it to our owner
//-----------------------------------------------------------------------------
static ConVar cl_particle_batch_mode( "cl_particle_batch_mode", "1" );
CNewParticleEffect *CParticleProperty::Create( const char *pszParticleName, ParticleAttachment_t iAttachType, int iAttachmentPoint, Vector vecOriginOffset )
{
if ( GameRules() )
{
pszParticleName = GameRules()->TranslateEffectForVisionFilter( "particles", pszParticleName );
}
int nBatchMode = cl_particle_batch_mode.GetInt();
CParticleSystemDefinition *pDef = g_pParticleSystemMgr->FindParticleSystem( pszParticleName );
bool bRequestedBatch = ( nBatchMode == 2 ) || ( ( nBatchMode == 1 ) && pDef && pDef->ShouldBatch() );
if ( ( iAttachType == PATTACH_CUSTOMORIGIN ) && bRequestedBatch )
{
int iIndex = FindEffect( pszParticleName );
if ( iIndex >= 0 )
{
CNewParticleEffect *pEffect = m_ParticleEffects[iIndex].pParticleEffect.GetObject();
pEffect->Restart();
return pEffect;
}
}
if ( !pDef )
{
AssertMsg( 0, "Attempting to create unknown particle system" );
Warning( "Attempting to create unknown particle system '%s' \n", pszParticleName );
return NULL;
}
int iIndex = m_ParticleEffects.AddToTail();
ParticleEffectList_t *newEffect = &m_ParticleEffects[iIndex];
newEffect->pParticleEffect = CNewParticleEffect::Create( m_pOuter, pDef );
if ( !newEffect->pParticleEffect->IsValid() )
{
// Caused by trying to spawn an unregistered particle effect. Remove it.
ParticleMgr()->RemoveEffect( newEffect->pParticleEffect.GetObject() );
return NULL;
}
AddControlPoint( iIndex, 0, GetOuter(), iAttachType, iAttachmentPoint, vecOriginOffset );
if ( m_pOuter )
{
m_pOuter->OnNewParticleEffect( pszParticleName, newEffect->pParticleEffect.GetObject() );
}
return newEffect->pParticleEffect.GetObject();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::AddControlPoint( CNewParticleEffect *pEffect, int iPoint, C_BaseEntity *pEntity, ParticleAttachment_t iAttachType, const char *pszAttachmentName, Vector vecOriginOffset )
{
int iAttachment = INVALID_PARTICLE_ATTACHMENT;
if ( pszAttachmentName )
{
iAttachment = GetParticleAttachment( pEntity, pszAttachmentName, pEffect->GetEffectName() );
}
for ( int i = 0; i < m_ParticleEffects.Count(); i++ )
{
if ( m_ParticleEffects[i].pParticleEffect == pEffect )
{
AddControlPoint( i, iPoint, pEntity, iAttachType, iAttachment, vecOriginOffset );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::AddControlPoint( int iEffectIndex, int iPoint, C_BaseEntity *pEntity, ParticleAttachment_t iAttachType, int iAttachmentPoint, Vector vecOriginOffset )
{
Assert( iEffectIndex >= 0 && iEffectIndex < m_ParticleEffects.Count() );
ParticleEffectList_t *pEffect = &m_ParticleEffects[iEffectIndex];
Assert( pEffect->pControlPoints.Count() < MAX_PARTICLE_CONTROL_POINTS );
// If the control point is already used, override it
ParticleControlPoint_t *pNewPoint = NULL;
int iIndex = iPoint;
FOR_EACH_VEC( pEffect->pControlPoints, i )
{
if ( pEffect->pControlPoints[i].iControlPoint == iPoint )
{
pNewPoint = &pEffect->pControlPoints[i];
}
}
if ( !pNewPoint )
{
iIndex = pEffect->pControlPoints.AddToTail();
pNewPoint = &pEffect->pControlPoints[iIndex];
}
pNewPoint->iControlPoint = iPoint;
pNewPoint->hEntity = pEntity;
pNewPoint->iAttachType = iAttachType;
pNewPoint->iAttachmentPoint = iAttachmentPoint;
pNewPoint->vecOriginOffset = vecOriginOffset;
UpdateParticleEffect( pEffect, true, iIndex );
}
//-----------------------------------------------------------------------------
// Used to replace a particle effect with a different one; attaches the control point updating to the new one
//-----------------------------------------------------------------------------
void CParticleProperty::ReplaceParticleEffect( CNewParticleEffect *pOldEffect, CNewParticleEffect *pNewEffect )
{
int nCount = m_ParticleEffects.Count();
for ( int i = 0; i < nCount; ++i )
{
if ( pOldEffect != m_ParticleEffects[i].pParticleEffect.GetObject() )
continue;
m_ParticleEffects[i].pParticleEffect = pNewEffect;
UpdateParticleEffect( &m_ParticleEffects[i], true );
}
}
//-----------------------------------------------------------------------------
// Purpose: Set the parent of a given control point to the index of some other
// control point.
//-----------------------------------------------------------------------------
void CParticleProperty::SetControlPointParent( int iEffectIndex, int whichControlPoint, int parentIdx )
{
}
//-----------------------------------------------------------------------------
// Purpose: Stop effects from emitting more particles. If no effect is
// specified, all effects attached to this entity are stopped.
//-----------------------------------------------------------------------------
void CParticleProperty::StopEmission( CNewParticleEffect *pEffect, bool bWakeOnStop, bool bDestroyAsleepSystems )
{
// If we return from dormancy and are then told to stop emitting,
// we should have died while dormant. Remove ourselves immediately.
bool bRemoveInstantly = (m_iDormancyChangedAtFrame == gpGlobals->framecount);
if ( pEffect )
{
if ( FindEffect( pEffect ) != -1 )
{
pEffect->StopEmission( false, bRemoveInstantly, bWakeOnStop );
}
}
else
{
// Stop all effects
float flNow = g_pParticleSystemMgr->GetLastSimulationTime();
int nCount = m_ParticleEffects.Count();
for ( int i = nCount-1; i >= 0; i-- )
{
CNewParticleEffect *pTmp = m_ParticleEffects[i].pParticleEffect.GetObject();
bool bRemoveSystem = bRemoveInstantly || ( bDestroyAsleepSystems && ( flNow >= pTmp->m_flNextSleepTime ) );
if ( bRemoveSystem )
{
m_ParticleEffects.Remove( i );
pTmp->SetOwner( NULL );
}
pTmp->StopEmission( false, bRemoveSystem, !bRemoveSystem && bWakeOnStop );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Remove effects immediately, including all current particles. If no
// effect is specified, all effects attached to this entity are removed.
//-----------------------------------------------------------------------------
void CParticleProperty::StopEmissionAndDestroyImmediately( CNewParticleEffect *pEffect )
{
if ( pEffect )
{
int iIndex = FindEffect( pEffect );
//Assert( iIndex != -1 );
if ( iIndex != -1 )
{
m_ParticleEffects.Remove( iIndex );
// Clear the owner so it doesn't try to call back to us on deletion
pEffect->SetOwner( NULL );
pEffect->StopEmission( false, true );
}
}
else
{
// Immediately destroy all effects
int nCount = m_ParticleEffects.Count();
for ( int i = nCount-1; i >= 0; i-- )
{
CNewParticleEffect *pTmp = m_ParticleEffects[i].pParticleEffect.GetObject();
m_ParticleEffects.Remove( i );
// Clear the owner so it doesn't try to call back to us on deletion
pTmp->SetOwner( NULL );
pTmp->StopEmission( false, true );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Stop all effects that have a control point associated with the given
// entity.
//-----------------------------------------------------------------------------
void CParticleProperty::StopParticlesInvolving( CBaseEntity *pEntity )
{
Assert( pEntity );
EHANDLE entHandle(pEntity);
// If we return from dormancy and are then told to stop emitting,
// we should have died while dormant. Remove ourselves immediately.
bool bRemoveInstantly = (m_iDormancyChangedAtFrame == gpGlobals->framecount);
int nCount = m_ParticleEffects.Count();
for ( int i = 0; i < nCount; ++i )
{
// for each effect...
ParticleEffectList_t &part = m_ParticleEffects[i];
// look through all the control points to see if any mention the given object
int cpCount = part.pControlPoints.Count();
for (int j = 0; j < cpCount ; ++j )
{
// if any control points respond to the given handle...
if (part.pControlPoints[j].hEntity == entHandle)
{
part.pParticleEffect->StopEmission( false, bRemoveInstantly );
part.pControlPoints.Remove( j );
break; // break out of the inner loop (to where it says BREAK TO HERE)
}
}
// BREAK TO HERE
}
}
//g_pParticleSystemMgr->FindParticleSystem( pParticleSystemName );
//-----------------------------------------------------------------------------
// Purpose: Stop all effects that were created using the given definition
// name.
//-----------------------------------------------------------------------------
void CParticleProperty::StopParticlesNamed( const char *pszEffectName, bool bForceRemoveInstantly /* =false */ )
{
CParticleSystemDefinition *pDef = g_pParticleSystemMgr->FindParticleSystem( pszEffectName );
AssertMsg1(pDef, "Could not find particle definition %s", pszEffectName );
if (!pDef)
return;
// If we return from dormancy and are then told to stop emitting,
// we should have died while dormant. Remove ourselves immediately.
bool bRemoveInstantly = (m_iDormancyChangedAtFrame == gpGlobals->framecount);
// force remove particles instantly if caller specified
bRemoveInstantly |= bForceRemoveInstantly;
int nCount = m_ParticleEffects.Count();
for ( int i = 0; i < nCount; ++i )
{
// for each effect...
CNewParticleEffect *pParticleEffect = m_ParticleEffects[i].pParticleEffect.GetObject();
if (pParticleEffect->m_pDef() == pDef)
{
pParticleEffect->StopEmission( false, bRemoveInstantly );
}
}
}
void CParticleProperty::StopParticlesWithNameAndAttachment( const char *pszEffectName, int iAttachmentPoint, bool bForceRemoveInstantly /* =false */ )
{
CParticleSystemDefinition *pDef = g_pParticleSystemMgr->FindParticleSystem( pszEffectName );
AssertMsg1(pDef, "Could not find particle definition %s", pszEffectName );
if (!pDef)
return;
// If we return from dormancy and are then told to stop emitting,
// we should have died while dormant. Remove ourselves immediately.
bool bRemoveInstantly = (m_iDormancyChangedAtFrame == gpGlobals->framecount);
// force remove particles instantly if caller specified
bRemoveInstantly |= bForceRemoveInstantly;
int nCount = m_ParticleEffects.Count();
for ( int i = 0; i < nCount; ++i )
{
// for each effect...
ParticleEffectList_t *pParticleEffectList = &m_ParticleEffects[i];
CNewParticleEffect *pParticleEffect = pParticleEffectList->pParticleEffect.GetObject();
if (pParticleEffect->m_pDef() == pDef)
{
int nControlPointCount = pParticleEffectList->pControlPoints.Count();
for ( int j = 0; j < nControlPointCount; ++j )
{
if ( pParticleEffectList->pControlPoints[j].iAttachmentPoint == iAttachmentPoint )
{
pParticleEffect->StopEmission( false, bRemoveInstantly );
break;
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::OnParticleSystemUpdated( CNewParticleEffect *pEffect, float flTimeDelta )
{
int iIndex = FindEffect( pEffect );
Assert( iIndex != -1 );
if ( iIndex == -1 )
return;
// Enable FP exceptions here when FP_EXCEPTIONS_ENABLED is defined,
// to help track down bad math.
FPExceptionEnabler enableExceptions;
UpdateParticleEffect( &m_ParticleEffects[iIndex] );
/*
// Display the bounding box of the particle effect
Vector vecMins, vecMaxs;
pEffect->GetRenderBounds( vecMins, vecMaxs );
debugoverlay->AddBoxOverlay( pEffect->GetRenderOrigin(), vecMins, vecMaxs, QAngle( 0, 0, 0 ), 0, 255, 255, 0, 0 );
*/
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::OnParticleSystemDeleted( CNewParticleEffect *pEffect )
{
int iIndex = FindEffect( pEffect );
if ( iIndex == -1 )
return;
m_ParticleEffects[iIndex].pParticleEffect.MarkDeleted();
m_ParticleEffects.Remove( iIndex );
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: The entity we're attached to has change dormancy state on our client
//-----------------------------------------------------------------------------
void CParticleProperty::OwnerSetDormantTo( bool bDormant )
{
m_iDormancyChangedAtFrame = gpGlobals->framecount;
int nCount = m_ParticleEffects.Count();
for ( int i = 0; i < nCount; i++ )
{
//m_ParticleEffects[i].pParticleEffect->SetShouldSimulate( !bDormant );
m_ParticleEffects[i].pParticleEffect->SetDormant( bDormant );
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CParticleProperty::FindEffect( CNewParticleEffect *pEffect )
{
for ( int i = 0; i < m_ParticleEffects.Count(); i++ )
{
if ( m_ParticleEffects[i].pParticleEffect == pEffect )
return i;
}
return -1;
}
int CParticleProperty::FindEffect( const char *pEffectName, int nStart /*= 0*/ )
{
for ( int i = nStart; i < m_ParticleEffects.Count(); i++ )
{
if ( !Q_stricmp( m_ParticleEffects[i].pParticleEffect->GetName(), pEffectName ) )
return i;
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::UpdateParticleEffect( ParticleEffectList_t *pEffect, bool bInitializing, int iOnlyThisControlPoint )
{
if ( iOnlyThisControlPoint != -1 )
{
UpdateControlPoint( pEffect, iOnlyThisControlPoint, bInitializing );
return;
}
// Loop through our control points and update them all
for ( int i = 0; i < pEffect->pControlPoints.Count(); i++ )
{
UpdateControlPoint( pEffect, i, bInitializing );
}
}
extern void FormatViewModelAttachment( Vector &vOrigin, bool bInverse );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::UpdateControlPoint( ParticleEffectList_t *pEffect, int iPoint, bool bInitializing )
{
ParticleControlPoint_t *pPoint = &pEffect->pControlPoints[iPoint];
if ( !pPoint->hEntity.Get() )
{
if ( pPoint->iAttachType == PATTACH_WORLDORIGIN && bInitializing )
{
pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, Vector(1,0,0), Vector(0,1,0), Vector(0,0,1) );
pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, pPoint->vecOriginOffset );
pEffect->pParticleEffect->SetSortOrigin( pPoint->vecOriginOffset );
}
pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, NULL );
return;
}
// Only update non-follow particles when we're initializing,
// unless we're parented to something, in which case we should always update
if ( !bInitializing && !pPoint->hEntity->GetMoveParent() && (pPoint->iAttachType == PATTACH_ABSORIGIN || pPoint->iAttachType == PATTACH_POINT ) )
return;
if ( pPoint->iAttachType == PATTACH_CUSTOMORIGIN )
return;
Vector vecOrigin, vecForward, vecRight, vecUp;
float flOffset = 0.0f;
bool bUsingHeadOrigin = false;
#ifdef TF_CLIENT_DLL
CBaseEntity *pWearable = (CBaseEntity*) pPoint->hEntity.Get();
if ( pWearable && dynamic_cast<IHasAttributes*>( pWearable ) && !pWearable->IsPlayer() )
{
C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating();
if ( pAnimating )
{
int bUseHeadOrigin = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAnimating, bUseHeadOrigin, particle_effect_use_head_origin );
if ( bUseHeadOrigin > 0 )
{
int iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "bip_head" );
if ( iBone < 0 )
{
iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "prp_helmet" );
if ( iBone < 0 )
{
iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "prp_hat" );
}
}
if ( iBone < 0 )
{
iBone = 0;
}
bUsingHeadOrigin = true;
const matrix3x4_t headBone = pAnimating->GetBone( iBone );
MatrixVectors( headBone, &vecForward, &vecRight, &vecUp );
MatrixPosition( headBone, vecOrigin );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pAnimating, flOffset, particle_effect_vertical_offset );
}
}
}
#endif
if ( !bUsingHeadOrigin )
{
switch ( pPoint->iAttachType )
{
case PATTACH_POINT:
case PATTACH_POINT_FOLLOW:
{
C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating();
Assert( pAnimating );
if ( pAnimating )
{
matrix3x4_t attachmentToWorld;
if ( !pAnimating->GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) )
{
// try C_BaseAnimating if attach point is not on the weapon
if ( !pAnimating->C_BaseAnimating::GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) )
{
Warning( "Cannot update control point %d for effect '%s'.\n", pPoint->iAttachmentPoint, pEffect->pParticleEffect->GetEffectName() );
attachmentToWorld = pAnimating->RenderableToWorldTransform();
}
}
VMatrix vMat(attachmentToWorld);
MatrixTranslate( vMat, pPoint->vecOriginOffset );
MatrixVectors( vMat.As3x4(), &vecForward, &vecRight, &vecUp );
MatrixPosition( vMat.As3x4(), vecOrigin );
if ( pEffect->pParticleEffect->m_pDef->IsViewModelEffect() )
{
FormatViewModelAttachment( vecOrigin, true );
}
}
}
break;
case PATTACH_ABSORIGIN:
case PATTACH_ABSORIGIN_FOLLOW:
default:
{
vecOrigin = pPoint->hEntity->GetAbsOrigin() + pPoint->vecOriginOffset;
pPoint->hEntity->GetVectors( &vecForward, &vecRight, &vecUp );
}
break;
case PATTACH_ROOTBONE_FOLLOW:
{
C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating();
Assert( pAnimating );
if ( pAnimating )
{
matrix3x4_t rootBone;
if ( pAnimating->GetRootBone( rootBone ) )
{
MatrixVectors( rootBone, &vecForward, &vecRight, &vecUp );
MatrixPosition( rootBone, vecOrigin );
}
}
}
break;
}
}
Vector vecForcedOriginOffset( 0, 0, flOffset );
pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, vecForward, vecRight, vecUp );
pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, pPoint->hEntity );
pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, vecOrigin + vecForcedOriginOffset );
pEffect->pParticleEffect->SetSortOrigin( vecOrigin + vecForcedOriginOffset);
}
//-----------------------------------------------------------------------------
// Purpose: Output all active effects
//-----------------------------------------------------------------------------
void CParticleProperty::DebugPrintEffects( void )
{
int nCount = m_ParticleEffects.Count();
for ( int i = 0; i < nCount; ++i )
{
// for each effect...
CNewParticleEffect *pParticleEffect = m_ParticleEffects[i].pParticleEffect.GetObject();
if ( !pParticleEffect )
continue;
Msg( "(%d) EffectName \"%s\" Dormant? %s Emission Stopped? %s \n",
i,
pParticleEffect->GetEffectName(),
( pParticleEffect->m_bDormant ) ? "yes" : "no",
( pParticleEffect->m_bEmissionStopped ) ? "yes" : "no" );
}
}