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

1537 lines
46 KiB
Raw Permalink Blame History

//========= 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 );