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.
 
 
 
 
 
 

533 lines
15 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "cbase.h"
#include "particles_simple.h"
#include "env_wind_shared.h"
#include "KeyValues.h"
#include "toolframework_client.h"
#include "toolframework/itoolframework.h"
#include "vstdlib/IKeyValuesSystem.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Used for debugging to make sure all particle effects get freed when we exit.
CUtlLinkedList<CParticleEffect*,int> g_ParticleEffects;
class CEffectChecker
{
public:
~CEffectChecker()
{
Assert( g_ParticleEffects.Count() == 0 );
}
} g_EffectChecker;
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CParticleEffect::CParticleEffect( const char *pName )
{
m_pDebugName = pName;
m_vSortOrigin.Init();
m_Flags = FLAG_ALLOCATED;
m_nToolParticleEffectId = TOOLPARTICLESYSTEMID_INVALID;
m_RefCount = 0;
m_bSimulate = true;
ParticleMgr()->AddEffect( &m_ParticleEffect, this );
#if defined( _DEBUG )
g_ParticleEffects.AddToTail( this );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CParticleEffect::~CParticleEffect( void )
{
#if defined( _DEBUG )
int index = g_ParticleEffects.Find( this );
Assert( g_ParticleEffects.IsValidIndex(index) );
g_ParticleEffects.Remove( index );
#endif
// HACKHACK: Prevent re-entering the destructor, clear m_Flags.
// For some reason we'll get a callback into NotifyRemove() after being deleted!
// Investigate dangling pointer
m_Flags = 0;
#if !defined( _XBOX )
if ( ( m_nToolParticleEffectId != TOOLPARTICLESYSTEMID_INVALID ) && clienttools->IsInRecordingMode() )
{
KeyValues *msg = new KeyValues( "OldParticleSystem_Destroy" );
msg->SetInt( "id", m_nToolParticleEffectId );
msg->SetFloat( "time", gpGlobals->curtime );
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
m_nToolParticleEffectId = TOOLPARTICLESYSTEMID_INVALID;
}
#endif
}
void CParticleEffect::SetDynamicallyAllocated( bool bDynamic )
{
if( bDynamic )
m_Flags |= FLAG_ALLOCATED;
else
m_Flags &= ~FLAG_ALLOCATED;
}
int CParticleEffect::IsReleased()
{
return m_RefCount == 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleEffect::AddRef()
{
++m_RefCount;
}
void CParticleEffect::Release()
{
Assert( m_RefCount > 0 );
--m_RefCount;
// If all the particles are already gone, delete ourselves now.
// If there are still particles, wait for the last NotifyDestroyParticle.
if ( m_RefCount == 0 )
{
if ( m_Flags & FLAG_ALLOCATED )
{
if ( m_ParticleEffect.GetNumActiveParticles() == 0 )
{
m_ParticleEffect.SetRemoveFlag();
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &vSortOrigin -
//-----------------------------------------------------------------------------
const Vector &CParticleEffect::GetSortOrigin()
{
Assert(m_vSortOrigin.IsValid());
return m_vSortOrigin;
}
const char *CParticleEffect::GetEffectName()
{
return m_pDebugName;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pParticle -
//-----------------------------------------------------------------------------
void CParticleEffect::NotifyDestroyParticle( Particle* pParticle )
{
// Go away if we're released and there are no more particles.
if( m_ParticleEffect.GetNumActiveParticles() == 0 && IsReleased() && (m_Flags & FLAG_ALLOCATED) && !(m_Flags & FLAG_DONT_REMOVE) )
{
m_ParticleEffect.SetRemoveFlag();
}
}
void CParticleEffect::Update( float flTimeDelta )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleEffect::NotifyRemove()
{
if( m_Flags & FLAG_ALLOCATED )
{
Assert( IsReleased() );
delete this;
}
}
void CParticleEffect::SetSortOrigin( const Vector &vSortOrigin )
{
if ( GetBinding().GetAutoUpdateBBox() )
{
if ( m_ParticleEffect.EnlargeBBoxToContain( vSortOrigin ) )
{
m_vSortOrigin = vSortOrigin;
}
}
else
{
// If not auto-updating bbox, don't change the bbox, just set the sort origin.
m_vSortOrigin = vSortOrigin;
}
}
void CParticleEffect::SetParticleCullRadius( float radius )
{
m_ParticleEffect.SetParticleCullRadius( radius );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
// Output : PMaterialHandle
//-----------------------------------------------------------------------------
PMaterialHandle CParticleEffect::GetPMaterial(const char *name)
{
return m_ParticleEffect.FindOrAddMaterial(name);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : particleSize -
// material -
// Output : SimpleParticle
//-----------------------------------------------------------------------------
Particle *CParticleEffect::AddParticle( unsigned int particleSize, PMaterialHandle material, const Vector &origin )
{
// If you get here, then you must call SetSortOrigin before adding particles.
Assert( m_vSortOrigin.IsValid() );
Particle *pParticle = (Particle *) m_ParticleEffect.AddParticle( particleSize, material );
if( pParticle == NULL )
return NULL;
pParticle->m_Pos = origin;
return pParticle;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
REGISTER_EFFECT_USING_CREATE( CSimpleEmitter );
CSimpleEmitter::CSimpleEmitter( const char *pDebugName ) : CParticleEffect( pDebugName )
{
m_flNearClipMin = 16.0f;
m_flNearClipMax = 64.0f;
}
CSimpleEmitter::~CSimpleEmitter()
{
}
CSmartPtr<CSimpleEmitter> CSimpleEmitter::Create( const char *pDebugName )
{
CSimpleEmitter *pRet = new CSimpleEmitter( pDebugName );
pRet->SetDynamicallyAllocated( true );
return pRet;
}
//-----------------------------------------------------------------------------
// Purpose: Set the internal near clip range for this particle system
// Input : nearClipMin - beginning of clip range
// nearClipMax - end of clip range
//-----------------------------------------------------------------------------
void CSimpleEmitter::SetNearClip( float nearClipMin, float nearClipMax )
{
m_flNearClipMin = nearClipMin;
m_flNearClipMax = nearClipMax;
}
SimpleParticle* CSimpleEmitter::AddSimpleParticle(
PMaterialHandle hMaterial,
const Vector &vOrigin,
float flDieTime,
unsigned char uchSize )
{
SimpleParticle *pRet = (SimpleParticle*)AddParticle( sizeof( SimpleParticle ), hMaterial, vOrigin );
if ( pRet )
{
pRet->m_Pos = vOrigin;
pRet->m_vecVelocity.Init();
pRet->m_flRoll = 0;
pRet->m_flRollDelta = 0;
pRet->m_flLifetime = 0;
pRet->m_flDieTime = flDieTime;
pRet->m_uchColor[0] = pRet->m_uchColor[1] = pRet->m_uchColor[2] = 0;
pRet->m_uchStartAlpha = pRet->m_uchEndAlpha = 255;
pRet->m_uchStartSize = pRet->m_uchEndSize = uchSize;
pRet->m_iFlags = 0;
}
return pRet;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fTimeDelta -
// Output : float
//-----------------------------------------------------------------------------
float CSimpleEmitter::UpdateAlpha( const SimpleParticle *pParticle )
{
return (pParticle->m_uchStartAlpha/255.0f) + ( (float)(pParticle->m_uchEndAlpha/255.0f) - (float)(pParticle->m_uchStartAlpha/255.0f) ) * (pParticle->m_flLifetime / pParticle->m_flDieTime);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fTimeDelta -
// Output : float
//-----------------------------------------------------------------------------
float CSimpleEmitter::UpdateScale( const SimpleParticle *pParticle )
{
return (float)pParticle->m_uchStartSize + ( (float)pParticle->m_uchEndSize - (float)pParticle->m_uchStartSize ) * (pParticle->m_flLifetime / pParticle->m_flDieTime);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fTimeDelta -
// Output : Vector
//-----------------------------------------------------------------------------
#define WIND_ACCEL 50
void CSimpleEmitter::UpdateVelocity( SimpleParticle *pParticle, float timeDelta )
{
if (pParticle->m_iFlags & SIMPLE_PARTICLE_FLAG_WINDBLOWN)
{
Vector vecWind;
GetWindspeedAtTime( gpGlobals->curtime, vecWind );
for ( int i = 0 ; i < 2 ; i++ )
{
if ( pParticle->m_vecVelocity[i] < vecWind[i] )
{
pParticle->m_vecVelocity[i] += ( timeDelta * WIND_ACCEL );
// clamp
if ( pParticle->m_vecVelocity[i] > vecWind[i] )
pParticle->m_vecVelocity[i] = vecWind[i];
}
else if (pParticle->m_vecVelocity[i] > vecWind[i] )
{
pParticle->m_vecVelocity[i] -= ( timeDelta * WIND_ACCEL );
// clamp.
if ( pParticle->m_vecVelocity[i] < vecWind[i] )
pParticle->m_vecVelocity[i] = vecWind[i];
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fTimeDelta -
// Output : float
//-----------------------------------------------------------------------------
float CSimpleEmitter::UpdateRoll( SimpleParticle *pParticle, float timeDelta )
{
pParticle->m_flRoll += pParticle->m_flRollDelta * timeDelta;
return pParticle->m_flRoll;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pParticle -
// timeDelta -
//-----------------------------------------------------------------------------
Vector CSimpleEmitter::UpdateColor( const SimpleParticle *pParticle )
{
static Vector cColor;
cColor[0] = pParticle->m_uchColor[0] / 255.0f;
cColor[1] = pParticle->m_uchColor[1] / 255.0f;
cColor[2] = pParticle->m_uchColor[2] / 255.0f;
return cColor;
}
void CSimpleEmitter::SimulateParticles( CParticleSimulateIterator *pIterator )
{
float timeDelta = pIterator->GetTimeDelta();
SimpleParticle *pParticle = (SimpleParticle*)pIterator->GetFirst();
while ( pParticle )
{
//Update velocity
UpdateVelocity( pParticle, timeDelta );
pParticle->m_Pos += pParticle->m_vecVelocity * timeDelta;
//Should this particle die?
pParticle->m_flLifetime += timeDelta;
UpdateRoll( pParticle, timeDelta );
if ( pParticle->m_flLifetime >= pParticle->m_flDieTime )
pIterator->RemoveParticle( pParticle );
pParticle = (SimpleParticle*)pIterator->GetNext();
}
}
void CSimpleEmitter::RenderParticles( CParticleRenderIterator *pIterator )
{
const SimpleParticle *pParticle = (const SimpleParticle *)pIterator->GetFirst();
while ( pParticle )
{
//Render
Vector tPos;
TransformParticle( ParticleMgr()->GetModelView(), pParticle->m_Pos, tPos );
float sortKey = (int) tPos.z;
//Render it
RenderParticle_ColorSizeAngle(
pIterator->GetParticleDraw(),
tPos,
UpdateColor( pParticle ),
UpdateAlpha( pParticle ) * GetAlphaDistanceFade( tPos, m_flNearClipMin, m_flNearClipMax ),
UpdateScale( pParticle ),
pParticle->m_flRoll
);
pParticle = (const SimpleParticle *)pIterator->GetNext( sortKey );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : state -
//-----------------------------------------------------------------------------
void CSimpleEmitter::SetDrawBeforeViewModel( bool state )
{
m_ParticleEffect.SetDrawBeforeViewModel( state );
}
//==================================================
// Particle Library
//==================================================
CEmberEffect::CEmberEffect( const char *pDebugName ) : CSimpleEmitter( pDebugName )
{
}
CSmartPtr<CEmberEffect> CEmberEffect::Create( const char *pDebugName )
{
CEmberEffect *pRet = new CEmberEffect( pDebugName );
pRet->SetDynamicallyAllocated( true );
return pRet;
}
void CEmberEffect::UpdateVelocity( SimpleParticle *pParticle, float timeDelta )
{
float speed = VectorNormalize( pParticle->m_vecVelocity );
Vector offset;
speed -= ( 12.0f * timeDelta );
offset.Random( -0.125f, 0.125f );
pParticle->m_vecVelocity += offset;
VectorNormalize( pParticle->m_vecVelocity );
pParticle->m_vecVelocity *= speed;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pParticle -
// timeDelta -
//-----------------------------------------------------------------------------
Vector CEmberEffect::UpdateColor( const SimpleParticle *pParticle )
{
Vector color;
float ramp = 1.0f - ( pParticle->m_flLifetime / pParticle->m_flDieTime );
color[0] = ( (float) pParticle->m_uchColor[0] * ramp ) / 255.0f;
color[1] = ( (float) pParticle->m_uchColor[1] * ramp ) / 255.0f;
color[2] = ( (float) pParticle->m_uchColor[2] * ramp ) / 255.0f;
return color;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pParticle -
// timeDelta -
// Output : float
//-----------------------------------------------------------------------------
CFireSmokeEffect::CFireSmokeEffect( const char *pDebugName ) : CSimpleEmitter( pDebugName )
{
}
CSmartPtr<CFireSmokeEffect> CFireSmokeEffect::Create( const char *pDebugName )
{
CFireSmokeEffect *pRet = new CFireSmokeEffect( pDebugName );
pRet->SetDynamicallyAllocated( true );
return pRet;
}
float CFireSmokeEffect::UpdateAlpha( const SimpleParticle *pParticle )
{
return ( ((float)pParticle->m_uchStartAlpha/255.0f) * sin( M_PI * (pParticle->m_flLifetime / pParticle->m_flDieTime) ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pParticle -
// timeDelta -
//-----------------------------------------------------------------------------
void CFireSmokeEffect::UpdateVelocity( SimpleParticle *pParticle, float timeDelta )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pParticle -
// timeDelta -
// Output : Vector
//-----------------------------------------------------------------------------
CFireParticle::CFireParticle( const char *pDebugName ) : CSimpleEmitter( pDebugName )
{
}
CSmartPtr<CFireParticle> CFireParticle::Create( const char *pDebugName )
{
CFireParticle *pRet = new CFireParticle( pDebugName );
pRet->SetDynamicallyAllocated( true );
return pRet;
}
Vector CFireParticle::UpdateColor( const SimpleParticle *pParticle )
{
for ( int i = 0; i < 3; i++ )
{
//FIXME: This is frame dependant... but I don't want to store off start/end colors yet
//pParticle->m_uchColor[i] = MAX( 0, pParticle->m_uchColor[i]-2 );
}
return CSimpleEmitter::UpdateColor( pParticle );
}