2011 lines
60 KiB
C++
2011 lines
60 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
#include "cbase.h"
|
|
#include "c_smoke_trail.h"
|
|
#include "fx.h"
|
|
#include "engine/ivdebugoverlay.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "c_te_effect_dispatch.h"
|
|
#include "glow_overlay.h"
|
|
#include "fx_explosion.h"
|
|
#include "tier1/KeyValues.h"
|
|
#include "toolframework_client.h"
|
|
#include "view.h"
|
|
#include "clienteffectprecachesystem.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//
|
|
// CRocketTrailParticle
|
|
//
|
|
|
|
class CRocketTrailParticle : public CSimpleEmitter
|
|
{
|
|
public:
|
|
|
|
CRocketTrailParticle( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}
|
|
|
|
//Create
|
|
static CRocketTrailParticle *Create( const char *pDebugName )
|
|
{
|
|
return new CRocketTrailParticle( pDebugName );
|
|
}
|
|
|
|
//Roll
|
|
virtual float UpdateRoll( SimpleParticle *pParticle, float timeDelta )
|
|
{
|
|
pParticle->m_flRoll += pParticle->m_flRollDelta * timeDelta;
|
|
|
|
pParticle->m_flRollDelta += pParticle->m_flRollDelta * ( timeDelta * -8.0f );
|
|
|
|
//Cap the minimum roll
|
|
if ( fabs( pParticle->m_flRollDelta ) < 0.5f )
|
|
{
|
|
pParticle->m_flRollDelta = ( pParticle->m_flRollDelta > 0.0f ) ? 0.5f : -0.5f;
|
|
}
|
|
|
|
return pParticle->m_flRoll;
|
|
}
|
|
|
|
//Alpha
|
|
virtual float UpdateAlpha( const SimpleParticle *pParticle )
|
|
{
|
|
return ( ((float)pParticle->m_uchStartAlpha/255.0f) * sin( M_PI * (pParticle->m_flLifetime / pParticle->m_flDieTime) ) );
|
|
}
|
|
|
|
private:
|
|
CRocketTrailParticle( const CRocketTrailParticle & );
|
|
};
|
|
|
|
//
|
|
// CSmokeParticle
|
|
//
|
|
|
|
class CSmokeParticle : public CSimpleEmitter
|
|
{
|
|
public:
|
|
|
|
CSmokeParticle( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}
|
|
|
|
//Create
|
|
static CSmokeParticle *Create( const char *pDebugName )
|
|
{
|
|
return new CSmokeParticle( pDebugName );
|
|
}
|
|
|
|
//Alpha
|
|
virtual float UpdateAlpha( const SimpleParticle *pParticle )
|
|
{
|
|
return ( ((float)pParticle->m_uchStartAlpha/255.0f) * sin( M_PI * (pParticle->m_flLifetime / pParticle->m_flDieTime) ) );
|
|
}
|
|
|
|
//Color
|
|
virtual Vector UpdateColor( const SimpleParticle *pParticle )
|
|
{
|
|
Vector color;
|
|
|
|
float tLifetime = pParticle->m_flLifetime / pParticle->m_flDieTime;
|
|
float ramp = 1.0f - tLifetime;
|
|
|
|
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;
|
|
}
|
|
|
|
//Roll
|
|
virtual float UpdateRoll( SimpleParticle *pParticle, float timeDelta )
|
|
{
|
|
pParticle->m_flRoll += pParticle->m_flRollDelta * timeDelta;
|
|
|
|
pParticle->m_flRollDelta += pParticle->m_flRollDelta * ( timeDelta * -8.0f );
|
|
|
|
//Cap the minimum roll
|
|
if ( fabs( pParticle->m_flRollDelta ) < 0.5f )
|
|
{
|
|
pParticle->m_flRollDelta = ( pParticle->m_flRollDelta > 0.0f ) ? 0.5f : -0.5f;
|
|
}
|
|
|
|
return pParticle->m_flRoll;
|
|
}
|
|
|
|
private:
|
|
CSmokeParticle( const CSmokeParticle & );
|
|
};
|
|
|
|
// Datatable.. this can have all the smoketrail parameters when we need it to.
|
|
IMPLEMENT_CLIENTCLASS_DT(C_SmokeTrail, DT_SmokeTrail, SmokeTrail)
|
|
RecvPropFloat(RECVINFO(m_SpawnRate)),
|
|
RecvPropVector(RECVINFO(m_StartColor)),
|
|
RecvPropVector(RECVINFO(m_EndColor)),
|
|
RecvPropFloat(RECVINFO(m_ParticleLifetime)),
|
|
RecvPropFloat(RECVINFO(m_StopEmitTime)),
|
|
RecvPropFloat(RECVINFO(m_MinSpeed)),
|
|
RecvPropFloat(RECVINFO(m_MaxSpeed)),
|
|
RecvPropFloat(RECVINFO(m_MinDirectedSpeed)),
|
|
RecvPropFloat(RECVINFO(m_MaxDirectedSpeed)),
|
|
RecvPropFloat(RECVINFO(m_StartSize)),
|
|
RecvPropFloat(RECVINFO(m_EndSize)),
|
|
RecvPropFloat(RECVINFO(m_SpawnRadius)),
|
|
RecvPropInt(RECVINFO(m_bEmit)),
|
|
RecvPropInt(RECVINFO(m_nAttachment)),
|
|
RecvPropFloat(RECVINFO(m_Opacity)),
|
|
END_RECV_TABLE()
|
|
|
|
// ------------------------------------------------------------------------- //
|
|
// ParticleMovieExplosion
|
|
// ------------------------------------------------------------------------- //
|
|
C_SmokeTrail::C_SmokeTrail()
|
|
{
|
|
m_MaterialHandle[0] = NULL;
|
|
m_MaterialHandle[1] = NULL;
|
|
|
|
m_SpawnRate = 10;
|
|
m_ParticleSpawn.Init(10);
|
|
m_StartColor.Init(0.5, 0.5, 0.5);
|
|
m_EndColor.Init(0,0,0);
|
|
m_ParticleLifetime = 5;
|
|
m_StopEmitTime = 0; // No end time
|
|
m_MinSpeed = 2;
|
|
m_MaxSpeed = 4;
|
|
m_MinDirectedSpeed = m_MaxDirectedSpeed = 0;
|
|
m_StartSize = 35;
|
|
m_EndSize = 55;
|
|
m_SpawnRadius = 2;
|
|
m_VelocityOffset.Init();
|
|
m_Opacity = 0.5f;
|
|
|
|
m_bEmit = true;
|
|
|
|
m_nAttachment = -1;
|
|
|
|
m_pSmokeEmitter = NULL;
|
|
m_pParticleMgr = NULL;
|
|
}
|
|
|
|
C_SmokeTrail::~C_SmokeTrail()
|
|
{
|
|
if ( ToolsEnabled() && clienttools->IsInRecordingMode() && m_pSmokeEmitter.IsValid() && m_pSmokeEmitter->GetToolParticleEffectId() != TOOLPARTICLESYSTEMID_INVALID )
|
|
{
|
|
KeyValues *msg = new KeyValues( "OldParticleSystem_ActivateEmitter" );
|
|
msg->SetInt( "id", m_pSmokeEmitter->GetToolParticleEffectId() );
|
|
msg->SetInt( "emitter", 0 );
|
|
msg->SetInt( "active", false );
|
|
msg->SetFloat( "time", gpGlobals->curtime );
|
|
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
|
|
msg->deleteThis();
|
|
}
|
|
|
|
if ( m_pParticleMgr )
|
|
{
|
|
m_pParticleMgr->RemoveEffect( &m_ParticleEffect );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void C_SmokeTrail::GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pAbsOrigin, QAngle *pAbsAngles )
|
|
{
|
|
C_BaseEntity *pEnt = pAttachedTo->GetBaseEntity();
|
|
if (pEnt && (m_nAttachment > 0))
|
|
{
|
|
pEnt->GetAttachment( m_nAttachment, *pAbsOrigin, *pAbsAngles );
|
|
}
|
|
else
|
|
{
|
|
BaseClass::GetAimEntOrigin( pAttachedTo, pAbsOrigin, pAbsAngles );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bEmit -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SmokeTrail::SetEmit(bool bEmit)
|
|
{
|
|
m_bEmit = bEmit;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : rate -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SmokeTrail::SetSpawnRate(float rate)
|
|
{
|
|
m_SpawnRate = rate;
|
|
m_ParticleSpawn.Init(rate);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bnewentity -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SmokeTrail::OnDataChanged(DataUpdateType_t updateType)
|
|
{
|
|
C_BaseEntity::OnDataChanged(updateType);
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
Start( ParticleMgr(), NULL );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pParticleMgr -
|
|
// *pArgs -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SmokeTrail::Start( CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs )
|
|
{
|
|
if(!pParticleMgr->AddEffect( &m_ParticleEffect, this ))
|
|
return;
|
|
|
|
m_pParticleMgr = pParticleMgr;
|
|
m_pSmokeEmitter = CSmokeParticle::Create("smokeTrail");
|
|
|
|
if ( !m_pSmokeEmitter )
|
|
{
|
|
Assert( false );
|
|
return;
|
|
}
|
|
|
|
m_pSmokeEmitter->SetSortOrigin( GetAbsOrigin() );
|
|
m_pSmokeEmitter->SetNearClip( 64.0f, 128.0f );
|
|
|
|
m_MaterialHandle[0] = g_Mat_DustPuff[0];
|
|
m_MaterialHandle[1] = g_Mat_DustPuff[1];
|
|
|
|
m_ParticleSpawn.Init( m_SpawnRate );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : fTimeDelta -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SmokeTrail::Update( float fTimeDelta )
|
|
{
|
|
if ( !m_pSmokeEmitter )
|
|
return;
|
|
|
|
Vector offsetColor;
|
|
|
|
// Add new particles
|
|
if ( !m_bEmit )
|
|
return;
|
|
|
|
if ( ( m_StopEmitTime != 0 ) && ( m_StopEmitTime <= gpGlobals->curtime ) )
|
|
return;
|
|
|
|
float tempDelta = fTimeDelta;
|
|
|
|
SimpleParticle *pParticle;
|
|
Vector offset;
|
|
|
|
Vector vecOrigin;
|
|
VectorMA( GetAbsOrigin(), -fTimeDelta, GetAbsVelocity(), vecOrigin );
|
|
|
|
Vector vecForward;
|
|
GetVectors( &vecForward, NULL, NULL );
|
|
|
|
while( m_ParticleSpawn.NextEvent( tempDelta ) )
|
|
{
|
|
float fldt = fTimeDelta - tempDelta;
|
|
|
|
offset.Random( -m_SpawnRadius, m_SpawnRadius );
|
|
offset += vecOrigin;
|
|
VectorMA( offset, fldt, GetAbsVelocity(), offset );
|
|
|
|
pParticle = (SimpleParticle *) m_pSmokeEmitter->AddParticle( sizeof( SimpleParticle ), m_MaterialHandle[random->RandomInt(0,1)], offset );
|
|
|
|
if ( pParticle == NULL )
|
|
continue;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = m_ParticleLifetime;
|
|
|
|
pParticle->m_vecVelocity.Random( -1.0f, 1.0f );
|
|
pParticle->m_vecVelocity *= random->RandomFloat( m_MinSpeed, m_MaxSpeed );
|
|
|
|
pParticle->m_vecVelocity = pParticle->m_vecVelocity + GetAbsVelocity();
|
|
|
|
float flDirectedVel = random->RandomFloat( m_MinDirectedSpeed, m_MaxDirectedSpeed );
|
|
VectorMA( pParticle->m_vecVelocity, flDirectedVel, vecForward, pParticle->m_vecVelocity );
|
|
|
|
offsetColor = m_StartColor;
|
|
float flMaxVal = MAX( m_StartColor[0], m_StartColor[1] );
|
|
if ( flMaxVal < m_StartColor[2] )
|
|
{
|
|
flMaxVal = m_StartColor[2];
|
|
}
|
|
offsetColor /= flMaxVal;
|
|
|
|
offsetColor *= random->RandomFloat( -0.2f, 0.2f );
|
|
offsetColor += m_StartColor;
|
|
|
|
offsetColor[0] = clamp( offsetColor[0], 0.0f, 1.0f );
|
|
offsetColor[1] = clamp( offsetColor[1], 0.0f, 1.0f );
|
|
offsetColor[2] = clamp( offsetColor[2], 0.0f, 1.0f );
|
|
|
|
pParticle->m_uchColor[0] = offsetColor[0]*255.0f;
|
|
pParticle->m_uchColor[1] = offsetColor[1]*255.0f;
|
|
pParticle->m_uchColor[2] = offsetColor[2]*255.0f;
|
|
|
|
pParticle->m_uchStartSize = m_StartSize;
|
|
pParticle->m_uchEndSize = m_EndSize;
|
|
|
|
float alpha = random->RandomFloat( m_Opacity*0.75f, m_Opacity*1.25f );
|
|
alpha = clamp( alpha, 0.0f, 1.0f );
|
|
|
|
pParticle->m_uchStartAlpha = alpha * 255;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -1.0f, 1.0f );
|
|
}
|
|
}
|
|
|
|
|
|
void C_SmokeTrail::RenderParticles( CParticleRenderIterator *pIterator )
|
|
{
|
|
}
|
|
|
|
|
|
void C_SmokeTrail::SimulateParticles( CParticleSimulateIterator *pIterator )
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is called after sending this entity's recording state
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void C_SmokeTrail::CleanupToolRecordingState( KeyValues *msg )
|
|
{
|
|
if ( !ToolsEnabled() )
|
|
return;
|
|
|
|
BaseClass::CleanupToolRecordingState( msg );
|
|
|
|
// Generally, this is used to allow the entity to clean up
|
|
// allocated state it put into the message, but here we're going
|
|
// to use it to send particle system messages because we
|
|
// know the grenade has been recorded at this point
|
|
if ( !clienttools->IsInRecordingMode() || !m_pSmokeEmitter.IsValid() )
|
|
return;
|
|
|
|
// For now, we can't record smoketrails that don't have a moveparent
|
|
C_BaseEntity *pEnt = GetMoveParent();
|
|
if ( !pEnt )
|
|
return;
|
|
|
|
bool bEmitterActive = m_bEmit && ( ( m_StopEmitTime == 0 ) || ( m_StopEmitTime > gpGlobals->curtime ) );
|
|
|
|
// NOTE: Particle system destruction message will be sent by the particle effect itself.
|
|
if ( m_pSmokeEmitter->GetToolParticleEffectId() == TOOLPARTICLESYSTEMID_INVALID )
|
|
{
|
|
int nId = m_pSmokeEmitter->AllocateToolParticleEffectId();
|
|
|
|
KeyValues *oldmsg = new KeyValues( "OldParticleSystem_Create" );
|
|
oldmsg->SetString( "name", "C_SmokeTrail" );
|
|
oldmsg->SetInt( "id", nId );
|
|
oldmsg->SetFloat( "time", gpGlobals->curtime );
|
|
|
|
KeyValues *pRandomEmitter = oldmsg->FindKey( "DmeRandomEmitter", true );
|
|
pRandomEmitter->SetInt( "count", m_SpawnRate ); // particles per second, when duration is < 0
|
|
pRandomEmitter->SetFloat( "duration", -1 );
|
|
pRandomEmitter->SetInt( "active", bEmitterActive );
|
|
|
|
KeyValues *pEmitterParent1 = pRandomEmitter->FindKey( "emitter1", true );
|
|
pEmitterParent1->SetFloat( "randomamount", 0.5f );
|
|
KeyValues *pEmitterParent2 = pRandomEmitter->FindKey( "emitter2", true );
|
|
pEmitterParent2->SetFloat( "randomamount", 0.5f );
|
|
|
|
KeyValues *pEmitter = pEmitterParent1->FindKey( "DmeSpriteEmitter", true );
|
|
pEmitter->SetString( "material", "particle/particle_smokegrenade" );
|
|
|
|
KeyValues *pInitializers = pEmitter->FindKey( "initializers", true );
|
|
|
|
// FIXME: Until we can interpolate ent logs during emission, this can't work
|
|
KeyValues *pPosition = pInitializers->FindKey( "DmePositionPointToEntityInitializer", true );
|
|
pPosition->SetPtr( "entindex", (void*)pEnt->entindex() );
|
|
pPosition->SetInt( "attachmentIndex", m_nAttachment );
|
|
pPosition->SetFloat( "randomDist", m_SpawnRadius );
|
|
pPosition->SetFloat( "startx", pEnt->GetAbsOrigin().x );
|
|
pPosition->SetFloat( "starty", pEnt->GetAbsOrigin().y );
|
|
pPosition->SetFloat( "startz", pEnt->GetAbsOrigin().z );
|
|
|
|
KeyValues *pLifetime = pInitializers->FindKey( "DmeRandomLifetimeInitializer", true );
|
|
pLifetime->SetFloat( "minLifetime", m_ParticleLifetime );
|
|
pLifetime->SetFloat( "maxLifetime", m_ParticleLifetime );
|
|
|
|
KeyValues *pVelocity = pInitializers->FindKey( "DmeAttachmentVelocityInitializer", true );
|
|
pVelocity->SetPtr( "entindex", (void*)entindex() );
|
|
pVelocity->SetFloat( "minAttachmentSpeed", m_MinDirectedSpeed );
|
|
pVelocity->SetFloat( "maxAttachmentSpeed", m_MaxDirectedSpeed );
|
|
pVelocity->SetFloat( "minRandomSpeed", m_MinSpeed );
|
|
pVelocity->SetFloat( "maxRandomSpeed", m_MaxSpeed );
|
|
|
|
KeyValues *pRoll = pInitializers->FindKey( "DmeRandomRollInitializer", true );
|
|
pRoll->SetFloat( "minRoll", 0.0f );
|
|
pRoll->SetFloat( "maxRoll", 360.0f );
|
|
|
|
KeyValues *pRollSpeed = pInitializers->FindKey( "DmeRandomRollSpeedInitializer", true );
|
|
pRollSpeed->SetFloat( "minRollSpeed", -1.0f );
|
|
pRollSpeed->SetFloat( "maxRollSpeed", 1.0f );
|
|
|
|
KeyValues *pColor = pInitializers->FindKey( "DmeRandomValueColorInitializer", true );
|
|
Color c(
|
|
FastFToC( clamp( m_StartColor.x, 0.f, 1.f ) ),
|
|
FastFToC( clamp( m_StartColor.y, 0.f, 1.f ) ),
|
|
FastFToC( clamp( m_StartColor.z, 0.f, 1.f ) ),
|
|
255 );
|
|
pColor->SetColor( "startColor", c );
|
|
pColor->SetFloat( "minStartValueDelta", -0.2f );
|
|
pColor->SetFloat( "maxStartValueDelta", 0.2f );
|
|
pColor->SetColor( "endColor", Color( 0, 0, 0, 255 ) );
|
|
|
|
KeyValues *pAlpha = pInitializers->FindKey( "DmeRandomAlphaInitializer", true );
|
|
int nMinAlpha = 255 * m_Opacity * 0.75f;
|
|
int nMaxAlpha = 255 * m_Opacity * 1.25f;
|
|
pAlpha->SetInt( "minStartAlpha", 0 );
|
|
pAlpha->SetInt( "maxStartAlpha", 0 );
|
|
pAlpha->SetInt( "minEndAlpha", clamp( nMinAlpha, 0, 255 ) );
|
|
pAlpha->SetInt( "maxEndAlpha", clamp( nMaxAlpha, 0, 255 ) );
|
|
|
|
KeyValues *pSize = pInitializers->FindKey( "DmeRandomSizeInitializer", true );
|
|
pSize->SetFloat( "minStartSize", m_StartSize );
|
|
pSize->SetFloat( "maxStartSize", m_StartSize );
|
|
pSize->SetFloat( "minEndSize", m_EndSize );
|
|
pSize->SetFloat( "maxEndSize", m_EndSize );
|
|
|
|
KeyValues *pUpdaters = pEmitter->FindKey( "updaters", true );
|
|
|
|
pUpdaters->FindKey( "DmePositionVelocityUpdater", true );
|
|
pUpdaters->FindKey( "DmeRollUpdater", true );
|
|
|
|
KeyValues *pRollSpeedUpdater = pUpdaters->FindKey( "DmeRollSpeedAttenuateUpdater", true );
|
|
pRollSpeedUpdater->SetFloat( "attenuation", 1.0f - 8.0f / 30.0f );
|
|
pRollSpeedUpdater->SetFloat( "attenuationTme", 1.0f / 30.0f );
|
|
pRollSpeedUpdater->SetFloat( "minRollSpeed", 0.5f );
|
|
|
|
pUpdaters->FindKey( "DmeAlphaSineUpdater", true );
|
|
pUpdaters->FindKey( "DmeColorUpdater", true );
|
|
pUpdaters->FindKey( "DmeSizeUpdater", true );
|
|
|
|
KeyValues *pEmitter2 = pEmitter->MakeCopy();
|
|
pEmitter2->SetString( "material", "particle/particle_noisesphere" );
|
|
pEmitterParent2->AddSubKey( pEmitter2 );
|
|
|
|
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, oldmsg );
|
|
oldmsg->deleteThis();
|
|
}
|
|
else
|
|
{
|
|
KeyValues *oldmsg = new KeyValues( "OldParticleSystem_ActivateEmitter" );
|
|
oldmsg->SetInt( "id", m_pSmokeEmitter->GetToolParticleEffectId() );
|
|
oldmsg->SetInt( "emitter", 0 );
|
|
oldmsg->SetInt( "active", bEmitterActive );
|
|
oldmsg->SetFloat( "time", gpGlobals->curtime );
|
|
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, oldmsg );
|
|
oldmsg->deleteThis();
|
|
}
|
|
}
|
|
|
|
|
|
//==================================================
|
|
// RocketTrail
|
|
//==================================================
|
|
|
|
// Expose to the particle app.
|
|
EXPOSE_PROTOTYPE_EFFECT(RocketTrail, C_RocketTrail);
|
|
|
|
// Datatable.. this can have all the smoketrail parameters when we need it to.
|
|
IMPLEMENT_CLIENTCLASS_DT(C_RocketTrail, DT_RocketTrail, RocketTrail)
|
|
RecvPropFloat(RECVINFO(m_SpawnRate)),
|
|
RecvPropVector(RECVINFO(m_StartColor)),
|
|
RecvPropVector(RECVINFO(m_EndColor)),
|
|
RecvPropFloat(RECVINFO(m_ParticleLifetime)),
|
|
RecvPropFloat(RECVINFO(m_StopEmitTime)),
|
|
RecvPropFloat(RECVINFO(m_MinSpeed)),
|
|
RecvPropFloat(RECVINFO(m_MaxSpeed)),
|
|
RecvPropFloat(RECVINFO(m_StartSize)),
|
|
RecvPropFloat(RECVINFO(m_EndSize)),
|
|
RecvPropFloat(RECVINFO(m_SpawnRadius)),
|
|
RecvPropInt(RECVINFO(m_bEmit)),
|
|
RecvPropInt(RECVINFO(m_nAttachment)),
|
|
RecvPropFloat(RECVINFO(m_Opacity)),
|
|
RecvPropInt(RECVINFO(m_bDamaged)),
|
|
RecvPropFloat(RECVINFO(m_flFlareScale)),
|
|
END_RECV_TABLE()
|
|
|
|
// ------------------------------------------------------------------------- //
|
|
// ParticleMovieExplosion
|
|
// ------------------------------------------------------------------------- //
|
|
C_RocketTrail::C_RocketTrail()
|
|
{
|
|
m_MaterialHandle[0] = NULL;
|
|
m_MaterialHandle[1] = NULL;
|
|
|
|
m_SpawnRate = 10;
|
|
m_ParticleSpawn.Init(10);
|
|
m_StartColor.Init(0.5, 0.5, 0.5);
|
|
m_EndColor.Init(0,0,0);
|
|
m_ParticleLifetime = 5;
|
|
m_StopEmitTime = 0; // No end time
|
|
m_MinSpeed = 2;
|
|
m_MaxSpeed = 4;
|
|
m_StartSize = 35;
|
|
m_EndSize = 55;
|
|
m_SpawnRadius = 2;
|
|
m_VelocityOffset.Init();
|
|
m_Opacity = 0.5f;
|
|
|
|
m_bEmit = true;
|
|
m_bDamaged = false;
|
|
|
|
m_nAttachment = -1;
|
|
|
|
m_pRocketEmitter = NULL;
|
|
m_pParticleMgr = NULL;
|
|
}
|
|
|
|
C_RocketTrail::~C_RocketTrail()
|
|
{
|
|
if ( m_pParticleMgr )
|
|
{
|
|
m_pParticleMgr->RemoveEffect( &m_ParticleEffect );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void C_RocketTrail::GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pAbsOrigin, QAngle *pAbsAngles )
|
|
{
|
|
C_BaseEntity *pEnt = pAttachedTo->GetBaseEntity();
|
|
if (pEnt && (m_nAttachment > 0))
|
|
{
|
|
pEnt->GetAttachment( m_nAttachment, *pAbsOrigin, *pAbsAngles );
|
|
}
|
|
else
|
|
{
|
|
BaseClass::GetAimEntOrigin( pAttachedTo, pAbsOrigin, pAbsAngles );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bEmit -
|
|
//-----------------------------------------------------------------------------
|
|
void C_RocketTrail::SetEmit(bool bEmit)
|
|
{
|
|
m_bEmit = bEmit;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : rate -
|
|
//-----------------------------------------------------------------------------
|
|
void C_RocketTrail::SetSpawnRate(float rate)
|
|
{
|
|
m_SpawnRate = rate;
|
|
m_ParticleSpawn.Init(rate);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bnewentity -
|
|
//-----------------------------------------------------------------------------
|
|
void C_RocketTrail::OnDataChanged(DataUpdateType_t updateType)
|
|
{
|
|
C_BaseEntity::OnDataChanged(updateType);
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
Start( ParticleMgr(), NULL );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pParticleMgr -
|
|
// *pArgs -
|
|
//-----------------------------------------------------------------------------
|
|
void C_RocketTrail::Start( CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs )
|
|
{
|
|
if(!pParticleMgr->AddEffect( &m_ParticleEffect, this ))
|
|
return;
|
|
|
|
m_pParticleMgr = pParticleMgr;
|
|
m_pRocketEmitter = CRocketTrailParticle::Create("smokeTrail");
|
|
if ( !m_pRocketEmitter )
|
|
{
|
|
Assert( false );
|
|
return;
|
|
}
|
|
|
|
m_pRocketEmitter->SetSortOrigin( GetAbsOrigin() );
|
|
m_pRocketEmitter->SetNearClip( 64.0f, 128.0f );
|
|
|
|
m_MaterialHandle[0] = g_Mat_DustPuff[0];
|
|
m_MaterialHandle[1] = g_Mat_DustPuff[1];
|
|
|
|
m_ParticleSpawn.Init( m_SpawnRate );
|
|
|
|
m_vecLastPosition = GetAbsOrigin();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : fTimeDelta -
|
|
//-----------------------------------------------------------------------------
|
|
void C_RocketTrail::Update( float fTimeDelta )
|
|
{
|
|
if ( !m_pRocketEmitter )
|
|
return;
|
|
|
|
if ( gpGlobals->frametime == 0.0f )
|
|
return;
|
|
|
|
CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "MuzzleFlash" );
|
|
pSimple->SetSortOrigin( GetAbsOrigin() );
|
|
|
|
SimpleParticle *pParticle;
|
|
Vector forward, offset;
|
|
|
|
AngleVectors( GetAbsAngles(), &forward );
|
|
|
|
forward.Negate();
|
|
|
|
float flScale = random->RandomFloat( m_flFlareScale-0.5f, m_flFlareScale+0.5f );
|
|
|
|
//
|
|
// Flash
|
|
//
|
|
|
|
int i;
|
|
|
|
for ( i = 1; i < 9; i++ )
|
|
{
|
|
offset = GetAbsOrigin() + (forward * (i*2.0f*m_flFlareScale));
|
|
|
|
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( VarArgs( "effects/muzzleflash%d", random->RandomInt(1,4) ) ), offset );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = 0.01f;
|
|
|
|
pParticle->m_vecVelocity.Init();
|
|
|
|
pParticle->m_uchColor[0] = 255;
|
|
pParticle->m_uchColor[1] = 255;
|
|
pParticle->m_uchColor[2] = 255;
|
|
|
|
pParticle->m_uchStartAlpha = 255;
|
|
pParticle->m_uchEndAlpha = 128;
|
|
|
|
pParticle->m_uchStartSize = (random->RandomFloat( 5.0f, 6.0f ) * (12-(i))/9) * flScale;
|
|
pParticle->m_uchEndSize = pParticle->m_uchStartSize;
|
|
pParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
pParticle->m_flRollDelta = 0.0f;
|
|
}
|
|
|
|
// Add new particles (undamaged version)
|
|
if ( m_bEmit )
|
|
{
|
|
Vector moveDiff = GetAbsOrigin() - m_vecLastPosition;
|
|
float moveLength = VectorNormalize( moveDiff );
|
|
|
|
int numPuffs = moveLength / ( m_StartSize / 2.0f );
|
|
|
|
//debugoverlay->AddLineOverlay( m_vecLastPosition, GetAbsOrigin(), 255, 0, 0, true, 2.0f );
|
|
|
|
//FIXME: More rational cap here, perhaps
|
|
if ( numPuffs > 50 )
|
|
numPuffs = 50;
|
|
|
|
Vector offsetColor;
|
|
float step = moveLength / numPuffs;
|
|
|
|
//Fill in the gaps
|
|
for ( i = 1; i < numPuffs+1; i++ )
|
|
{
|
|
offset = m_vecLastPosition + ( moveDiff * step * i );
|
|
|
|
//debugoverlay->AddBoxOverlay( offset, -Vector(2,2,2), Vector(2,2,2), vec3_angle, i*4, i*4, i*4, true, 4.0f );
|
|
|
|
pParticle = (SimpleParticle *) m_pRocketEmitter->AddParticle( sizeof( SimpleParticle ), m_MaterialHandle[random->RandomInt(0,1)], offset );
|
|
|
|
if ( pParticle != NULL )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = m_ParticleLifetime + random->RandomFloat(m_ParticleLifetime*0.9f,m_ParticleLifetime*1.1f);
|
|
|
|
pParticle->m_vecVelocity.Random( -1.0f, 1.0f );
|
|
pParticle->m_vecVelocity *= random->RandomFloat( m_MinSpeed, m_MaxSpeed );
|
|
|
|
offsetColor = m_StartColor * random->RandomFloat( 0.75f, 1.25f );
|
|
|
|
offsetColor[0] = clamp( offsetColor[0], 0.0f, 1.0f );
|
|
offsetColor[1] = clamp( offsetColor[1], 0.0f, 1.0f );
|
|
offsetColor[2] = clamp( offsetColor[2], 0.0f, 1.0f );
|
|
|
|
pParticle->m_uchColor[0] = offsetColor[0]*255.0f;
|
|
pParticle->m_uchColor[1] = offsetColor[1]*255.0f;
|
|
pParticle->m_uchColor[2] = offsetColor[2]*255.0f;
|
|
|
|
pParticle->m_uchStartSize = m_StartSize * random->RandomFloat( 0.75f, 1.25f );
|
|
pParticle->m_uchEndSize = m_EndSize * random->RandomFloat( 1.0f, 1.25f );
|
|
|
|
float alpha = random->RandomFloat( m_Opacity*0.75f, m_Opacity*1.25f );
|
|
|
|
if ( alpha > 1.0f )
|
|
alpha = 1.0f;
|
|
if ( alpha < 0.0f )
|
|
alpha = 0.0f;
|
|
|
|
pParticle->m_uchStartAlpha = alpha * 255;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -8.0f, 8.0f );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( m_bDamaged )
|
|
{
|
|
Vector offsetColor;
|
|
|
|
CSmartPtr<CEmberEffect> pEmitter = CEmberEffect::Create("C_RocketTrail::damaged");
|
|
|
|
pEmitter->SetSortOrigin( GetAbsOrigin() );
|
|
|
|
PMaterialHandle flameMaterial = m_pRocketEmitter->GetPMaterial( VarArgs( "sprites/flamelet%d", random->RandomInt( 1, 4 ) ) );
|
|
|
|
// Flames from the rocket
|
|
for ( i = 0; i < 8; i++ )
|
|
{
|
|
offset = RandomVector( -8, 8 ) + GetAbsOrigin();
|
|
|
|
pParticle = (SimpleParticle *) pEmitter->AddParticle( sizeof( SimpleParticle ), flameMaterial, offset );
|
|
|
|
if ( pParticle != NULL )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = 0.25f;
|
|
|
|
pParticle->m_vecVelocity.Random( -1.0f, 1.0f );
|
|
pParticle->m_vecVelocity *= random->RandomFloat( 32, 128 );
|
|
|
|
offsetColor = m_StartColor * random->RandomFloat( 0.75f, 1.25f );
|
|
|
|
offsetColor[0] = clamp( offsetColor[0], 0.0f, 1.0f );
|
|
offsetColor[1] = clamp( offsetColor[1], 0.0f, 1.0f );
|
|
offsetColor[2] = clamp( offsetColor[2], 0.0f, 1.0f );
|
|
|
|
pParticle->m_uchColor[0] = offsetColor[0]*255.0f;
|
|
pParticle->m_uchColor[1] = offsetColor[1]*255.0f;
|
|
pParticle->m_uchColor[2] = offsetColor[2]*255.0f;
|
|
|
|
pParticle->m_uchStartSize = 8.0f;
|
|
pParticle->m_uchEndSize = 32.0f;
|
|
|
|
pParticle->m_uchStartAlpha = 255;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -8.0f, 8.0f );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_vecLastPosition = GetAbsOrigin();
|
|
}
|
|
|
|
void C_RocketTrail::RenderParticles( CParticleRenderIterator *pIterator )
|
|
{
|
|
}
|
|
|
|
void C_RocketTrail::SimulateParticles( CParticleSimulateIterator *pIterator )
|
|
{
|
|
}
|
|
|
|
SporeEffect::SporeEffect( const char *pDebugName ) : CSimpleEmitter( pDebugName )
|
|
{
|
|
}
|
|
|
|
|
|
SporeEffect* SporeEffect::Create( const char *pDebugName )
|
|
{
|
|
return new SporeEffect( pDebugName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : fTimeDelta -
|
|
// Output : Vector
|
|
//-----------------------------------------------------------------------------
|
|
void SporeEffect::UpdateVelocity( SimpleParticle *pParticle, float timeDelta )
|
|
{
|
|
float speed = VectorNormalize( pParticle->m_vecVelocity );
|
|
Vector offset;
|
|
|
|
speed -= ( 64.0f * timeDelta );
|
|
|
|
offset.Random( -0.5f, 0.5f );
|
|
|
|
pParticle->m_vecVelocity += offset;
|
|
VectorNormalize( pParticle->m_vecVelocity );
|
|
|
|
pParticle->m_vecVelocity *= speed;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pParticle -
|
|
// timeDelta -
|
|
//-----------------------------------------------------------------------------
|
|
Vector SporeEffect::UpdateColor( const SimpleParticle *pParticle )
|
|
{
|
|
Vector color;
|
|
float ramp = ((float)pParticle->m_uchStartAlpha/255.0f) * sin( M_PI * (pParticle->m_flLifetime / pParticle->m_flDieTime) );//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
|
|
//-----------------------------------------------------------------------------
|
|
float SporeEffect::UpdateAlpha( const SimpleParticle *pParticle )
|
|
{
|
|
return ( ((float)pParticle->m_uchStartAlpha/255.0f) * sin( M_PI * (pParticle->m_flLifetime / pParticle->m_flDieTime) ) );
|
|
}
|
|
|
|
//==================================================
|
|
// C_SporeExplosion
|
|
//==================================================
|
|
|
|
EXPOSE_PROTOTYPE_EFFECT( SporeExplosion, C_SporeExplosion );
|
|
|
|
IMPLEMENT_CLIENTCLASS_DT( C_SporeExplosion, DT_SporeExplosion, SporeExplosion )
|
|
RecvPropFloat(RECVINFO(m_flSpawnRate)),
|
|
RecvPropFloat(RECVINFO(m_flParticleLifetime)),
|
|
RecvPropFloat(RECVINFO(m_flStartSize)),
|
|
RecvPropFloat(RECVINFO(m_flEndSize)),
|
|
RecvPropFloat(RECVINFO(m_flSpawnRadius)),
|
|
RecvPropBool(RECVINFO(m_bEmit)),
|
|
RecvPropBool(RECVINFO(m_bDontRemove)),
|
|
END_RECV_TABLE()
|
|
|
|
C_SporeExplosion::C_SporeExplosion( void )
|
|
{
|
|
m_pParticleMgr = NULL;
|
|
|
|
m_flSpawnRate = 32;
|
|
m_flParticleLifetime = 5;
|
|
m_flStartSize = 32;
|
|
m_flEndSize = 64;
|
|
m_flSpawnRadius = 32;
|
|
m_pSporeEffect = NULL;
|
|
|
|
m_teParticleSpawn.Init( 32 );
|
|
|
|
m_bEmit = true;
|
|
m_bDontRemove = false;
|
|
}
|
|
|
|
C_SporeExplosion::~C_SporeExplosion()
|
|
{
|
|
if ( m_pParticleMgr != NULL )
|
|
{
|
|
m_pParticleMgr->RemoveEffect( &m_ParticleEffect );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bnewentity -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeExplosion::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
C_BaseEntity::OnDataChanged( updateType );
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
m_flPreviousSpawnRate = m_flSpawnRate;
|
|
m_teParticleSpawn.Init( m_flSpawnRate );
|
|
Start( ParticleMgr(), NULL );
|
|
}
|
|
else if( m_bEmit )
|
|
{
|
|
// Just been turned on by the server.
|
|
m_flPreviousSpawnRate = m_flSpawnRate;
|
|
m_teParticleSpawn.Init( m_flSpawnRate );
|
|
}
|
|
|
|
m_pSporeEffect->SetDontRemove( m_bDontRemove );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pParticleMgr -
|
|
// *pArgs -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeExplosion::Start( CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs )
|
|
{
|
|
//Add us into the effect manager
|
|
if( pParticleMgr->AddEffect( &m_ParticleEffect, this ) == false )
|
|
return;
|
|
|
|
//Create our main effect
|
|
m_pSporeEffect = SporeEffect::Create( "C_SporeExplosion" );
|
|
|
|
if ( m_pSporeEffect == NULL )
|
|
return;
|
|
|
|
m_hMaterial = m_pSporeEffect->GetPMaterial( "particle/fire" );
|
|
|
|
m_pSporeEffect->SetSortOrigin( GetAbsOrigin() );
|
|
m_pSporeEffect->SetNearClip( 64, 128 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeExplosion::AddParticles( void )
|
|
{
|
|
//Spores
|
|
Vector offset;
|
|
Vector dir;
|
|
|
|
//Get our direction
|
|
AngleVectors( GetAbsAngles(), &dir );
|
|
|
|
SimpleParticle *sParticle;
|
|
|
|
for ( int i = 0; i < 4; i++ )
|
|
{
|
|
//Add small particle to the effect's origin
|
|
offset.Random( -m_flSpawnRadius, m_flSpawnRadius );
|
|
sParticle = (SimpleParticle *) m_pSporeEffect->AddParticle( sizeof(SimpleParticle), m_hMaterial, GetAbsOrigin()+offset );
|
|
|
|
if ( sParticle == NULL )
|
|
return;
|
|
|
|
sParticle->m_flLifetime = 0.0f;
|
|
sParticle->m_flDieTime = 2.0f;
|
|
|
|
sParticle->m_flRoll = 0;
|
|
sParticle->m_flRollDelta = 0;
|
|
|
|
sParticle->m_uchColor[0] = 225;
|
|
sParticle->m_uchColor[1] = 140;
|
|
sParticle->m_uchColor[2] = 64;
|
|
sParticle->m_uchStartAlpha = Helper_RandomInt( 128, 255 );
|
|
sParticle->m_uchEndAlpha = 0;
|
|
sParticle->m_uchStartSize = Helper_RandomInt( 1, 2 );
|
|
sParticle->m_uchEndSize = 1;
|
|
|
|
sParticle->m_vecVelocity = dir * Helper_RandomFloat( 128.0f, 256.0f );
|
|
}
|
|
|
|
//Add smokey bits
|
|
offset.Random( -(m_flSpawnRadius * 0.5), (m_flSpawnRadius * 0.5) );
|
|
sParticle = (SimpleParticle *) m_pSporeEffect->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], GetAbsOrigin()+offset );
|
|
|
|
if ( sParticle == NULL )
|
|
return;
|
|
|
|
sParticle->m_flLifetime = 0.0f;
|
|
sParticle->m_flDieTime = 1.0f;
|
|
|
|
sParticle->m_flRoll = Helper_RandomFloat( 0, 360 );
|
|
sParticle->m_flRollDelta = Helper_RandomFloat( -2.0f, 2.0f );
|
|
|
|
sParticle->m_uchColor[0] = 225;
|
|
sParticle->m_uchColor[1] = 140;
|
|
sParticle->m_uchColor[2] = 64;
|
|
sParticle->m_uchStartAlpha = Helper_RandomInt( 32, 64 );
|
|
sParticle->m_uchEndAlpha = 0;
|
|
sParticle->m_uchStartSize = m_flStartSize;
|
|
sParticle->m_uchEndSize = m_flEndSize;
|
|
|
|
sParticle->m_vecVelocity = dir * Helper_RandomFloat( 64.0f, 128.0f );
|
|
}
|
|
|
|
|
|
ConVar cl_sporeclipdistance( "cl_sporeclipdistance", "512", FCVAR_CHEAT | FCVAR_CLIENTDLL );
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : fTimeDelta -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeExplosion::Update( float fTimeDelta )
|
|
{
|
|
if( m_bEmit )
|
|
{
|
|
float tempDelta = fTimeDelta;
|
|
|
|
float flDist = (MainViewOrigin() - GetAbsOrigin()).Length();
|
|
|
|
//Lower the spawnrate by half if we're far away from it.
|
|
if ( cl_sporeclipdistance.GetFloat() <= flDist )
|
|
{
|
|
if ( m_flSpawnRate == m_flPreviousSpawnRate )
|
|
{
|
|
m_flPreviousSpawnRate = m_flSpawnRate * 0.5f;
|
|
m_teParticleSpawn.ResetRate( m_flPreviousSpawnRate );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_flSpawnRate != m_flPreviousSpawnRate )
|
|
{
|
|
m_flPreviousSpawnRate = m_flSpawnRate;
|
|
m_teParticleSpawn.ResetRate( m_flPreviousSpawnRate );
|
|
}
|
|
}
|
|
|
|
while ( m_teParticleSpawn.NextEvent( tempDelta ) )
|
|
{
|
|
AddParticles();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void C_SporeExplosion::SimulateParticles( CParticleSimulateIterator *pIterator )
|
|
{
|
|
StandardParticle_t *pParticle = (StandardParticle_t*)pIterator->GetFirst();
|
|
while ( pParticle )
|
|
{
|
|
pParticle->m_Lifetime += pIterator->GetTimeDelta();
|
|
|
|
if( pParticle->m_Lifetime > m_flParticleLifetime )
|
|
{
|
|
pIterator->RemoveParticle( pParticle );
|
|
}
|
|
|
|
pParticle = (StandardParticle_t*)pIterator->GetNext();
|
|
}
|
|
}
|
|
|
|
void C_SporeExplosion::RenderParticles( CParticleRenderIterator *pIterator )
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void RPGShotDownCallback( const CEffectData &data )
|
|
{
|
|
CLocalPlayerFilter filter;
|
|
C_BaseEntity::EmitSound( filter, SOUND_FROM_WORLD, "Missile.ShotDown", &data.m_vOrigin );
|
|
|
|
if ( CExplosionOverlay *pOverlay = new CExplosionOverlay )
|
|
{
|
|
pOverlay->m_flLifetime = 0;
|
|
pOverlay->m_vPos = data.m_vOrigin;
|
|
pOverlay->m_nSprites = 1;
|
|
|
|
pOverlay->m_vBaseColors[0].Init( 1.0f, 0.9f, 0.7f );
|
|
|
|
pOverlay->m_Sprites[0].m_flHorzSize = 0.01f;
|
|
pOverlay->m_Sprites[0].m_flVertSize = pOverlay->m_Sprites[0].m_flHorzSize*0.5f;
|
|
|
|
pOverlay->Activate();
|
|
}
|
|
}
|
|
|
|
DECLARE_CLIENT_EFFECT( "RPGShotDown", RPGShotDownCallback );
|
|
|
|
|
|
|
|
//==================================================
|
|
// C_SporeTrail
|
|
//==================================================
|
|
|
|
class C_SporeTrail : public C_BaseParticleEntity
|
|
{
|
|
public:
|
|
DECLARE_CLASS( C_SporeTrail, C_BaseParticleEntity );
|
|
DECLARE_CLIENTCLASS();
|
|
|
|
C_SporeTrail( void );
|
|
virtual ~C_SporeTrail( void );
|
|
|
|
public:
|
|
void SetEmit( bool bEmit );
|
|
|
|
|
|
// C_BaseEntity
|
|
public:
|
|
virtual void OnDataChanged( DataUpdateType_t updateType );
|
|
virtual void GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pAbsOrigin, QAngle *pAbsAngles );
|
|
|
|
// IPrototypeAppEffect
|
|
public:
|
|
virtual void Start( CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs );
|
|
|
|
// IParticleEffect
|
|
public:
|
|
virtual void Update( float fTimeDelta );
|
|
virtual void RenderParticles( CParticleRenderIterator *pIterator );
|
|
virtual void SimulateParticles( CParticleSimulateIterator *pIterator );
|
|
virtual void StartRender( VMatrix &effectMatrix );
|
|
|
|
public:
|
|
Vector m_vecEndColor;
|
|
|
|
float m_flSpawnRate;
|
|
float m_flParticleLifetime;
|
|
float m_flStartSize;
|
|
float m_flEndSize;
|
|
float m_flSpawnRadius;
|
|
|
|
Vector m_vecVelocityOffset;
|
|
|
|
bool m_bEmit;
|
|
|
|
private:
|
|
C_SporeTrail( const C_SporeTrail & );
|
|
|
|
void AddParticles( void );
|
|
|
|
PMaterialHandle m_hMaterial;
|
|
TimedEvent m_teParticleSpawn;
|
|
//CSmartPtr<SporeSmokeEffect> m_pSmokeEffect;
|
|
|
|
Vector m_vecPos;
|
|
Vector m_vecLastPos; // This is stored so we can spawn particles in between the previous and new position
|
|
// to eliminate holes in the trail.
|
|
|
|
VMatrix m_mAttachmentMatrix;
|
|
CParticleMgr *m_pParticleMgr;
|
|
};
|
|
|
|
|
|
|
|
//==================================================
|
|
// C_SporeTrail
|
|
//==================================================
|
|
|
|
IMPLEMENT_CLIENTCLASS_DT( C_SporeTrail, DT_SporeTrail, SporeTrail )
|
|
RecvPropFloat(RECVINFO(m_flSpawnRate)),
|
|
RecvPropVector(RECVINFO(m_vecEndColor)),
|
|
RecvPropFloat(RECVINFO(m_flParticleLifetime)),
|
|
RecvPropFloat(RECVINFO(m_flStartSize)),
|
|
RecvPropFloat(RECVINFO(m_flEndSize)),
|
|
RecvPropFloat(RECVINFO(m_flSpawnRadius)),
|
|
RecvPropInt(RECVINFO(m_bEmit)),
|
|
END_RECV_TABLE()
|
|
|
|
C_SporeTrail::C_SporeTrail( void )
|
|
{
|
|
m_pParticleMgr = NULL;
|
|
//m_pSmokeEffect = SporeSmokeEffect::Create( "C_SporeTrail" );
|
|
|
|
m_flSpawnRate = 10;
|
|
m_flParticleLifetime = 5;
|
|
m_flStartSize = 35;
|
|
m_flEndSize = 55;
|
|
m_flSpawnRadius = 2;
|
|
|
|
m_teParticleSpawn.Init( 5 );
|
|
m_vecEndColor.Init();
|
|
m_vecPos.Init();
|
|
m_vecLastPos.Init();
|
|
m_vecVelocityOffset.Init();
|
|
|
|
m_bEmit = true;
|
|
}
|
|
|
|
C_SporeTrail::~C_SporeTrail()
|
|
{
|
|
if( m_pParticleMgr )
|
|
{
|
|
m_pParticleMgr->RemoveEffect( &m_ParticleEffect );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bEmit -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeTrail::SetEmit( bool bEmit )
|
|
{
|
|
m_bEmit = bEmit;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bnewentity -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeTrail::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
C_BaseEntity::OnDataChanged( updateType );
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
Start( ParticleMgr(), NULL );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pParticleMgr -
|
|
// *pArgs -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeTrail::Start( CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs )
|
|
{
|
|
if( pParticleMgr->AddEffect( &m_ParticleEffect, this ) == false )
|
|
return;
|
|
|
|
m_hMaterial = g_Mat_DustPuff[1];
|
|
m_pParticleMgr = pParticleMgr;
|
|
m_teParticleSpawn.Init( 64 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeTrail::AddParticles( void )
|
|
{
|
|
Vector offset = RandomVector( -4.0f, 4.0f );
|
|
|
|
//Make a new particle
|
|
SimpleParticle *sParticle = (SimpleParticle *) m_ParticleEffect.AddParticle( sizeof(SimpleParticle), m_hMaterial );//m_pSmokeEffect->AddParticle( sizeof(SimpleParticle), m_hMaterial, GetAbsOrigin()+offset );
|
|
|
|
if ( sParticle == NULL )
|
|
return;
|
|
|
|
sParticle->m_Pos = offset;
|
|
sParticle->m_flRoll = Helper_RandomInt( 0, 360 );
|
|
sParticle->m_flRollDelta = Helper_RandomFloat( -2.0f, 2.0f );
|
|
|
|
sParticle->m_flLifetime = 0.0f;
|
|
sParticle->m_flDieTime = 0.5f;
|
|
|
|
sParticle->m_uchColor[0] = 225;
|
|
sParticle->m_uchColor[1] = 140;
|
|
sParticle->m_uchColor[2] = 64;
|
|
sParticle->m_uchStartAlpha = Helper_RandomInt( 64, 128 );
|
|
sParticle->m_uchEndAlpha = 0;
|
|
|
|
sParticle->m_uchStartSize = 1.0f;
|
|
sParticle->m_uchEndSize = 1.0f;
|
|
|
|
sParticle->m_vecVelocity = RandomVector( -8.0f, 8.0f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : fTimeDelta -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeTrail::Update( float fTimeDelta )
|
|
{
|
|
if ( m_pParticleMgr == NULL )
|
|
return;
|
|
|
|
//Add new particles
|
|
if ( m_bEmit )
|
|
{
|
|
float tempDelta = fTimeDelta;
|
|
|
|
while ( m_teParticleSpawn.NextEvent( tempDelta ) )
|
|
{
|
|
AddParticles();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &effectMatrix -
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeTrail::StartRender( VMatrix &effectMatrix )
|
|
{
|
|
effectMatrix = effectMatrix * m_mAttachmentMatrix;
|
|
}
|
|
|
|
void C_SporeTrail::RenderParticles( CParticleRenderIterator *pIterator )
|
|
{
|
|
if ( m_bEmit == false )
|
|
return;
|
|
|
|
const SimpleParticle *pParticle = (const SimpleParticle*)pIterator->GetFirst();
|
|
while ( pParticle )
|
|
{
|
|
//Render
|
|
Vector tPos;
|
|
TransformParticle( m_pParticleMgr->GetModelView(), pParticle->m_Pos, tPos );
|
|
float sortKey = tPos.z;
|
|
|
|
Vector color = Vector( 1.0f, 1.0f, 1.0f );
|
|
|
|
//Render it
|
|
RenderParticle_ColorSize(
|
|
pIterator->GetParticleDraw(),
|
|
tPos,
|
|
color,
|
|
1.0f,
|
|
4 );
|
|
|
|
pParticle = (const SimpleParticle*)pIterator->GetNext( sortKey );
|
|
}
|
|
}
|
|
|
|
|
|
void C_SporeTrail::SimulateParticles( CParticleSimulateIterator *pIterator )
|
|
{
|
|
if ( m_bEmit == false )
|
|
return;
|
|
|
|
SimpleParticle *pParticle = (SimpleParticle*)pIterator->GetFirst();
|
|
while ( pParticle )
|
|
{
|
|
//UpdateVelocity( pParticle, timeDelta );
|
|
pParticle->m_Pos += pParticle->m_vecVelocity * pIterator->GetTimeDelta();
|
|
|
|
//Should this particle die?
|
|
pParticle->m_flLifetime += pIterator->GetTimeDelta();
|
|
|
|
if ( pParticle->m_flLifetime >= pParticle->m_flDieTime )
|
|
{
|
|
pIterator->RemoveParticle( pParticle );
|
|
}
|
|
|
|
pParticle = (SimpleParticle*)pIterator->GetNext();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void C_SporeTrail::GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pAbsOrigin, QAngle *pAbsAngles )
|
|
{
|
|
C_BaseEntity *pEnt = pAttachedTo->GetBaseEntity();
|
|
|
|
pEnt->GetAttachment( 1, *pAbsOrigin, *pAbsAngles );
|
|
|
|
matrix3x4_t matrix;
|
|
|
|
AngleMatrix( *pAbsAngles, *pAbsOrigin, matrix );
|
|
|
|
m_mAttachmentMatrix = matrix;
|
|
}
|
|
|
|
//==================================================
|
|
// FireTrailhou
|
|
//==================================================
|
|
|
|
// Datatable.. this can have all the smoketrail parameters when we need it to.
|
|
IMPLEMENT_CLIENTCLASS_DT(C_FireTrail, DT_FireTrail, CFireTrail)
|
|
RecvPropInt(RECVINFO(m_nAttachment)),
|
|
RecvPropFloat(RECVINFO(m_flLifetime)),
|
|
END_RECV_TABLE()
|
|
|
|
// ------------------------------------------------------------------------- //
|
|
// ParticleMovieExplosion
|
|
// ------------------------------------------------------------------------- //
|
|
C_FireTrail::C_FireTrail()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
C_FireTrail::~C_FireTrail( void )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pParticleMgr -
|
|
// *pArgs -
|
|
//-----------------------------------------------------------------------------
|
|
void C_FireTrail::Start( CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs )
|
|
{
|
|
BaseClass::Start( pParticleMgr, pArgs );
|
|
|
|
m_pTrailEmitter = CSimpleEmitter::Create( "FireTrail" );
|
|
|
|
if ( !m_pTrailEmitter )
|
|
{
|
|
Assert( false );
|
|
return;
|
|
}
|
|
|
|
m_pTrailEmitter->SetSortOrigin( GetAbsOrigin() );
|
|
|
|
// Setup our materials
|
|
m_hMaterial[FTRAIL_SMOKE1] = g_Mat_DustPuff[0];
|
|
m_hMaterial[FTRAIL_SMOKE2] = g_Mat_DustPuff[1];
|
|
|
|
m_hMaterial[FTRAIL_FLAME1] = m_pTrailEmitter->GetPMaterial( "sprites/flamelet1" );
|
|
m_hMaterial[FTRAIL_FLAME2] = m_pTrailEmitter->GetPMaterial( "sprites/flamelet2" );
|
|
m_hMaterial[FTRAIL_FLAME3] = m_pTrailEmitter->GetPMaterial( "sprites/flamelet3" );
|
|
m_hMaterial[FTRAIL_FLAME4] = m_pTrailEmitter->GetPMaterial( "sprites/flamelet4" );
|
|
m_hMaterial[FTRAIL_FLAME5] = m_pTrailEmitter->GetPMaterial( "sprites/flamelet5" );
|
|
|
|
// Setup our smoke emitter
|
|
m_pSmokeEmitter = CSmokeParticle::Create( "FireTrail_Smoke" );
|
|
|
|
m_pSmokeEmitter->SetSortOrigin( GetAbsOrigin() );
|
|
m_pSmokeEmitter->SetNearClip( 64.0f, 128.0f );
|
|
|
|
if ( !m_pSmokeEmitter )
|
|
{
|
|
Assert( false );
|
|
return;
|
|
}
|
|
|
|
// Seed our first position as the last known one
|
|
m_vecLastPosition = GetAbsOrigin();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : fTimeDelta -
|
|
//-----------------------------------------------------------------------------
|
|
void C_FireTrail::Update( float fTimeDelta )
|
|
{
|
|
if ( !m_pTrailEmitter )
|
|
return;
|
|
|
|
if ( ( m_flLifetime != 0 ) && ( m_flLifetime <= gpGlobals->curtime ) )
|
|
return;
|
|
|
|
CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "FireTrail" );
|
|
pSimple->SetSortOrigin( GetAbsOrigin() );
|
|
|
|
Vector offset;
|
|
|
|
#define STARTSIZE 8
|
|
#define ENDSIZE 16
|
|
#define PARTICLE_LIFETIME 0.075f
|
|
#define MIN_SPEED 32
|
|
#define MAX_SPEED 64
|
|
|
|
// Add new particles
|
|
//if ( ShouldEmit() )
|
|
{
|
|
Vector moveDiff = GetAbsOrigin() - m_vecLastPosition;
|
|
float moveLength = VectorNormalize( moveDiff );
|
|
|
|
int numPuffs = moveLength / ( STARTSIZE / 2.0f );
|
|
|
|
//FIXME: More rational cap here, perhaps
|
|
numPuffs = clamp( numPuffs, 1, 32 );
|
|
|
|
SimpleParticle *pParticle;
|
|
Vector offsetColor;
|
|
float step = moveLength / numPuffs;
|
|
|
|
//Fill in the gaps
|
|
for ( int i = 1; i < numPuffs+1; i++ )
|
|
{
|
|
offset = m_vecLastPosition + ( moveDiff * step * i ) + RandomVector( -4.0f, 4.0f );
|
|
|
|
//debugoverlay->AddBoxOverlay( offset, -Vector(2,2,2), Vector(2,2,2), vec3_angle, i*4, i*4, i*4, true, 1.0f );
|
|
|
|
pParticle = (SimpleParticle *) m_pSmokeEmitter->AddParticle( sizeof( SimpleParticle ), m_hMaterial[random->RandomInt( FTRAIL_FLAME1,FTRAIL_FLAME5 )], offset );
|
|
|
|
if ( pParticle != NULL )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = /*PARTICLE_LIFETIME*/ 0.5f;// + random->RandomFloat(PARTICLE_LIFETIME*0.75f, PARTICLE_LIFETIME*1.25f);
|
|
|
|
pParticle->m_vecVelocity.Random( 0.0f, 1.0f );
|
|
pParticle->m_vecVelocity *= random->RandomFloat( MIN_SPEED, MAX_SPEED );
|
|
pParticle->m_vecVelocity[2] += 50;//random->RandomFloat( 32, 64 );
|
|
|
|
pParticle->m_uchColor[0] = 255.0f;
|
|
pParticle->m_uchColor[1] = 255.0f;
|
|
pParticle->m_uchColor[2] = 255.0f;
|
|
|
|
pParticle->m_uchStartSize = STARTSIZE * 2.0f;
|
|
pParticle->m_uchEndSize = STARTSIZE * 0.5f;
|
|
|
|
pParticle->m_uchStartAlpha = 255;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_flRoll = 0.0f;//random->RandomInt( 0, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -16.0f, 16.0f );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Smoke
|
|
//
|
|
|
|
offset = RandomVector( -STARTSIZE*0.5f, STARTSIZE*0.5f ) + GetAbsOrigin();
|
|
|
|
pParticle = (SimpleParticle *) m_pSmokeEmitter->AddParticle( sizeof( SimpleParticle ), m_hMaterial[random->RandomInt( FTRAIL_SMOKE1, FTRAIL_SMOKE2 )], offset );
|
|
|
|
if ( pParticle != NULL )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = ( PARTICLE_LIFETIME * 10.0f ) + random->RandomFloat(PARTICLE_LIFETIME*0.75f, PARTICLE_LIFETIME*1.25f);
|
|
|
|
pParticle->m_vecVelocity.Random( 0.0f, 1.0f );
|
|
pParticle->m_vecVelocity *= random->RandomFloat( MIN_SPEED, MAX_SPEED );
|
|
pParticle->m_vecVelocity[2] += random->RandomFloat( 50, 100 );
|
|
|
|
pParticle->m_uchColor[0] = 255.0f * 0.5f;
|
|
pParticle->m_uchColor[1] = 245.0f * 0.5f;
|
|
pParticle->m_uchColor[2] = 205.0f * 0.5f;
|
|
|
|
pParticle->m_uchStartSize = 16 * random->RandomFloat( 0.75f, 1.25f );
|
|
pParticle->m_uchEndSize = pParticle->m_uchStartSize * 2.5f;
|
|
|
|
pParticle->m_uchStartAlpha = 64;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -16.0f, 16.0f );
|
|
}
|
|
}
|
|
|
|
// Save off this position
|
|
m_vecLastPosition = GetAbsOrigin();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: High drag, non color changing particle
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
class CDustFollower : public CSimpleEmitter
|
|
{
|
|
public:
|
|
|
|
CDustFollower( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}
|
|
|
|
//Create
|
|
static CDustFollower *Create( const char *pDebugName )
|
|
{
|
|
return new CDustFollower( pDebugName );
|
|
}
|
|
|
|
//Alpha
|
|
virtual float UpdateAlpha( const SimpleParticle *pParticle )
|
|
{
|
|
return ( ((float)pParticle->m_uchStartAlpha/255.0f) * sin( M_PI * (pParticle->m_flLifetime / pParticle->m_flDieTime) ) );
|
|
}
|
|
|
|
virtual void UpdateVelocity( SimpleParticle *pParticle, float timeDelta )
|
|
{
|
|
pParticle->m_vecVelocity = pParticle->m_vecVelocity * ExponentialDecay( 0.3, timeDelta );
|
|
}
|
|
|
|
//Roll
|
|
virtual float UpdateRoll( SimpleParticle *pParticle, float timeDelta )
|
|
{
|
|
pParticle->m_flRoll += pParticle->m_flRollDelta * timeDelta;
|
|
|
|
pParticle->m_flRollDelta *= ExponentialDecay( 0.5, timeDelta );
|
|
|
|
return pParticle->m_flRoll;
|
|
}
|
|
|
|
private:
|
|
CDustFollower( const CDustFollower & );
|
|
};
|
|
|
|
|
|
// Datatable.. this can have all the smoketrail parameters when we need it to.
|
|
IMPLEMENT_CLIENTCLASS_DT(C_DustTrail, DT_DustTrail, DustTrail)
|
|
RecvPropFloat(RECVINFO(m_SpawnRate)),
|
|
RecvPropVector(RECVINFO(m_Color)),
|
|
RecvPropFloat(RECVINFO(m_ParticleLifetime)),
|
|
RecvPropFloat(RECVINFO(m_StopEmitTime)),
|
|
RecvPropFloat(RECVINFO(m_MinSpeed)),
|
|
RecvPropFloat(RECVINFO(m_MaxSpeed)),
|
|
RecvPropFloat(RECVINFO(m_MinDirectedSpeed)),
|
|
RecvPropFloat(RECVINFO(m_MaxDirectedSpeed)),
|
|
RecvPropFloat(RECVINFO(m_StartSize)),
|
|
RecvPropFloat(RECVINFO(m_EndSize)),
|
|
RecvPropFloat(RECVINFO(m_SpawnRadius)),
|
|
RecvPropInt(RECVINFO(m_bEmit)),
|
|
RecvPropFloat(RECVINFO(m_Opacity)),
|
|
END_RECV_TABLE()
|
|
|
|
|
|
// ------------------------------------------------------------------------- //
|
|
// ParticleMovieExplosion
|
|
// ------------------------------------------------------------------------- //
|
|
C_DustTrail::C_DustTrail()
|
|
{
|
|
for (int i = 0; i < DUSTTRAIL_MATERIALS; i++)
|
|
{
|
|
m_MaterialHandle[i] = NULL;
|
|
}
|
|
|
|
m_SpawnRate = 10;
|
|
m_ParticleSpawn.Init(10);
|
|
m_Color.Init(0.5, 0.5, 0.5);
|
|
m_ParticleLifetime = 5;
|
|
m_StartEmitTime = gpGlobals->curtime;
|
|
m_StopEmitTime = 0; // No end time
|
|
m_MinSpeed = 2;
|
|
m_MaxSpeed = 4;
|
|
m_MinDirectedSpeed = m_MaxDirectedSpeed = 0;
|
|
m_StartSize = 35;
|
|
m_EndSize = 55;
|
|
m_SpawnRadius = 2;
|
|
m_VelocityOffset.Init();
|
|
m_Opacity = 0.5f;
|
|
|
|
m_bEmit = true;
|
|
|
|
m_pDustEmitter = NULL;
|
|
m_pParticleMgr = NULL;
|
|
}
|
|
|
|
C_DustTrail::~C_DustTrail()
|
|
{
|
|
if ( ToolsEnabled() && clienttools->IsInRecordingMode() && m_pDustEmitter.IsValid() && m_pDustEmitter->GetToolParticleEffectId() != TOOLPARTICLESYSTEMID_INVALID )
|
|
{
|
|
KeyValues *msg = new KeyValues( "OldParticleSystem_ActivateEmitter" );
|
|
msg->SetInt( "id", m_pDustEmitter->GetToolParticleEffectId() );
|
|
msg->SetInt( "emitter", 0 );
|
|
msg->SetInt( "active", false );
|
|
msg->SetFloat( "time", gpGlobals->curtime );
|
|
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
|
|
msg->deleteThis();
|
|
}
|
|
|
|
if ( m_pParticleMgr )
|
|
{
|
|
m_pParticleMgr->RemoveEffect( &m_ParticleEffect );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bEmit -
|
|
//-----------------------------------------------------------------------------
|
|
void C_DustTrail::SetEmit(bool bEmit)
|
|
{
|
|
m_bEmit = bEmit;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : rate -
|
|
//-----------------------------------------------------------------------------
|
|
void C_DustTrail::SetSpawnRate(float rate)
|
|
{
|
|
m_SpawnRate = rate;
|
|
m_ParticleSpawn.Init(rate);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bnewentity -
|
|
//-----------------------------------------------------------------------------
|
|
void C_DustTrail::OnDataChanged(DataUpdateType_t updateType)
|
|
{
|
|
C_BaseEntity::OnDataChanged(updateType);
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
Start( ParticleMgr(), NULL );
|
|
}
|
|
}
|
|
|
|
|
|
// FIXME: These all have to be moved out of this old system and into the new to leverage art assets!
|
|
CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectDusttrail )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0001" )
|
|
/*
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0002" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0003" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0004" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0005" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0006" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0007" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0008" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0009" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0010" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0011" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0012" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0013" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0014" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0015" )
|
|
CLIENTEFFECT_MATERIAL( "particle/smokesprites_0016" )
|
|
*/
|
|
CLIENTEFFECT_REGISTER_END()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pParticleMgr -
|
|
// *pArgs -
|
|
//-----------------------------------------------------------------------------
|
|
void C_DustTrail::Start( CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs )
|
|
{
|
|
if(!pParticleMgr->AddEffect( &m_ParticleEffect, this ))
|
|
return;
|
|
|
|
m_pParticleMgr = pParticleMgr;
|
|
m_pDustEmitter = CDustFollower::Create("DustTrail");
|
|
|
|
if ( !m_pDustEmitter )
|
|
{
|
|
Assert( false );
|
|
return;
|
|
}
|
|
|
|
m_pDustEmitter->SetSortOrigin( GetAbsOrigin() );
|
|
m_pDustEmitter->SetNearClip( 64.0f, 128.0f );
|
|
|
|
for (int i = 0; i < DUSTTRAIL_MATERIALS; i++)
|
|
{
|
|
//char name[256];
|
|
//Q_snprintf( name, sizeof( name ), "particle/smokesprites_%04d", i + 1 );
|
|
m_MaterialHandle[i] = m_pDustEmitter->GetPMaterial( "particle/smokesprites_0001" );
|
|
}
|
|
|
|
m_ParticleSpawn.Init( m_SpawnRate );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : fTimeDelta -
|
|
//-----------------------------------------------------------------------------
|
|
void C_DustTrail::Update( float fTimeDelta )
|
|
{
|
|
if ( !m_pDustEmitter )
|
|
return;
|
|
|
|
Vector offsetColor;
|
|
|
|
// Add new particles
|
|
if ( !m_bEmit )
|
|
return;
|
|
|
|
if ( ( m_StopEmitTime != 0 ) && ( m_StopEmitTime <= gpGlobals->curtime ) )
|
|
return;
|
|
|
|
float tempDelta = fTimeDelta;
|
|
|
|
SimpleParticle *pParticle;
|
|
Vector offset;
|
|
|
|
Vector vecOrigin;
|
|
VectorMA( GetAbsOrigin(), -fTimeDelta, GetAbsVelocity(), vecOrigin );
|
|
|
|
Vector vecForward;
|
|
GetVectors( &vecForward, NULL, NULL );
|
|
|
|
while( m_ParticleSpawn.NextEvent( tempDelta ) )
|
|
{
|
|
float fldt = fTimeDelta - tempDelta;
|
|
|
|
offset.Random( -m_SpawnRadius, m_SpawnRadius );
|
|
offset += vecOrigin;
|
|
VectorMA( offset, fldt, GetAbsVelocity(), offset );
|
|
|
|
//if ( random->RandomFloat( 0.f, 5.0f ) > GetAbsVelocity().Length())
|
|
// continue;
|
|
|
|
pParticle = (SimpleParticle *) m_pDustEmitter->AddParticle( sizeof( SimpleParticle ), m_MaterialHandle[random->RandomInt(0,0)], offset ); // FIXME: the other sprites look bad
|
|
|
|
if ( pParticle == NULL )
|
|
continue;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = m_ParticleLifetime;
|
|
|
|
pParticle->m_vecVelocity.Random( -1.0f, 1.0f );
|
|
pParticle->m_vecVelocity *= random->RandomFloat( m_MinSpeed, m_MaxSpeed );
|
|
|
|
pParticle->m_vecVelocity = pParticle->m_vecVelocity + GetAbsVelocity();
|
|
|
|
float flDirectedVel = random->RandomFloat( m_MinDirectedSpeed, m_MaxDirectedSpeed );
|
|
VectorMA( pParticle->m_vecVelocity, flDirectedVel, vecForward, pParticle->m_vecVelocity );
|
|
|
|
offsetColor = m_Color;
|
|
float flMaxVal = MAX( m_Color[0], m_Color[1] );
|
|
if ( flMaxVal < m_Color[2] )
|
|
{
|
|
flMaxVal = m_Color[2];
|
|
}
|
|
offsetColor /= flMaxVal;
|
|
|
|
offsetColor *= random->RandomFloat( -0.2f, 0.2f );
|
|
offsetColor += m_Color;
|
|
|
|
offsetColor[0] = clamp( offsetColor[0], 0.0f, 1.0f );
|
|
offsetColor[1] = clamp( offsetColor[1], 0.0f, 1.0f );
|
|
offsetColor[2] = clamp( offsetColor[2], 0.0f, 1.0f );
|
|
|
|
pParticle->m_uchColor[0] = offsetColor[0]*255.0f;
|
|
pParticle->m_uchColor[1] = offsetColor[1]*255.0f;
|
|
pParticle->m_uchColor[2] = offsetColor[2]*255.0f;
|
|
|
|
pParticle->m_uchStartSize = m_StartSize;
|
|
pParticle->m_uchEndSize = m_EndSize;
|
|
|
|
float alpha = random->RandomFloat( m_Opacity*0.75f, m_Opacity*1.25f );
|
|
alpha = clamp( alpha, 0.0f, 1.0f );
|
|
|
|
if ( m_StopEmitTime != 0 && m_StopEmitTime > m_StartEmitTime )
|
|
{
|
|
alpha *= sqrt( (m_StopEmitTime - gpGlobals->curtime) /(m_StopEmitTime - m_StartEmitTime) );
|
|
}
|
|
|
|
pParticle->m_uchStartAlpha = alpha * 255;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -1.0f, 1.0f );
|
|
}
|
|
}
|
|
|
|
|
|
void C_DustTrail::RenderParticles( CParticleRenderIterator *pIterator )
|
|
{
|
|
}
|
|
|
|
|
|
void C_DustTrail::SimulateParticles( CParticleSimulateIterator *pIterator )
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is called after sending this entity's recording state
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void C_DustTrail::CleanupToolRecordingState( KeyValues *msg )
|
|
{
|
|
if ( !ToolsEnabled() )
|
|
return;
|
|
|
|
BaseClass::CleanupToolRecordingState( msg );
|
|
|
|
// Generally, this is used to allow the entity to clean up
|
|
// allocated state it put into the message, but here we're going
|
|
// to use it to send particle system messages because we
|
|
// know the grenade has been recorded at this point
|
|
if ( !clienttools->IsInRecordingMode() || !m_pDustEmitter.IsValid() )
|
|
return;
|
|
|
|
// For now, we can't record Dusttrails that don't have a moveparent
|
|
C_BaseEntity *pEnt = GetMoveParent();
|
|
if ( !pEnt )
|
|
return;
|
|
|
|
bool bEmitterActive = m_bEmit && ( ( m_StopEmitTime == 0 ) || ( m_StopEmitTime > gpGlobals->curtime ) );
|
|
|
|
// NOTE: Particle system destruction message will be sent by the particle effect itself.
|
|
if ( m_pDustEmitter->GetToolParticleEffectId() == TOOLPARTICLESYSTEMID_INVALID )
|
|
{
|
|
int nId = m_pDustEmitter->AllocateToolParticleEffectId();
|
|
|
|
KeyValues *oldmsg = new KeyValues( "OldParticleSystem_Create" );
|
|
oldmsg->SetString( "name", "C_DustTrail" );
|
|
oldmsg->SetInt( "id", nId );
|
|
oldmsg->SetFloat( "time", gpGlobals->curtime );
|
|
|
|
KeyValues *pEmitter = oldmsg->FindKey( "DmeSpriteEmitter", true );
|
|
pEmitter->SetString( "material", "particle/smokesprites_0001" );
|
|
pEmitter->SetInt( "count", m_SpawnRate ); // particles per second, when duration is < 0
|
|
pEmitter->SetFloat( "duration", -1 ); // FIXME
|
|
pEmitter->SetInt( "active", bEmitterActive );
|
|
|
|
KeyValues *pInitializers = pEmitter->FindKey( "initializers", true );
|
|
|
|
// FIXME: Until we can interpolate ent logs during emission, this can't work
|
|
KeyValues *pPosition = pInitializers->FindKey( "DmePositionPointToEntityInitializer", true );
|
|
pPosition->SetPtr( "entindex", (void*)pEnt->entindex() );
|
|
pPosition->SetInt( "attachmentIndex", GetParentAttachment() );
|
|
pPosition->SetFloat( "randomDist", m_SpawnRadius );
|
|
pPosition->SetFloat( "startx", pEnt->GetAbsOrigin().x );
|
|
pPosition->SetFloat( "starty", pEnt->GetAbsOrigin().y );
|
|
pPosition->SetFloat( "startz", pEnt->GetAbsOrigin().z );
|
|
|
|
KeyValues *pVelocity = pInitializers->FindKey( "DmeDecayVelocityInitializer", true );
|
|
pVelocity->SetFloat( "velocityX", pEnt->GetAbsVelocity().x );
|
|
pVelocity->SetFloat( "velocityY", pEnt->GetAbsVelocity().y );
|
|
pVelocity->SetFloat( "velocityZ", pEnt->GetAbsVelocity().z );
|
|
pVelocity->SetFloat( "decayto", 0.5 );
|
|
pVelocity->SetFloat( "decaytime", 0.3 );
|
|
|
|
KeyValues *pLifetime = pInitializers->FindKey( "DmeRandomLifetimeInitializer", true );
|
|
pLifetime->SetFloat( "minLifetime", m_ParticleLifetime );
|
|
pLifetime->SetFloat( "maxLifetime", m_ParticleLifetime );
|
|
|
|
KeyValues *pRoll = pInitializers->FindKey( "DmeRandomRollInitializer", true );
|
|
pRoll->SetFloat( "minRoll", 0.0f );
|
|
pRoll->SetFloat( "maxRoll", 360.0f );
|
|
|
|
KeyValues *pRollSpeed = pInitializers->FindKey( "DmeRandomRollSpeedInitializer", true );
|
|
pRollSpeed->SetFloat( "minRollSpeed", -1.0f );
|
|
pRollSpeed->SetFloat( "maxRollSpeed", 1.0f );
|
|
|
|
KeyValues *pColor = pInitializers->FindKey( "DmeRandomValueColorInitializer", true );
|
|
Color c(
|
|
FastFToC( clamp( m_Color.x, 0.f, 1.f ) ),
|
|
FastFToC( clamp( m_Color.y, 0.f, 1.f ) ),
|
|
FastFToC( clamp( m_Color.z, 0.f, 1.f ) ),
|
|
255 );
|
|
pColor->SetColor( "startColor", c );
|
|
pColor->SetFloat( "minStartValueDelta", 0.0f );
|
|
pColor->SetFloat( "maxStartValueDelta", 0.0f );
|
|
pColor->SetColor( "endColor", c );
|
|
|
|
KeyValues *pAlpha = pInitializers->FindKey( "DmeRandomAlphaInitializer", true );
|
|
int nMinAlpha = 255 * m_Opacity * 0.75f;
|
|
int nMaxAlpha = 255 * m_Opacity * 1.25f;
|
|
pAlpha->SetInt( "minStartAlpha", clamp( nMinAlpha, 0, 255 ) );
|
|
pAlpha->SetInt( "maxStartAlpha", clamp( nMaxAlpha, 0, 255 ) );
|
|
pAlpha->SetInt( "minEndAlpha", clamp( nMinAlpha, 0, 255 ) );
|
|
pAlpha->SetInt( "maxEndAlpha", clamp( nMaxAlpha, 0, 255 ) );
|
|
|
|
KeyValues *pSize = pInitializers->FindKey( "DmeRandomSizeInitializer", true );
|
|
pSize->SetFloat( "minStartSize", m_StartSize );
|
|
pSize->SetFloat( "maxStartSize", m_StartSize );
|
|
pSize->SetFloat( "minEndSize", m_EndSize );
|
|
pSize->SetFloat( "maxEndSize", m_EndSize );
|
|
|
|
KeyValues *pUpdaters = pEmitter->FindKey( "updaters", true );
|
|
pUpdaters->FindKey( "DmePositionVelocityDecayUpdater", true );
|
|
pUpdaters->FindKey( "DmeRollUpdater", true );
|
|
|
|
KeyValues *pRollSpeedUpdater = pUpdaters->FindKey( "DmeRollSpeedAttenuateUpdater", true );
|
|
pRollSpeedUpdater->SetFloat( "attenuation", 1.0f - 8.0f / 30.0f );
|
|
pRollSpeedUpdater->SetFloat( "attenuationTme", 1.0f / 30.0f );
|
|
pRollSpeedUpdater->SetFloat( "minRollSpeed", 0.5f );
|
|
|
|
pUpdaters->FindKey( "DmeAlphaSineRampUpdater", true );
|
|
pUpdaters->FindKey( "DmeColorUpdater", true );
|
|
pUpdaters->FindKey( "DmeSizeUpdater", true );
|
|
|
|
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, oldmsg );
|
|
oldmsg->deleteThis();
|
|
}
|
|
else
|
|
{
|
|
KeyValues *oldmsg = new KeyValues( "OldParticleSystem_ActivateEmitter" );
|
|
oldmsg->SetInt( "id", m_pDustEmitter->GetToolParticleEffectId() );
|
|
oldmsg->SetInt( "emitter", 0 );
|
|
oldmsg->SetInt( "active", bEmitterActive );
|
|
oldmsg->SetFloat( "time", gpGlobals->curtime );
|
|
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, oldmsg );
|
|
oldmsg->deleteThis();
|
|
}
|
|
}
|