1538 lines
46 KiB
C++
1538 lines
46 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "view.h"
|
|
#include "viewrender.h"
|
|
#include "c_tracer.h"
|
|
#include "dlight.h"
|
|
#include "clienteffectprecachesystem.h"
|
|
#include "fx_sparks.h"
|
|
#include "iefx.h"
|
|
#include "c_te_effect_dispatch.h"
|
|
#include "tier0/vprof.h"
|
|
#include "fx_quad.h"
|
|
#include "fx.h"
|
|
#include "c_pixel_visibility.h"
|
|
#include "particles_ez.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//Precahce the effects
|
|
CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectSparks )
|
|
CLIENTEFFECT_MATERIAL( "effects/spark" )
|
|
CLIENTEFFECT_MATERIAL( "effects/energysplash" )
|
|
CLIENTEFFECT_MATERIAL( "effects/energyball" )
|
|
CLIENTEFFECT_MATERIAL( "sprites/rico1" )
|
|
CLIENTEFFECT_MATERIAL( "sprites/rico1_noz" )
|
|
CLIENTEFFECT_MATERIAL( "sprites/blueflare1" )
|
|
CLIENTEFFECT_MATERIAL( "effects/yellowflare" )
|
|
CLIENTEFFECT_MATERIAL( "effects/combinemuzzle1_nocull" )
|
|
CLIENTEFFECT_MATERIAL( "effects/combinemuzzle2_nocull" )
|
|
CLIENTEFFECT_MATERIAL( "effects/yellowflare_noz" )
|
|
CLIENTEFFECT_REGISTER_END()
|
|
|
|
PMaterialHandle g_Material_Spark = NULL;
|
|
|
|
static ConVar fx_drawmetalspark( "fx_drawmetalspark", "1", FCVAR_DEVELOPMENTONLY, "Draw metal spark effects." );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &pos -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool EffectOccluded( const Vector &pos, pixelvis_handle_t *queryHandle )
|
|
{
|
|
if ( !queryHandle )
|
|
{
|
|
// NOTE: This is called by networking code before the current view is set up.
|
|
// so use the main view instead
|
|
trace_t tr;
|
|
UTIL_TraceLine( pos, MainViewOrigin(), MASK_OPAQUE, NULL, COLLISION_GROUP_NONE, &tr );
|
|
|
|
return ( tr.fraction < 1.0f ) ? true : false;
|
|
}
|
|
pixelvis_queryparams_t params;
|
|
params.Init(pos);
|
|
|
|
return PixelVisibility_FractionVisible( params, queryHandle ) > 0.0f ? false : true;
|
|
}
|
|
|
|
|
|
CSimpleGlowEmitter::CSimpleGlowEmitter( const char *pDebugName, const Vector &sortOrigin, float flDeathTime )
|
|
: CSimpleEmitter( pDebugName )
|
|
{
|
|
SetSortOrigin( sortOrigin );
|
|
m_queryHandle = 0;
|
|
m_wasTested = 0;
|
|
m_isVisible = 0;
|
|
m_startTime = gpGlobals->curtime;
|
|
m_flDeathTime = flDeathTime;
|
|
}
|
|
|
|
CSimpleGlowEmitter *CSimpleGlowEmitter::Create( const char *pDebugName, const Vector &sortOrigin, float flDeathTime )
|
|
{
|
|
return new CSimpleGlowEmitter( pDebugName, sortOrigin, flDeathTime );
|
|
}
|
|
|
|
|
|
void CSimpleGlowEmitter::SimulateParticles( CParticleSimulateIterator *pIterator )
|
|
{
|
|
if ( gpGlobals->curtime > m_flDeathTime )
|
|
{
|
|
pIterator->RemoveAllParticles();
|
|
return;
|
|
}
|
|
|
|
if ( !WasTestedInView(1<<0) )
|
|
return;
|
|
|
|
BaseClass::SimulateParticles( pIterator );
|
|
}
|
|
|
|
bool CSimpleGlowEmitter::WasTestedInView( unsigned char viewMask )
|
|
{
|
|
return (m_wasTested & viewMask) ? true : false;
|
|
}
|
|
|
|
bool CSimpleGlowEmitter::IsVisibleInView( unsigned char viewMask )
|
|
{
|
|
return (m_isVisible & viewMask) ? true : false;
|
|
}
|
|
|
|
void CSimpleGlowEmitter::SetTestedInView( unsigned char viewMask, bool bTested )
|
|
{
|
|
m_wasTested &= ~viewMask;
|
|
if ( bTested )
|
|
{
|
|
m_wasTested |= viewMask;
|
|
}
|
|
}
|
|
|
|
void CSimpleGlowEmitter::SetVisibleInView( unsigned char viewMask, bool bVisible )
|
|
{
|
|
m_isVisible &= ~viewMask;
|
|
if ( bVisible )
|
|
{
|
|
m_isVisible |= viewMask;
|
|
}
|
|
}
|
|
|
|
unsigned char CSimpleGlowEmitter::CurrentViewMask() const
|
|
{
|
|
int viewId = (int)CurrentViewID();
|
|
viewId = clamp(viewId, 0, 7);
|
|
return 1<<viewId;
|
|
}
|
|
|
|
void CSimpleGlowEmitter::RenderParticles( CParticleRenderIterator *pIterator )
|
|
{
|
|
unsigned char viewMask = CurrentViewMask();
|
|
if ( !WasTestedInView(CurrentViewMask()) )
|
|
{
|
|
pixelvis_queryparams_t params;
|
|
params.Init(GetSortOrigin());
|
|
|
|
float visible = PixelVisibility_FractionVisible( params, &m_queryHandle );
|
|
if ( visible == 0.0f )
|
|
{
|
|
if ( (gpGlobals->curtime - m_startTime) <= 0.1f )
|
|
return;
|
|
SetVisibleInView(viewMask, false);
|
|
}
|
|
else
|
|
{
|
|
SetVisibleInView(viewMask, true);
|
|
}
|
|
|
|
SetTestedInView(viewMask, true);
|
|
}
|
|
if ( !IsVisibleInView(viewMask) )
|
|
return;
|
|
|
|
BaseClass::RenderParticles( pIterator );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CTrailParticles::CTrailParticles( const char *pDebugName ) : CSimpleEmitter( pDebugName )
|
|
{
|
|
m_fFlags = 0;
|
|
m_flVelocityDampen = 0.0f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Test for surrounding collision surfaces for quick collision testing for the particle system
|
|
// Input : &origin - starting position
|
|
// *dir - direction of movement (if NULL, will do a point emission test in four directions)
|
|
// angularSpread - looseness of the spread
|
|
// minSpeed - minimum speed
|
|
// maxSpeed - maximum speed
|
|
// gravity - particle gravity for the sytem
|
|
// dampen - dampening amount on collisions
|
|
// flags - extra information
|
|
//-----------------------------------------------------------------------------
|
|
void CTrailParticles::Setup( const Vector &origin, const Vector *direction, float angularSpread, float minSpeed, float maxSpeed, float gravity, float dampen, int flags, bool bNotCollideable )
|
|
{
|
|
//Take the flags
|
|
if ( !bNotCollideable )
|
|
{
|
|
SetFlag( (flags|bitsPARTICLE_TRAIL_COLLIDE) ); //Force this if they've called this function
|
|
}
|
|
else
|
|
{
|
|
SetFlag( flags );
|
|
}
|
|
|
|
//See if we've specified a direction
|
|
m_ParticleCollision.Setup( origin, direction, angularSpread, minSpeed, maxSpeed, gravity, dampen );
|
|
}
|
|
|
|
|
|
void CTrailParticles::RenderParticles( CParticleRenderIterator *pIterator )
|
|
{
|
|
const TrailParticle *pParticle = (const TrailParticle*)pIterator->GetFirst();
|
|
while ( pParticle )
|
|
{
|
|
//Get our remaining time
|
|
float lifePerc = 1.0f - ( pParticle->m_flLifetime / pParticle->m_flDieTime );
|
|
float scale = (pParticle->m_flLength*lifePerc);
|
|
|
|
if ( scale < 0.01f )
|
|
scale = 0.01f;
|
|
|
|
Vector start, delta;
|
|
|
|
//NOTE: We need to do everything in screen space
|
|
TransformParticle( ParticleMgr()->GetModelView(), pParticle->m_Pos, start );
|
|
float sortKey = start.z;
|
|
|
|
Vector3DMultiply( ParticleMgr()->GetModelView(), pParticle->m_vecVelocity, delta );
|
|
|
|
float color[4];
|
|
float ramp = 1.0;
|
|
|
|
// Fade in for the first few frames
|
|
if ( pParticle->m_flLifetime <= 0.3 && m_fFlags & bitsPARTICLE_TRAIL_FADE_IN )
|
|
{
|
|
ramp = pParticle->m_flLifetime;
|
|
}
|
|
else if ( m_fFlags & bitsPARTICLE_TRAIL_FADE )
|
|
{
|
|
ramp = ( 1.0f - ( pParticle->m_flLifetime / pParticle->m_flDieTime ) );
|
|
}
|
|
|
|
color[0] = pParticle->m_color.r * ramp * (1.0f / 255.0f);
|
|
color[1] = pParticle->m_color.g * ramp * (1.0f / 255.0f);
|
|
color[2] = pParticle->m_color.b * ramp * (1.0f / 255.0f);
|
|
color[3] = pParticle->m_color.a * ramp * (1.0f / 255.0f);
|
|
|
|
float flLength = (pParticle->m_vecVelocity * scale).Length();//( delta - pos ).Length();
|
|
float flWidth = ( flLength < pParticle->m_flWidth ) ? flLength : pParticle->m_flWidth;
|
|
|
|
//See if we should fade
|
|
Vector vecScaledDelta = (delta*scale);
|
|
Tracer_Draw( pIterator->GetParticleDraw(), start, vecScaledDelta, flWidth, color );
|
|
|
|
pParticle = (const TrailParticle*)pIterator->GetNext( sortKey );
|
|
}
|
|
}
|
|
|
|
|
|
void CTrailParticles::SimulateParticles( CParticleSimulateIterator *pIterator )
|
|
{
|
|
//Turn off collision if we're not told to do it
|
|
if (( m_fFlags & bitsPARTICLE_TRAIL_COLLIDE )==false)
|
|
{
|
|
m_ParticleCollision.ClearActivePlanes();
|
|
}
|
|
|
|
TrailParticle *pParticle = (TrailParticle*)pIterator->GetFirst();
|
|
while ( pParticle )
|
|
{
|
|
const float timeDelta = pIterator->GetTimeDelta();
|
|
|
|
//Simulate the movement with collision
|
|
trace_t trace;
|
|
m_ParticleCollision.MoveParticle( pParticle->m_Pos, pParticle->m_vecVelocity, NULL, timeDelta, &trace );
|
|
|
|
//Laterally dampen if asked to do so
|
|
if ( m_fFlags & bitsPARTICLE_TRAIL_VELOCITY_DAMPEN )
|
|
{
|
|
float attenuation = 1.0f - (timeDelta * m_flVelocityDampen);
|
|
|
|
if ( attenuation < 0.0f )
|
|
attenuation = 0.0f;
|
|
|
|
//Laterally dampen
|
|
pParticle->m_vecVelocity[0] *= attenuation;
|
|
pParticle->m_vecVelocity[1] *= attenuation;
|
|
pParticle->m_vecVelocity[2] *= attenuation;
|
|
}
|
|
|
|
//Should this particle die?
|
|
pParticle->m_flLifetime += timeDelta;
|
|
|
|
if ( pParticle->m_flLifetime >= pParticle->m_flDieTime )
|
|
pIterator->RemoveParticle( pParticle );
|
|
|
|
pParticle = (TrailParticle*)pIterator->GetNext();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Electric spark
|
|
// Input : &pos - origin point of effect
|
|
//-----------------------------------------------------------------------------
|
|
#define SPARK_ELECTRIC_SPREAD 0.0f
|
|
#define SPARK_ELECTRIC_MINSPEED 64.0f
|
|
#define SPARK_ELECTRIC_MAXSPEED 300.0f
|
|
#define SPARK_ELECTRIC_GRAVITY 800.0f
|
|
#define SPARK_ELECTRIC_DAMPEN 0.3f
|
|
|
|
void FX_ElectricSpark( const Vector &pos, int nMagnitude, int nTrailLength, const Vector *vecDir )
|
|
{
|
|
VPROF_BUDGET( "FX_ElectricSpark", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
CSmartPtr<CTrailParticles> pSparkEmitter = CTrailParticles::Create( "FX_ElectricSpark 1" );
|
|
|
|
if ( !pSparkEmitter )
|
|
{
|
|
Assert(0);
|
|
return;
|
|
}
|
|
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = pSparkEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
//Setup our collision information
|
|
pSparkEmitter->Setup( (Vector &) pos,
|
|
NULL,
|
|
SPARK_ELECTRIC_SPREAD,
|
|
SPARK_ELECTRIC_MINSPEED,
|
|
SPARK_ELECTRIC_MAXSPEED,
|
|
SPARK_ELECTRIC_GRAVITY,
|
|
SPARK_ELECTRIC_DAMPEN,
|
|
bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
pSparkEmitter->SetSortOrigin( pos );
|
|
|
|
//
|
|
// Big sparks.
|
|
//
|
|
Vector dir;
|
|
int numSparks = nMagnitude * nMagnitude * random->RandomFloat( 2, 4 );
|
|
|
|
int i;
|
|
TrailParticle *pParticle;
|
|
for ( i = 0; i < numSparks; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) pSparkEmitter->AddParticle( sizeof(TrailParticle), g_Material_Spark, pos );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = nMagnitude * random->RandomFloat( 1.0f, 2.0f );
|
|
|
|
dir.Random( -1.0f, 1.0f );
|
|
dir[2] = random->RandomFloat( 0.5f, 1.0f );
|
|
|
|
if ( vecDir )
|
|
{
|
|
dir += 2 * (*vecDir);
|
|
VectorNormalize( dir );
|
|
}
|
|
|
|
pParticle->m_flWidth = random->RandomFloat( 2.0f, 5.0f );
|
|
pParticle->m_flLength = nTrailLength * random->RandomFloat( 0.02, 0.05f );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( SPARK_ELECTRIC_MINSPEED, SPARK_ELECTRIC_MAXSPEED );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
|
|
#ifdef _XBOX
|
|
|
|
//
|
|
// Cap
|
|
//
|
|
|
|
SimpleParticle sParticle;
|
|
|
|
sParticle.m_Pos = pos;
|
|
sParticle.m_flLifetime = 0.0f;
|
|
sParticle.m_flDieTime = 0.2f;
|
|
|
|
sParticle.m_vecVelocity.Init();
|
|
|
|
sParticle.m_uchColor[0] = 255;
|
|
sParticle.m_uchColor[1] = 255;
|
|
sParticle.m_uchColor[2] = 255;
|
|
sParticle.m_uchStartAlpha = 255;
|
|
sParticle.m_uchEndAlpha = 255;
|
|
sParticle.m_uchStartSize = nMagnitude * random->RandomInt( 4, 8 );
|
|
sParticle.m_uchEndSize = 0;
|
|
sParticle.m_flRoll = random->RandomInt( 0, 360 );
|
|
sParticle.m_flRollDelta = 0.0f;
|
|
|
|
AddSimpleParticle( &sParticle, ParticleMgr()->GetPMaterial( "effects/yellowflare" ) );
|
|
|
|
#else
|
|
|
|
//
|
|
// Little sparks
|
|
//
|
|
|
|
CSmartPtr<CTrailParticles> pSparkEmitter2 = CTrailParticles::Create( "FX_ElectricSpark 2" );
|
|
|
|
if ( !pSparkEmitter2 )
|
|
{
|
|
Assert(0);
|
|
return;
|
|
}
|
|
|
|
pSparkEmitter2->SetSortOrigin( pos );
|
|
|
|
pSparkEmitter2->m_ParticleCollision.SetGravity( 400.0f );
|
|
pSparkEmitter2->SetFlag( bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
numSparks = nMagnitude * random->RandomInt( 16, 32 );
|
|
|
|
// Dump out sparks
|
|
for ( i = 0; i < numSparks; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) pSparkEmitter2->AddParticle( sizeof(TrailParticle), g_Material_Spark, pos );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
|
|
dir.Random( -1.0f, 1.0f );
|
|
if ( vecDir )
|
|
{
|
|
dir += *vecDir;
|
|
VectorNormalize( dir );
|
|
}
|
|
|
|
pParticle->m_flWidth = random->RandomFloat( 2.0f, 4.0f );
|
|
pParticle->m_flLength = nTrailLength * random->RandomFloat( 0.02f, 0.03f );
|
|
pParticle->m_flDieTime = nMagnitude * random->RandomFloat( 0.1f, 0.2f );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( 128, 256 );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
|
|
//
|
|
// Caps
|
|
//
|
|
CSmartPtr<CSimpleGlowEmitter> pSimple = CSimpleGlowEmitter::Create( "FX_ElectricSpark 3", pos, gpGlobals->curtime + 0.2 );
|
|
|
|
// NOTE: None of these will render unless the effect is visible!
|
|
//
|
|
// Inner glow
|
|
//
|
|
SimpleParticle *sParticle;
|
|
|
|
sParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/yellowflare_noz" ), pos );
|
|
|
|
if ( sParticle == NULL )
|
|
return;
|
|
|
|
sParticle->m_flLifetime = 0.0f;
|
|
sParticle->m_flDieTime = 0.2f;
|
|
|
|
sParticle->m_vecVelocity.Init();
|
|
|
|
sParticle->m_uchColor[0] = 255;
|
|
sParticle->m_uchColor[1] = 255;
|
|
sParticle->m_uchColor[2] = 255;
|
|
sParticle->m_uchStartAlpha = 255;
|
|
sParticle->m_uchEndAlpha = 255;
|
|
sParticle->m_uchStartSize = nMagnitude * random->RandomInt( 4, 8 );
|
|
sParticle->m_uchEndSize = 0;
|
|
sParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
sParticle->m_flRollDelta = 0.0f;
|
|
|
|
sParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/yellowflare_noz" ), pos );
|
|
|
|
if ( sParticle == NULL )
|
|
return;
|
|
|
|
sParticle->m_flLifetime = 0.0f;
|
|
sParticle->m_flDieTime = 0.2f;
|
|
|
|
sParticle->m_vecVelocity.Init();
|
|
|
|
float fColor = random->RandomInt( 32, 64 );
|
|
sParticle->m_uchColor[0] = fColor;
|
|
sParticle->m_uchColor[1] = fColor;
|
|
sParticle->m_uchColor[2] = fColor;
|
|
sParticle->m_uchStartAlpha = fColor;
|
|
sParticle->m_uchEndAlpha = 0;
|
|
sParticle->m_uchStartSize = nMagnitude * random->RandomInt( 32, 64 );
|
|
sParticle->m_uchEndSize = 0;
|
|
sParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
sParticle->m_flRollDelta = random->RandomFloat( -1.0f, 1.0f );
|
|
|
|
//
|
|
// Smoke
|
|
//
|
|
Vector sOffs;
|
|
|
|
sOffs[0] = pos[0] + random->RandomFloat( -4.0f, 4.0f );
|
|
sOffs[1] = pos[1] + random->RandomFloat( -4.0f, 4.0f );
|
|
sOffs[2] = pos[2];
|
|
|
|
sParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), g_Mat_DustPuff[1], sOffs );
|
|
|
|
if ( sParticle == NULL )
|
|
return;
|
|
|
|
sParticle->m_flLifetime = 0.0f;
|
|
sParticle->m_flDieTime = 1.0f;
|
|
|
|
sParticle->m_vecVelocity.Init();
|
|
|
|
sParticle->m_vecVelocity[2] = 16.0f;
|
|
|
|
sParticle->m_vecVelocity[0] = random->RandomFloat( -16.0f, 16.0f );
|
|
sParticle->m_vecVelocity[1] = random->RandomFloat( -16.0f, 16.0f );
|
|
|
|
sParticle->m_uchColor[0] = 255;
|
|
sParticle->m_uchColor[1] = 255;
|
|
sParticle->m_uchColor[2] = 200;
|
|
sParticle->m_uchStartAlpha = random->RandomInt( 16, 32 );
|
|
sParticle->m_uchEndAlpha = 0;
|
|
sParticle->m_uchStartSize = random->RandomInt( 4, 8 );
|
|
sParticle->m_uchEndSize = sParticle->m_uchStartSize*4.0f;
|
|
sParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
sParticle->m_flRollDelta = random->RandomFloat( -2.0f, 2.0f );
|
|
|
|
//
|
|
// Dlight
|
|
//
|
|
|
|
/*
|
|
dlight_t *dl= effects->CL_AllocDlight ( 0 );
|
|
|
|
dl->origin = pos;
|
|
dl->color.r = dl->color.g = dl->color.b = 250;
|
|
dl->radius = random->RandomFloat(16,32);
|
|
dl->die = gpGlobals->curtime + 0.001;
|
|
*/
|
|
|
|
#endif // !_XBOX
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sparks created by scraping metal
|
|
// Input : &position - start
|
|
// &normal - direction of spark travel
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define METAL_SCRAPE_MINSPEED 128.0f
|
|
#define METAL_SCRAPE_MAXSPEED 512.0f
|
|
#define METAL_SCRAPE_SPREAD 0.3f
|
|
#define METAL_SCRAPE_GRAVITY 800.0f
|
|
#define METAL_SCRAPE_DAMPEN 0.4f
|
|
|
|
void FX_MetalScrape( Vector &position, Vector &normal )
|
|
{
|
|
VPROF_BUDGET( "FX_MetalScrape", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
Vector offset = position + ( normal * 1.0f );
|
|
|
|
CSmartPtr<CTrailParticles> sparkEmitter = CTrailParticles::Create( "FX_MetalScrape 1" );
|
|
|
|
if ( !sparkEmitter )
|
|
return;
|
|
|
|
sparkEmitter->SetSortOrigin( offset );
|
|
|
|
//Setup our collision information
|
|
sparkEmitter->Setup( offset,
|
|
&normal,
|
|
METAL_SCRAPE_SPREAD,
|
|
METAL_SCRAPE_MINSPEED,
|
|
METAL_SCRAPE_MAXSPEED,
|
|
METAL_SCRAPE_GRAVITY,
|
|
METAL_SCRAPE_DAMPEN,
|
|
bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
int numSparks = random->RandomInt( 4, 8 );
|
|
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = sparkEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
Vector dir;
|
|
TrailParticle *pParticle;
|
|
float length = 0.06f;
|
|
|
|
//Dump out sparks
|
|
for ( int i = 0; i < numSparks; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) sparkEmitter->AddParticle( sizeof(TrailParticle), g_Material_Spark, offset );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
|
|
float spreadOfs = random->RandomFloat( 0.0f, 2.0f );
|
|
|
|
dir[0] = normal[0] + random->RandomFloat( -(METAL_SCRAPE_SPREAD*spreadOfs), (METAL_SCRAPE_SPREAD*spreadOfs) );
|
|
dir[1] = normal[1] + random->RandomFloat( -(METAL_SCRAPE_SPREAD*spreadOfs), (METAL_SCRAPE_SPREAD*spreadOfs) );
|
|
dir[2] = normal[2] + random->RandomFloat( -(METAL_SCRAPE_SPREAD*spreadOfs), (METAL_SCRAPE_SPREAD*spreadOfs) );
|
|
|
|
pParticle->m_flWidth = random->RandomFloat( 2.0f, 5.0f );
|
|
pParticle->m_flLength = random->RandomFloat( length*0.25f, length );
|
|
pParticle->m_flDieTime = random->RandomFloat( 2.0f, 2.0f );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( (METAL_SCRAPE_MINSPEED*(2.0f-spreadOfs)), (METAL_SCRAPE_MAXSPEED*(2.0f-spreadOfs)) );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Ricochet spark on metal
|
|
// Input : &position - origin of effect
|
|
// &normal - normal of the surface struck
|
|
//-----------------------------------------------------------------------------
|
|
#define METAL_SPARK_SPREAD 0.5f
|
|
#define METAL_SPARK_MINSPEED 128.0f
|
|
#define METAL_SPARK_MAXSPEED 512.0f
|
|
#define METAL_SPARK_GRAVITY 400.0f
|
|
#define METAL_SPARK_DAMPEN 0.25f
|
|
|
|
void FX_MetalSpark( const Vector &position, const Vector &direction, const Vector &surfaceNormal, int iScale )
|
|
{
|
|
VPROF_BUDGET( "FX_MetalSpark", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
|
|
if ( !fx_drawmetalspark.GetBool() )
|
|
return;
|
|
|
|
//
|
|
// Emitted particles
|
|
//
|
|
|
|
Vector offset = position + ( surfaceNormal * 1.0f );
|
|
|
|
CSmartPtr<CTrailParticles> sparkEmitter = CTrailParticles::Create( "FX_MetalSpark 1" );
|
|
|
|
if ( sparkEmitter == NULL )
|
|
return;
|
|
|
|
//Setup our information
|
|
sparkEmitter->SetSortOrigin( offset );
|
|
sparkEmitter->SetFlag( bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
sparkEmitter->SetVelocityDampen( 8.0f );
|
|
sparkEmitter->SetGravity( METAL_SPARK_GRAVITY );
|
|
sparkEmitter->SetCollisionDamped( METAL_SPARK_DAMPEN );
|
|
sparkEmitter->GetBinding().SetBBox( offset - Vector( 32, 32, 32 ), offset + Vector( 32, 32, 32 ) );
|
|
|
|
int numSparks = random->RandomInt( 4, 8 ) * ( iScale * 2 );
|
|
numSparks = (int)( 0.5f + (float)numSparks * g_pParticleSystemMgr->ParticleThrottleScaling() );
|
|
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = sparkEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
TrailParticle *pParticle;
|
|
Vector dir;
|
|
float length = 0.1f;
|
|
|
|
//Dump out sparks
|
|
for ( int i = 0; i < numSparks; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) sparkEmitter->AddParticle( sizeof(TrailParticle), g_Material_Spark, offset );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
|
|
if( iScale > 1 && i%3 == 0 )
|
|
{
|
|
// Every third spark goes flying far if we're having a big batch of sparks.
|
|
pParticle->m_flDieTime = random->RandomFloat( 0.15f, 0.25f );
|
|
}
|
|
else
|
|
{
|
|
pParticle->m_flDieTime = random->RandomFloat( 0.05f, 0.1f );
|
|
}
|
|
|
|
float spreadOfs = random->RandomFloat( 0.0f, 2.0f );
|
|
|
|
dir[0] = direction[0] + random->RandomFloat( -(METAL_SPARK_SPREAD*spreadOfs), (METAL_SPARK_SPREAD*spreadOfs) );
|
|
dir[1] = direction[1] + random->RandomFloat( -(METAL_SPARK_SPREAD*spreadOfs), (METAL_SPARK_SPREAD*spreadOfs) );
|
|
dir[2] = direction[2] + random->RandomFloat( -(METAL_SPARK_SPREAD*spreadOfs), (METAL_SPARK_SPREAD*spreadOfs) );
|
|
|
|
VectorNormalize( dir );
|
|
|
|
pParticle->m_flWidth = random->RandomFloat( 1.0f, 4.0f );
|
|
pParticle->m_flLength = random->RandomFloat( length*0.25f, length );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( (METAL_SPARK_MINSPEED*(2.0f-spreadOfs)), (METAL_SPARK_MAXSPEED*(2.0f-spreadOfs)) );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
|
|
//
|
|
// Impact point glow
|
|
//
|
|
|
|
FXQuadData_t data;
|
|
|
|
data.SetMaterial( "effects/yellowflare" );
|
|
data.SetColor( 1.0f, 1.0f, 1.0f );
|
|
data.SetOrigin( offset );
|
|
data.SetNormal( surfaceNormal );
|
|
data.SetAlpha( 1.0f, 0.0f );
|
|
data.SetLifeTime( 0.1f );
|
|
data.SetYaw( random->RandomInt( 0, 360 ) );
|
|
|
|
int scale = random->RandomInt( 24, 28 );
|
|
data.SetScale( scale, 0 );
|
|
|
|
FX_AddQuad( data );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Spark effect. Nothing but sparks.
|
|
// Input : &pos - origin point of effect
|
|
//-----------------------------------------------------------------------------
|
|
#define SPARK_SPREAD 3.0f
|
|
#define SPARK_GRAVITY 800.0f
|
|
#define SPARK_DAMPEN 0.3f
|
|
|
|
void FX_Sparks( const Vector &pos, int nMagnitude, int nTrailLength, const Vector &vecDir, float flWidth, float flMinSpeed, float flMaxSpeed, char *pSparkMaterial )
|
|
{
|
|
VPROF_BUDGET( "FX_Sparks", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
CSmartPtr<CTrailParticles> pSparkEmitter = CTrailParticles::Create( "FX_Sparks 1" );
|
|
|
|
if ( !pSparkEmitter )
|
|
{
|
|
Assert(0);
|
|
return;
|
|
}
|
|
|
|
PMaterialHandle hMaterial;
|
|
if ( pSparkMaterial )
|
|
{
|
|
hMaterial = pSparkEmitter->GetPMaterial( pSparkMaterial );
|
|
}
|
|
else
|
|
{
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = pSparkEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
hMaterial = g_Material_Spark;
|
|
}
|
|
|
|
//Setup our collision information
|
|
pSparkEmitter->Setup( (Vector &) pos,
|
|
NULL,
|
|
SPARK_SPREAD,
|
|
flMinSpeed,
|
|
flMaxSpeed,
|
|
SPARK_GRAVITY,
|
|
SPARK_DAMPEN,
|
|
bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
pSparkEmitter->SetSortOrigin( pos );
|
|
|
|
//
|
|
// Big sparks.
|
|
//
|
|
Vector dir;
|
|
int numSparks = nMagnitude * nMagnitude * random->RandomFloat( 2, 4 );
|
|
|
|
int i;
|
|
TrailParticle *pParticle;
|
|
for ( i = 0; i < numSparks; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) pSparkEmitter->AddParticle( sizeof(TrailParticle), hMaterial, pos );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = nMagnitude * random->RandomFloat( 1.0f, 2.0f );
|
|
|
|
float spreadOfs = random->RandomFloat( 0.0f, 2.0f );
|
|
dir[0] = vecDir[0] + random->RandomFloat( -(SPARK_SPREAD*spreadOfs), (SPARK_SPREAD*spreadOfs) );
|
|
dir[1] = vecDir[1] + random->RandomFloat( -(SPARK_SPREAD*spreadOfs), (SPARK_SPREAD*spreadOfs) );
|
|
dir[2] = vecDir[2] + random->RandomFloat( -(SPARK_SPREAD*spreadOfs), (SPARK_SPREAD*spreadOfs) );
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( (flMinSpeed*(2.0f-spreadOfs)), (flMaxSpeed*(2.0f-spreadOfs)) );
|
|
|
|
pParticle->m_flWidth = flWidth + random->RandomFloat( 0.0f, 0.5f );
|
|
pParticle->m_flLength = nTrailLength * random->RandomFloat( 0.02, 0.05f );
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
|
|
//
|
|
// Little sparks
|
|
//
|
|
CSmartPtr<CTrailParticles> pSparkEmitter2 = CTrailParticles::Create( "FX_ElectricSpark 2" );
|
|
|
|
if ( !pSparkEmitter2 )
|
|
{
|
|
Assert(0);
|
|
return;
|
|
}
|
|
|
|
if ( pSparkMaterial )
|
|
{
|
|
hMaterial = pSparkEmitter->GetPMaterial( pSparkMaterial );
|
|
}
|
|
else
|
|
{
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = pSparkEmitter2->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
hMaterial = g_Material_Spark;
|
|
}
|
|
|
|
pSparkEmitter2->SetSortOrigin( pos );
|
|
|
|
pSparkEmitter2->m_ParticleCollision.SetGravity( 400.0f );
|
|
pSparkEmitter2->SetFlag( bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
numSparks = nMagnitude * random->RandomInt( 4, 8 );
|
|
|
|
// Dump out sparks
|
|
for ( i = 0; i < numSparks; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) pSparkEmitter2->AddParticle( sizeof(TrailParticle), hMaterial, pos );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
|
|
dir.Random( -1.0f, 1.0f );
|
|
dir += vecDir;
|
|
VectorNormalize( dir );
|
|
|
|
pParticle->m_flWidth = (flWidth * 0.25) + random->RandomFloat( 0.0f, 0.5f );
|
|
pParticle->m_flLength = nTrailLength * random->RandomFloat( 0.02f, 0.03f );
|
|
pParticle->m_flDieTime = nMagnitude * random->RandomFloat( 0.3f, 0.5f );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( flMinSpeed, flMaxSpeed );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Energy splash for plasma/beam weapon impacts
|
|
// Input : &pos - origin point of effect
|
|
//-----------------------------------------------------------------------------
|
|
#define ENERGY_SPLASH_SPREAD 0.7f
|
|
#define ENERGY_SPLASH_MINSPEED 128.0f
|
|
#define ENERGY_SPLASH_MAXSPEED 160.0f
|
|
#define ENERGY_SPLASH_GRAVITY 800.0f
|
|
#define ENERGY_SPLASH_DAMPEN 0.3f
|
|
|
|
void FX_EnergySplash( const Vector &pos, const Vector &normal, int nFlags )
|
|
{
|
|
VPROF_BUDGET( "FX_EnergySplash", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
Vector offset = pos + ( normal * 2.0f );
|
|
|
|
// Quick flash
|
|
FX_AddQuad( pos,
|
|
normal,
|
|
64.0f,
|
|
0,
|
|
0.75f,
|
|
1.0f,
|
|
0.0f,
|
|
0.4f,
|
|
random->RandomInt( 0, 360 ),
|
|
0,
|
|
Vector( 1.0f, 1.0f, 1.0f ),
|
|
0.25f,
|
|
"effects/combinemuzzle1_nocull",
|
|
(FXQUAD_BIAS_SCALE|FXQUAD_BIAS_ALPHA) );
|
|
|
|
// Lingering burn
|
|
FX_AddQuad( pos,
|
|
normal,
|
|
16,
|
|
32,
|
|
0.75f,
|
|
1.0f,
|
|
0.0f,
|
|
0.4f,
|
|
random->RandomInt( 0, 360 ),
|
|
0,
|
|
Vector( 1.0f, 1.0f, 1.0f ),
|
|
0.5f,
|
|
"effects/combinemuzzle2_nocull",
|
|
(FXQUAD_BIAS_SCALE|FXQUAD_BIAS_ALPHA) );
|
|
|
|
SimpleParticle *sParticle;
|
|
|
|
CSmartPtr<CSimpleEmitter> pEmitter;
|
|
|
|
pEmitter = CSimpleEmitter::Create( "C_EntityDissolve" );
|
|
pEmitter->SetSortOrigin( pos );
|
|
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = pEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
// Anime ground effects
|
|
for ( int j = 0; j < 8; j++ )
|
|
{
|
|
offset.x = random->RandomFloat( -8.0f, 8.0f );
|
|
offset.y = random->RandomFloat( -8.0f, 8.0f );
|
|
offset.z = random->RandomFloat( 0.0f, 4.0f );
|
|
|
|
offset += pos;
|
|
|
|
sParticle = (SimpleParticle *) pEmitter->AddParticle( sizeof(SimpleParticle), g_Material_Spark, offset );
|
|
|
|
if ( sParticle == NULL )
|
|
return;
|
|
|
|
sParticle->m_vecVelocity = Vector( Helper_RandomFloat( -4.0f, 4.0f ), Helper_RandomFloat( -4.0f, 4.0f ), Helper_RandomFloat( 16.0f, 64.0f ) );
|
|
|
|
sParticle->m_uchStartSize = random->RandomFloat( 2, 4 );
|
|
|
|
sParticle->m_flDieTime = random->RandomFloat( 0.4f, 0.6f );
|
|
|
|
sParticle->m_flLifetime = 0.0f;
|
|
|
|
sParticle->m_flRoll = Helper_RandomInt( 0, 360 );
|
|
|
|
float alpha = 255;
|
|
|
|
sParticle->m_flRollDelta = Helper_RandomFloat( -4.0f, 4.0f );
|
|
sParticle->m_uchColor[0] = alpha;
|
|
sParticle->m_uchColor[1] = alpha;
|
|
sParticle->m_uchColor[2] = alpha;
|
|
sParticle->m_uchStartAlpha = alpha;
|
|
sParticle->m_uchEndAlpha = 0;
|
|
sParticle->m_uchEndSize = 0;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Micro-Explosion effect
|
|
// Input : &position - origin of effect
|
|
// &normal - normal of the surface struck
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define MICRO_EXPLOSION_MINSPEED 100.0f
|
|
#define MICRO_EXPLOSION_MAXSPEED 150.0f
|
|
#define MICRO_EXPLOSION_SPREAD 1.0f
|
|
#define MICRO_EXPLOSION_GRAVITY 0.0f
|
|
#define MICRO_EXPLOSION_DAMPEN 0.4f
|
|
|
|
void FX_MicroExplosion( Vector &position, Vector &normal )
|
|
{
|
|
VPROF_BUDGET( "FX_MicroExplosion", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
Vector offset = position + ( normal * 2.0f );
|
|
|
|
CSmartPtr<CTrailParticles> sparkEmitter = CTrailParticles::Create( "FX_MicroExplosion 1" );
|
|
|
|
if ( !sparkEmitter )
|
|
return;
|
|
|
|
sparkEmitter->SetSortOrigin( offset );
|
|
|
|
//Setup our collision information
|
|
sparkEmitter->Setup( offset,
|
|
&normal,
|
|
MICRO_EXPLOSION_SPREAD,
|
|
MICRO_EXPLOSION_MINSPEED,
|
|
MICRO_EXPLOSION_MAXSPEED,
|
|
MICRO_EXPLOSION_GRAVITY,
|
|
MICRO_EXPLOSION_DAMPEN,
|
|
bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
int numSparks = random->RandomInt( 8, 16 );
|
|
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = sparkEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
TrailParticle *pParticle;
|
|
Vector dir, vOfs;
|
|
float length = 0.2f;
|
|
|
|
//Fast lines
|
|
for ( int i = 0; i < numSparks; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) sparkEmitter->AddParticle( sizeof(TrailParticle), g_Material_Spark, offset );
|
|
|
|
if ( pParticle )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
|
|
float ramp = ( (float) i / (float)numSparks );
|
|
|
|
dir[0] = normal[0] + random->RandomFloat( -MICRO_EXPLOSION_SPREAD*ramp, MICRO_EXPLOSION_SPREAD*ramp );
|
|
dir[1] = normal[1] + random->RandomFloat( -MICRO_EXPLOSION_SPREAD*ramp, MICRO_EXPLOSION_SPREAD*ramp );
|
|
dir[2] = normal[2] + random->RandomFloat( -MICRO_EXPLOSION_SPREAD*ramp, MICRO_EXPLOSION_SPREAD*ramp );
|
|
|
|
pParticle->m_flWidth = random->RandomFloat( 5.0f, 10.0f );
|
|
pParticle->m_flLength = (length*((1.0f-ramp)*(1.0f-ramp)*0.5f));
|
|
pParticle->m_flDieTime = 0.2f;
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( MICRO_EXPLOSION_MINSPEED*(1.5f-ramp), MICRO_EXPLOSION_MAXSPEED*(1.5f-ramp) );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Filler
|
|
//
|
|
|
|
CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "FX_MicroExplosion 2" );
|
|
pSimple->SetSortOrigin( offset );
|
|
|
|
SimpleParticle *sParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "sprites/rico1" ), offset );
|
|
|
|
if ( sParticle )
|
|
{
|
|
sParticle->m_flLifetime = 0.0f;
|
|
sParticle->m_flDieTime = 0.3f;
|
|
|
|
sParticle->m_vecVelocity.Init();
|
|
|
|
sParticle->m_uchColor[0] = 255;
|
|
sParticle->m_uchColor[1] = 255;
|
|
sParticle->m_uchColor[2] = 255;
|
|
sParticle->m_uchStartAlpha = random->RandomInt( 128, 255 );
|
|
sParticle->m_uchEndAlpha = 0;
|
|
sParticle->m_uchStartSize = random->RandomInt( 12, 16 );
|
|
sParticle->m_uchEndSize = sParticle->m_uchStartSize;
|
|
sParticle->m_flRoll = random->RandomInt( 0, 360 );
|
|
sParticle->m_flRollDelta = 0.0f;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Ugly prototype explosion effect
|
|
//-----------------------------------------------------------------------------
|
|
#define EXPLOSION_MINSPEED 300.0f
|
|
#define EXPLOSION_MAXSPEED 300.0f
|
|
#define EXPLOSION_SPREAD 0.8f
|
|
#define EXPLOSION_GRAVITY 800.0f
|
|
#define EXPLOSION_DAMPEN 0.4f
|
|
|
|
#define EXPLOSION_FLECK_MIN_SPEED 150.0f
|
|
#define EXPLOSION_FLECK_MAX_SPEED 350.0f
|
|
#define EXPLOSION_FLECK_GRAVITY 800.0f
|
|
#define EXPLOSION_FLECK_DAMPEN 0.3f
|
|
#define EXPLOSION_FLECK_ANGULAR_SPRAY 0.8f
|
|
|
|
void FX_Explosion( Vector& origin, Vector& normal, char materialType )
|
|
{
|
|
VPROF_BUDGET( "FX_Explosion", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
Vector offset = origin + ( normal * 2.0f );
|
|
|
|
CSmartPtr<CTrailParticles> pSparkEmitter = CTrailParticles::Create( "FX_Explosion 1" );
|
|
if ( !pSparkEmitter )
|
|
return;
|
|
|
|
// Get color data from our hit point
|
|
IMaterial *pTraceMaterial;
|
|
Vector diffuseColor, baseColor;
|
|
pTraceMaterial = engine->TraceLineMaterialAndLighting( origin, normal * -16.0f, diffuseColor, baseColor );
|
|
// Get final light value
|
|
float r = pow( diffuseColor[0], 1.0f/2.2f ) * baseColor[0];
|
|
float g = pow( diffuseColor[1], 1.0f/2.2f ) * baseColor[1];
|
|
float b = pow( diffuseColor[2], 1.0f/2.2f ) * baseColor[2];
|
|
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = pSparkEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
// Setup our collision information
|
|
pSparkEmitter->Setup( offset,
|
|
&normal,
|
|
EXPLOSION_SPREAD,
|
|
EXPLOSION_MINSPEED,
|
|
EXPLOSION_MAXSPEED,
|
|
EXPLOSION_GRAVITY,
|
|
EXPLOSION_DAMPEN,
|
|
bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
pSparkEmitter->SetSortOrigin( offset );
|
|
|
|
Vector dir;
|
|
int numSparks = random->RandomInt( 8,16 );
|
|
|
|
// Dump out sparks
|
|
int i;
|
|
for ( i = 0; i < numSparks; i++ )
|
|
{
|
|
TrailParticle *pParticle = (TrailParticle *) pSparkEmitter->AddParticle( sizeof(TrailParticle), g_Material_Spark, offset );
|
|
|
|
if ( pParticle == NULL )
|
|
break;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
|
|
pParticle->m_flWidth = random->RandomFloat( 5.0f, 10.0f );
|
|
pParticle->m_flLength = random->RandomFloat( 0.05, 0.1f );
|
|
pParticle->m_flDieTime = random->RandomFloat( 1.0f, 2.0f );
|
|
|
|
dir[0] = normal[0] + random->RandomFloat( -EXPLOSION_SPREAD, EXPLOSION_SPREAD );
|
|
dir[1] = normal[1] + random->RandomFloat( -EXPLOSION_SPREAD, EXPLOSION_SPREAD );
|
|
dir[2] = normal[2] + random->RandomFloat( -EXPLOSION_SPREAD, EXPLOSION_SPREAD );
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( EXPLOSION_MINSPEED, EXPLOSION_MAXSPEED );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
|
|
|
|
// Chunks o'dirt
|
|
// Only create dirt chunks on concrete/world
|
|
if ( materialType == 'C' || materialType == 'W' )
|
|
{
|
|
CSmartPtr<CFleckParticles> fleckEmitter = CFleckParticles::Create( "FX_Explosion 10", offset, Vector(5,5,5) );
|
|
if ( !fleckEmitter )
|
|
return;
|
|
|
|
// Setup our collision information
|
|
fleckEmitter->m_ParticleCollision.Setup( offset, &normal, EXPLOSION_FLECK_ANGULAR_SPRAY, EXPLOSION_FLECK_MIN_SPEED, EXPLOSION_FLECK_MAX_SPEED, EXPLOSION_FLECK_GRAVITY, EXPLOSION_FLECK_DAMPEN );
|
|
|
|
PMaterialHandle *hMaterialArray;
|
|
|
|
switch ( materialType )
|
|
{
|
|
case 'C':
|
|
case 'c':
|
|
default:
|
|
hMaterialArray = g_Mat_Fleck_Cement;
|
|
break;
|
|
}
|
|
|
|
int numFlecks = random->RandomInt( 48, 64 );
|
|
// Dump out flecks
|
|
for ( i = 0; i < numFlecks; i++ )
|
|
{
|
|
FleckParticle *pParticle = (FleckParticle *) fleckEmitter->AddParticle( sizeof(FleckParticle), hMaterialArray[random->RandomInt(0,1)], offset );
|
|
|
|
if ( pParticle == NULL )
|
|
break;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = 3.0f;
|
|
dir[0] = normal[0] + random->RandomFloat( -EXPLOSION_FLECK_ANGULAR_SPRAY, EXPLOSION_FLECK_ANGULAR_SPRAY );
|
|
dir[1] = normal[1] + random->RandomFloat( -EXPLOSION_FLECK_ANGULAR_SPRAY, EXPLOSION_FLECK_ANGULAR_SPRAY );
|
|
dir[2] = normal[2] + random->RandomFloat( -EXPLOSION_FLECK_ANGULAR_SPRAY, EXPLOSION_FLECK_ANGULAR_SPRAY );
|
|
pParticle->m_uchSize = random->RandomInt( 2, 6 );
|
|
pParticle->m_vecVelocity = dir * ( random->RandomFloat( EXPLOSION_FLECK_MIN_SPEED, EXPLOSION_FLECK_MAX_SPEED ) * ( 7 - pParticle->m_uchSize ) );
|
|
pParticle->m_flRoll = random->RandomFloat( 0, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( 0, 360 );
|
|
|
|
float colorRamp = random->RandomFloat( 0.75f, 1.5f );
|
|
pParticle->m_uchColor[0] = MIN( 1.0f, r*colorRamp )*255.0f;
|
|
pParticle->m_uchColor[1] = MIN( 1.0f, g*colorRamp )*255.0f;
|
|
pParticle->m_uchColor[2] = MIN( 1.0f, b*colorRamp )*255.0f;
|
|
}
|
|
}
|
|
|
|
// Large sphere bursts
|
|
CSmartPtr<CSimpleEmitter> pSimpleEmitter = CSimpleEmitter::Create( "FX_Explosion 1" );
|
|
PMaterialHandle hSphereMaterial = g_Mat_DustPuff[1];
|
|
Vector vecBurstOrigin = offset + normal * 8.0;
|
|
pSimpleEmitter->SetSortOrigin( vecBurstOrigin );
|
|
SimpleParticle *pSphereParticle = (SimpleParticle *) pSimpleEmitter->AddParticle( sizeof(SimpleParticle), hSphereMaterial, vecBurstOrigin );
|
|
if ( pSphereParticle )
|
|
{
|
|
pSphereParticle->m_flLifetime = 0.0f;
|
|
pSphereParticle->m_flDieTime = 0.3f;
|
|
pSphereParticle->m_uchStartAlpha = 150.0;
|
|
pSphereParticle->m_uchEndAlpha = 64.0;
|
|
pSphereParticle->m_uchStartSize = 0.0;
|
|
pSphereParticle->m_uchEndSize = 255.0;
|
|
pSphereParticle->m_vecVelocity = Vector(0,0,0);
|
|
|
|
float colorRamp = random->RandomFloat( 0.75f, 1.5f );
|
|
pSphereParticle->m_uchColor[0] = MIN( 1.0f, r*colorRamp )*255.0f;
|
|
pSphereParticle->m_uchColor[1] = MIN( 1.0f, g*colorRamp )*255.0f;
|
|
pSphereParticle->m_uchColor[2] = MIN( 1.0f, b*colorRamp )*255.0f;
|
|
}
|
|
|
|
// Throw some smoke balls out around the normal
|
|
int numBalls = 12;
|
|
Vector vecRight, vecForward, vecUp;
|
|
QAngle vecAngles;
|
|
VectorAngles( normal, vecAngles );
|
|
AngleVectors( vecAngles, NULL, &vecRight, &vecUp );
|
|
for ( i = 0; i < numBalls; i++ )
|
|
{
|
|
SimpleParticle *pParticle = (SimpleParticle *) pSimpleEmitter->AddParticle( sizeof(SimpleParticle), hSphereMaterial, vecBurstOrigin );
|
|
if ( pParticle )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = 0.25f;
|
|
pParticle->m_uchStartAlpha = 128.0;
|
|
pParticle->m_uchEndAlpha = 64.0;
|
|
pParticle->m_uchStartSize = 16.0;
|
|
pParticle->m_uchEndSize = 64.0;
|
|
|
|
float flAngle = ((float)i * M_PI * 2) / numBalls;
|
|
float x = cos( flAngle );
|
|
float y = sin( flAngle );
|
|
pParticle->m_vecVelocity = (vecRight*x + vecUp*y) * 1024.0;
|
|
|
|
float colorRamp = random->RandomFloat( 0.75f, 1.5f );
|
|
pParticle->m_uchColor[0] = MIN( 1.0f, r*colorRamp )*255.0f;
|
|
pParticle->m_uchColor[1] = MIN( 1.0f, g*colorRamp )*255.0f;
|
|
pParticle->m_uchColor[2] = MIN( 1.0f, b*colorRamp )*255.0f;
|
|
}
|
|
}
|
|
|
|
// Create a couple of big, floating smoke clouds
|
|
CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "FX_Explosion 2" );
|
|
pSmokeEmitter->SetSortOrigin( offset );
|
|
for ( i = 0; i < 2; i++ )
|
|
{
|
|
SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], offset );
|
|
if ( pParticle == NULL )
|
|
break;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = random->RandomFloat( 2.0f, 3.0f );
|
|
pParticle->m_uchStartSize = 64;
|
|
pParticle->m_uchEndSize = 255;
|
|
dir[0] = normal[0] + random->RandomFloat( -0.8f, 0.8f );
|
|
dir[1] = normal[1] + random->RandomFloat( -0.8f, 0.8f );
|
|
dir[2] = normal[2] + random->RandomFloat( -0.8f, 0.8f );
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( 2.0f, 24.0f )*(i+1);
|
|
pParticle->m_uchStartAlpha = 160;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
pParticle->m_flRoll = random->RandomFloat( 180, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
|
|
|
|
float colorRamp = random->RandomFloat( 0.5f, 1.25f );
|
|
pParticle->m_uchColor[0] = MIN( 1.0f, r*colorRamp )*255.0f;
|
|
pParticle->m_uchColor[1] = MIN( 1.0f, g*colorRamp )*255.0f;
|
|
pParticle->m_uchColor[2] = MIN( 1.0f, b*colorRamp )*255.0f;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : origin -
|
|
// normal -
|
|
//-----------------------------------------------------------------------------
|
|
void FX_ConcussiveExplosion( Vector &origin, Vector &normal )
|
|
{
|
|
VPROF_BUDGET( "FX_ConcussiveExplosion", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
|
|
Vector offset = origin + ( normal * 2.0f );
|
|
Vector dir;
|
|
int i;
|
|
|
|
//
|
|
// Smoke
|
|
//
|
|
|
|
CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "FX_ConcussiveExplosion 1" );
|
|
pSmokeEmitter->SetSortOrigin( offset );
|
|
|
|
//Quick moving sprites
|
|
for ( i = 0; i < 16; i++ )
|
|
{
|
|
SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], offset );
|
|
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = random->RandomFloat( 0.2f, 0.4f );
|
|
pParticle->m_uchStartSize = random->RandomInt( 4, 8 );
|
|
pParticle->m_uchEndSize = random->RandomInt( 32, 64 );
|
|
|
|
dir[0] = random->RandomFloat( -1.0f, 1.0f );
|
|
dir[1] = random->RandomFloat( -1.0f, 1.0f );
|
|
dir[2] = random->RandomFloat( -1.0f, 1.0f );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( 64.0f, 128.0f );
|
|
pParticle->m_uchStartAlpha = random->RandomInt( 64, 128 );
|
|
pParticle->m_uchEndAlpha = 0;
|
|
pParticle->m_flRoll = random->RandomFloat( 180, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -4, 4 );
|
|
|
|
int colorRamp = random->RandomFloat( 235, 255 );
|
|
pParticle->m_uchColor[0] = colorRamp;
|
|
pParticle->m_uchColor[1] = colorRamp;
|
|
pParticle->m_uchColor[2] = colorRamp;
|
|
}
|
|
|
|
//Slow lingering sprites
|
|
for ( i = 0; i < 2; i++ )
|
|
{
|
|
SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], offset );
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = random->RandomFloat( 1.0f, 2.0f );
|
|
pParticle->m_uchStartSize = random->RandomInt( 32, 64 );
|
|
pParticle->m_uchEndSize = random->RandomInt( 100, 128 );
|
|
|
|
dir[0] = normal[0] + random->RandomFloat( -0.8f, 0.8f );
|
|
dir[1] = normal[1] + random->RandomFloat( -0.8f, 0.8f );
|
|
dir[2] = normal[2] + random->RandomFloat( -0.8f, 0.8f );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( 16.0f, 32.0f );
|
|
|
|
pParticle->m_uchStartAlpha = random->RandomInt( 32, 64 );
|
|
pParticle->m_uchEndAlpha = 0;
|
|
pParticle->m_flRoll = random->RandomFloat( 180, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
|
|
|
|
int colorRamp = random->RandomFloat( 235, 255 );
|
|
pParticle->m_uchColor[0] = colorRamp;
|
|
pParticle->m_uchColor[1] = colorRamp;
|
|
pParticle->m_uchColor[2] = colorRamp;
|
|
}
|
|
|
|
|
|
//
|
|
// Quick sphere
|
|
//
|
|
|
|
CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "FX_ConcussiveExplosion 2" );
|
|
|
|
pSimple->SetSortOrigin( offset );
|
|
|
|
SimpleParticle *pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof(SimpleParticle), pSimple->GetPMaterial( "effects/blueflare1" ), offset );
|
|
|
|
if ( pParticle )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = 0.1f;
|
|
pParticle->m_vecVelocity.Init();
|
|
pParticle->m_flRoll = random->RandomFloat( 180, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
|
|
|
|
pParticle->m_uchColor[0] = pParticle->m_uchColor[1] = pParticle->m_uchColor[2] = 128;
|
|
|
|
pParticle->m_uchStartAlpha = 255;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_uchStartSize = 16;
|
|
pParticle->m_uchEndSize = 64;
|
|
}
|
|
|
|
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof(SimpleParticle), pSimple->GetPMaterial( "effects/blueflare1" ), offset );
|
|
|
|
if ( pParticle )
|
|
{
|
|
pParticle->m_flLifetime = 0.0f;
|
|
pParticle->m_flDieTime = 0.2f;
|
|
pParticle->m_vecVelocity.Init();
|
|
pParticle->m_flRoll = random->RandomFloat( 180, 360 );
|
|
pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
|
|
pParticle->m_uchColor[0] = pParticle->m_uchColor[1] = pParticle->m_uchColor[2] = 32;
|
|
|
|
pParticle->m_uchStartAlpha = 64;
|
|
pParticle->m_uchEndAlpha = 0;
|
|
|
|
pParticle->m_uchStartSize = 64;
|
|
pParticle->m_uchEndSize = 128;
|
|
}
|
|
|
|
|
|
//
|
|
// Dlight
|
|
//
|
|
|
|
dlight_t *dl= effects->CL_AllocDlight ( 0 );
|
|
|
|
dl->origin = offset;
|
|
dl->color.r = dl->color.g = dl->color.b = 64;
|
|
dl->radius = random->RandomFloat(128,256);
|
|
dl->die = gpGlobals->curtime + 0.1;
|
|
|
|
|
|
//
|
|
// Moving lines
|
|
//
|
|
|
|
TrailParticle *pTrailParticle;
|
|
CSmartPtr<CTrailParticles> pSparkEmitter = CTrailParticles::Create( "FX_ConcussiveExplosion 3" );
|
|
PMaterialHandle hMaterial;
|
|
int numSparks;
|
|
|
|
if ( pSparkEmitter.IsValid() )
|
|
{
|
|
hMaterial= pSparkEmitter->GetPMaterial( "effects/blueflare1" );
|
|
|
|
pSparkEmitter->SetSortOrigin( offset );
|
|
pSparkEmitter->m_ParticleCollision.SetGravity( 0.0f );
|
|
|
|
numSparks = random->RandomInt( 16, 32 );
|
|
|
|
//Dump out sparks
|
|
for ( i = 0; i < numSparks; i++ )
|
|
{
|
|
pTrailParticle = (TrailParticle *) pSparkEmitter->AddParticle( sizeof(TrailParticle), hMaterial, offset );
|
|
|
|
if ( pTrailParticle == NULL )
|
|
return;
|
|
|
|
pTrailParticle->m_flLifetime = 0.0f;
|
|
|
|
dir.Random( -1.0f, 1.0f );
|
|
|
|
pTrailParticle->m_flWidth = random->RandomFloat( 1.0f, 2.0f );
|
|
pTrailParticle->m_flLength = random->RandomFloat( 0.01f, 0.1f );
|
|
pTrailParticle->m_flDieTime = random->RandomFloat( 0.1f, 0.2f );
|
|
|
|
pTrailParticle->m_vecVelocity = dir * random->RandomFloat( 800, 1000 );
|
|
|
|
float colorRamp = random->RandomFloat( 0.75f, 1.0f );
|
|
FloatToColor32( pTrailParticle->m_color, colorRamp, colorRamp, 1.0f, 1.0f );
|
|
}
|
|
}
|
|
|
|
//Moving particles
|
|
CSmartPtr<CTrailParticles> pCollisionEmitter = CTrailParticles::Create( "FX_ConcussiveExplosion 4" );
|
|
|
|
if ( pCollisionEmitter.IsValid() )
|
|
{
|
|
//Setup our collision information
|
|
pCollisionEmitter->Setup( (Vector &) offset,
|
|
NULL,
|
|
SPARK_ELECTRIC_SPREAD,
|
|
SPARK_ELECTRIC_MINSPEED*6,
|
|
SPARK_ELECTRIC_MAXSPEED*6,
|
|
-400,
|
|
SPARK_ELECTRIC_DAMPEN,
|
|
bitsPARTICLE_TRAIL_FADE );
|
|
|
|
pCollisionEmitter->SetSortOrigin( offset );
|
|
|
|
numSparks = random->RandomInt( 8, 16 );
|
|
hMaterial = pCollisionEmitter->GetPMaterial( "effects/blueflare1" );
|
|
|
|
//Dump out sparks
|
|
for ( i = 0; i < numSparks; i++ )
|
|
{
|
|
pTrailParticle = (TrailParticle *) pCollisionEmitter->AddParticle( sizeof(TrailParticle), hMaterial, offset );
|
|
|
|
if ( pTrailParticle == NULL )
|
|
return;
|
|
|
|
pTrailParticle->m_flLifetime = 0.0f;
|
|
|
|
dir.Random( -1.0f, 1.0f );
|
|
dir[2] = random->RandomFloat( 0.0f, 0.75f );
|
|
|
|
pTrailParticle->m_flWidth = random->RandomFloat( 1.0f, 2.0f );
|
|
pTrailParticle->m_flLength = random->RandomFloat( 0.01f, 0.1f );
|
|
pTrailParticle->m_flDieTime = random->RandomFloat( 0.2f, 1.0f );
|
|
|
|
pTrailParticle->m_vecVelocity = dir * random->RandomFloat( 128, 512 );
|
|
|
|
float colorRamp = random->RandomFloat( 0.75f, 1.0f );
|
|
FloatToColor32( pTrailParticle->m_color, colorRamp, colorRamp, 1.0f, 1.0f );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FX_SparkFan( Vector &position, Vector &normal )
|
|
{
|
|
Vector offset = position + ( normal * 1.0f );
|
|
|
|
CSmartPtr<CTrailParticles> sparkEmitter = CTrailParticles::Create( "FX_MetalScrape 1" );
|
|
|
|
if ( !sparkEmitter )
|
|
return;
|
|
|
|
sparkEmitter->SetSortOrigin( offset );
|
|
|
|
//Setup our collision information
|
|
sparkEmitter->Setup( offset,
|
|
&normal,
|
|
METAL_SCRAPE_SPREAD,
|
|
METAL_SCRAPE_MINSPEED,
|
|
METAL_SCRAPE_MAXSPEED,
|
|
METAL_SCRAPE_GRAVITY,
|
|
METAL_SCRAPE_DAMPEN,
|
|
bitsPARTICLE_TRAIL_VELOCITY_DAMPEN );
|
|
|
|
if ( g_Material_Spark == NULL )
|
|
{
|
|
g_Material_Spark = sparkEmitter->GetPMaterial( "effects/spark" );
|
|
}
|
|
|
|
TrailParticle *pParticle;
|
|
Vector dir;
|
|
|
|
float length = 0.06f;
|
|
|
|
//Dump out sparks
|
|
for ( int i = 0; i < 35; i++ )
|
|
{
|
|
pParticle = (TrailParticle *) sparkEmitter->AddParticle( sizeof(TrailParticle), g_Material_Spark, offset );
|
|
if ( pParticle == NULL )
|
|
return;
|
|
|
|
pParticle->m_flLifetime = 0.0f;
|
|
|
|
float spreadOfs = random->RandomFloat( 0.0f, 2.0f );
|
|
|
|
dir[0] = normal[0] + random->RandomFloat( -(METAL_SCRAPE_SPREAD*spreadOfs), (METAL_SCRAPE_SPREAD*spreadOfs) );
|
|
dir[1] = normal[1] + random->RandomFloat( -(METAL_SCRAPE_SPREAD*spreadOfs), (METAL_SCRAPE_SPREAD*spreadOfs) );
|
|
dir[2] = normal[2] + random->RandomFloat( -(METAL_SCRAPE_SPREAD*spreadOfs), (METAL_SCRAPE_SPREAD*spreadOfs) );
|
|
|
|
pParticle->m_flWidth = random->RandomFloat( 2.0f, 5.0f );
|
|
pParticle->m_flLength = random->RandomFloat( length*0.25f, length );
|
|
pParticle->m_flDieTime = random->RandomFloat( 2.0f, 2.0f );
|
|
|
|
pParticle->m_vecVelocity = dir * random->RandomFloat( (METAL_SCRAPE_MINSPEED*(2.0f-spreadOfs)), (METAL_SCRAPE_MAXSPEED*(2.0f-spreadOfs)) );
|
|
|
|
Color32Init( pParticle->m_color, 255, 255, 255, 255 );
|
|
}
|
|
}
|
|
|
|
|
|
void ManhackSparkCallback( const CEffectData & data )
|
|
{
|
|
Vector vecNormal;
|
|
Vector vecPosition;
|
|
QAngle angles;
|
|
|
|
vecPosition = data.m_vOrigin;
|
|
vecNormal = data.m_vNormal;
|
|
angles = data.m_vAngles;
|
|
|
|
FX_SparkFan( vecPosition, vecNormal );
|
|
}
|
|
|
|
DECLARE_CLIENT_EFFECT( "ManhackSparks", ManhackSparkCallback );
|