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.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/client/hl2/fx_hl2_tracers.cpp

695 lines
21 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Game-specific impact effect hooks
//
//=============================================================================//
#include "cbase.h"
#include "fx.h"
#include "c_te_effect_dispatch.h"
#include "tier0/vprof.h"
#include "fx_line.h"
#include "fx_quad.h"
#include "view.h"
#include "particles_localspace.h"
#include "dlight.h"
#include "iefx.h"
#include "clienteffectprecachesystem.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern Vector GetTracerOrigin( const CEffectData &data );
extern void FX_TracerSound( const Vector &start, const Vector &end, int iTracerType );
extern ConVar muzzleflash_light;
CLIENTEFFECT_REGISTER_BEGIN( PrecacheTracers )
CLIENTEFFECT_MATERIAL( "effects/gunshiptracer" )
CLIENTEFFECT_MATERIAL( "effects/combinemuzzle1" )
CLIENTEFFECT_MATERIAL( "effects/combinemuzzle2_nocull" )
CLIENTEFFECT_REGISTER_END()
//-----------------------------------------------------------------------------
// Purpose: Gunship's Tracer
//-----------------------------------------------------------------------------
void GunshipTracerCallback( const CEffectData &data )
{
float flVelocity = data.m_flScale;
bool bWhiz = (data.m_fFlags & TRACER_FLAG_WHIZ);
FX_GunshipTracer( (Vector&)data.m_vStart, (Vector&)data.m_vOrigin, flVelocity, bWhiz );
}
DECLARE_CLIENT_EFFECT( "GunshipTracer", GunshipTracerCallback );
//-----------------------------------------------------------------------------
// Purpose: Strider's Tracer
//-----------------------------------------------------------------------------
void StriderTracerCallback( const CEffectData &data )
{
float flVelocity = data.m_flScale;
bool bWhiz = (data.m_fFlags & TRACER_FLAG_WHIZ);
FX_StriderTracer( (Vector&)data.m_vStart, (Vector&)data.m_vOrigin, flVelocity, bWhiz );
}
DECLARE_CLIENT_EFFECT( "StriderTracer", StriderTracerCallback );
//-----------------------------------------------------------------------------
// Purpose: Hunter's Tracer
//-----------------------------------------------------------------------------
void HunterTracerCallback( const CEffectData &data )
{
float flVelocity = data.m_flScale;
bool bWhiz = (data.m_fFlags & TRACER_FLAG_WHIZ);
FX_HunterTracer( (Vector&)data.m_vStart, (Vector&)data.m_vOrigin, flVelocity, bWhiz );
}
DECLARE_CLIENT_EFFECT( "HunterTracer", HunterTracerCallback );
//-----------------------------------------------------------------------------
// Purpose: Gauss Gun's Tracer
//-----------------------------------------------------------------------------
void GaussTracerCallback( const CEffectData &data )
{
float flVelocity = data.m_flScale;
bool bWhiz = (data.m_fFlags & TRACER_FLAG_WHIZ);
FX_GaussTracer( (Vector&)data.m_vStart, (Vector&)data.m_vOrigin, flVelocity, bWhiz );
}
DECLARE_CLIENT_EFFECT( "GaussTracer", GaussTracerCallback );
//-----------------------------------------------------------------------------
// Purpose: Airboat gun tracers
//-----------------------------------------------------------------------------
void AirboatGunHeavyTracerCallback( const CEffectData &data )
{
// Grab the data
Vector vecStart = GetTracerOrigin( data );
float flVelocity = data.m_flScale;
// Use default velocity if none specified
if ( !flVelocity )
{
flVelocity = 8000;
}
//Get out shot direction and length
Vector vecShotDir;
VectorSubtract( data.m_vOrigin, vecStart, vecShotDir );
float flTotalDist = VectorNormalize( vecShotDir );
// Don't make small tracers
if ( flTotalDist <= 64 )
return;
float flLength = random->RandomFloat( 300.0f, 400.0f );
float flLife = ( flTotalDist + flLength ) / flVelocity; //NOTENOTE: We want the tail to finish its run as well
// Add it
FX_AddDiscreetLine( vecStart, vecShotDir, flVelocity, flLength, flTotalDist, 5.0f, flLife, "effects/gunshiptracer" );
}
DECLARE_CLIENT_EFFECT( "AirboatGunHeavyTracer", AirboatGunHeavyTracerCallback );
//-----------------------------------------------------------------------------
// Purpose: Airboat gun tracers
//-----------------------------------------------------------------------------
void AirboatGunTracerCallback( const CEffectData &data )
{
// Grab the data
Vector vecStart = GetTracerOrigin( data );
float flVelocity = data.m_flScale;
// Use default velocity if none specified
if ( !flVelocity )
{
flVelocity = 10000;
}
//Get out shot direction and length
Vector vecShotDir;
VectorSubtract( data.m_vOrigin, vecStart, vecShotDir );
float flTotalDist = VectorNormalize( vecShotDir );
// Don't make small tracers
if ( flTotalDist <= 64 )
return;
float flLength = random->RandomFloat( 256.0f, 384.0f );
float flLife = ( flTotalDist + flLength ) / flVelocity; //NOTENOTE: We want the tail to finish its run as well
// Add it
FX_AddDiscreetLine( vecStart, vecShotDir, flVelocity, flLength, flTotalDist, 2.0f, flLife, "effects/gunshiptracer" );
}
DECLARE_CLIENT_EFFECT( "AirboatGunTracer", AirboatGunTracerCallback );
//-----------------------------------------------------------------------------
// Purpose: Airboat gun tracers
//-----------------------------------------------------------------------------
void HelicopterTracerCallback( const CEffectData &data )
{
// Grab the data
Vector vecStart = GetTracerOrigin( data );
float flVelocity = data.m_flScale;
// Use default velocity if none specified
if ( !flVelocity )
{
flVelocity = 8000;
}
//Get out shot direction and length
Vector vecShotDir;
VectorSubtract( data.m_vOrigin, vecStart, vecShotDir );
float flTotalDist = VectorNormalize( vecShotDir );
// Don't make small tracers
if ( flTotalDist <= 256 )
return;
float flLength = random->RandomFloat( 256.0f, 384.0f );
float flLife = ( flTotalDist + flLength ) / flVelocity; //NOTENOTE: We want the tail to finish its run as well
// Add it
FX_AddDiscreetLine( vecStart, vecShotDir, flVelocity, flLength, flTotalDist, 5.0f, flLife, "effects/gunshiptracer" );
if (data.m_fFlags & TRACER_FLAG_WHIZ)
{
FX_TracerSound( vecStart, data.m_vOrigin, TRACER_TYPE_GUNSHIP );
}
}
DECLARE_CLIENT_EFFECT( "HelicopterTracer", HelicopterTracerCallback );
//-----------------------------------------------------------------------------
// Purpose:
// Input : start -
// end -
//-----------------------------------------------------------------------------
void FX_PlayerAR2Tracer( const Vector &start, const Vector &end )
{
VPROF_BUDGET( "FX_PlayerAR2Tracer", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
Vector shotDir, dStart, dEnd;
float length;
//Find the direction of the tracer
VectorSubtract( end, start, shotDir );
length = VectorNormalize( shotDir );
//We don't want to draw them if they're too close to us
if ( length < 128 )
return;
//Randomly place the tracer along this line, with a random length
VectorMA( start, random->RandomFloat( 0.0f, 8.0f ), shotDir, dStart );
VectorMA( dStart, MIN( length, random->RandomFloat( 256.0f, 1024.0f ) ), shotDir, dEnd );
//Create the line
CFXStaticLine *tracerLine = new CFXStaticLine( "Tracer", dStart, dEnd, random->RandomFloat( 6.0f, 12.0f ), 0.01f, "effects/gunshiptracer", 0 );
assert( tracerLine );
//Throw it into the list
clienteffects->AddEffect( tracerLine );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : start -
// end -
// velocity -
// makeWhiz -
//-----------------------------------------------------------------------------
void FX_AR2Tracer( Vector& start, Vector& end, int velocity, bool makeWhiz )
{
VPROF_BUDGET( "FX_AR2Tracer", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
//Don't make small tracers
float dist;
Vector dir;
VectorSubtract( end, start, dir );
dist = VectorNormalize( dir );
// Don't make short tracers.
if ( dist < 128 )
return;
float length = random->RandomFloat( 128.0f, 256.0f );
float life = ( dist + length ) / velocity; //NOTENOTE: We want the tail to finish its run as well
//Add it
FX_AddDiscreetLine( start, dir, velocity, length, dist, random->RandomFloat( 0.5f, 1.5f ), life, "effects/gunshiptracer" );
if( makeWhiz )
{
FX_TracerSound( start, end, TRACER_TYPE_GUNSHIP );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void AR2TracerCallback( const CEffectData &data )
{
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
if ( player == NULL )
return;
// Grab the data
Vector vecStart = GetTracerOrigin( data );
float flVelocity = data.m_flScale;
bool bWhiz = (data.m_fFlags & TRACER_FLAG_WHIZ);
int iEntIndex = data.entindex();
if ( iEntIndex && iEntIndex == player->index )
{
Vector foo = data.m_vStart;
QAngle vangles;
Vector vforward, vright, vup;
engine->GetViewAngles( vangles );
AngleVectors( vangles, &vforward, &vright, &vup );
VectorMA( data.m_vStart, 4, vright, foo );
foo[2] -= 0.5f;
FX_PlayerAR2Tracer( foo, (Vector&)data.m_vOrigin );
return;
}
// Use default velocity if none specified
if ( !flVelocity )
{
flVelocity = 8000;
}
// Do tracer effect
FX_AR2Tracer( (Vector&)vecStart, (Vector&)data.m_vOrigin, flVelocity, bWhiz );
}
DECLARE_CLIENT_EFFECT( "AR2Tracer", AR2TracerCallback );
//-----------------------------------------------------------------------------
// Purpose:
// Input : &data -
//-----------------------------------------------------------------------------
void AR2ExplosionCallback( const CEffectData &data )
{
float lifetime = random->RandomFloat( 0.4f, 0.75f );
// Ground splash
FX_AddQuad( data.m_vOrigin,
data.m_vNormal,
data.m_flRadius,
data.m_flRadius * 4.0f,
0.85f,
1.0f,
0.0f,
0.25f,
random->RandomInt( 0, 360 ),
random->RandomFloat( -4, 4 ),
Vector( 1.0f, 1.0f, 1.0f ),
lifetime,
"effects/combinemuzzle1",
(FXQUAD_BIAS_SCALE|FXQUAD_BIAS_ALPHA) );
Vector vRight, vUp;
VectorVectors( data.m_vNormal, vRight, vUp );
Vector start, end;
float radius = data.m_flRadius * 0.15f;
// Base vertical shaft
FXLineData_t lineData;
start = data.m_vOrigin;
end = start + ( data.m_vNormal * random->RandomFloat( radius*2.0f, radius*4.0f ) );
lineData.m_flDieTime = lifetime;
lineData.m_flStartAlpha= 1.0f;
lineData.m_flEndAlpha = 0.0f;
lineData.m_flStartScale = radius*4;
lineData.m_flEndScale = radius*5;
lineData.m_pMaterial = materials->FindMaterial( "effects/ar2ground2", 0, 0 );
lineData.m_vecStart = start;
lineData.m_vecStartVelocity = vec3_origin;
lineData.m_vecEnd = end;
lineData.m_vecEndVelocity = data.m_vNormal * random->RandomFloat( 200, 350 );
FX_AddLine( lineData );
// Inner filler shaft
start = data.m_vOrigin;
end = start + ( data.m_vNormal * random->RandomFloat( 16, radius*0.25f ) );
lineData.m_flDieTime = lifetime - 0.1f;
lineData.m_flStartAlpha= 1.0f;
lineData.m_flEndAlpha = 0.0f;
lineData.m_flStartScale = radius*2;
lineData.m_flEndScale = radius*4;
lineData.m_pMaterial = materials->FindMaterial( "effects/ar2ground2", 0, 0 );
lineData.m_vecStart = start;
lineData.m_vecStartVelocity = vec3_origin;
lineData.m_vecEnd = end;
lineData.m_vecEndVelocity = data.m_vNormal * random->RandomFloat( 64, 128 );
FX_AddLine( lineData );
}
DECLARE_CLIENT_EFFECT( "AR2Explosion", AR2ExplosionCallback );
//-----------------------------------------------------------------------------
// Purpose:
// Input : &data -
//-----------------------------------------------------------------------------
void AR2ImpactCallback( const CEffectData &data )
{
FX_AddQuad( data.m_vOrigin,
data.m_vNormal,
random->RandomFloat( 24, 32 ),
0,
0.75f,
1.0f,
0.0f,
0.4f,
random->RandomInt( 0, 360 ),
0,
Vector( 1.0f, 1.0f, 1.0f ),
0.25f,
"effects/combinemuzzle2_nocull",
(FXQUAD_BIAS_SCALE|FXQUAD_BIAS_ALPHA) );
}
DECLARE_CLIENT_EFFECT( "AR2Impact", AR2ImpactCallback );
//-----------------------------------------------------------------------------
// Creates a muzzleflash elight
//-----------------------------------------------------------------------------
void CreateMuzzleflashELight( const Vector &origin, int exponent, int nMinRadius, int nMaxRadius, ClientEntityHandle_t hEntity )
{
if ( muzzleflash_light.GetInt() )
{
int entityIndex = ClientEntityList().HandleToEntIndex( hEntity );
if ( entityIndex >= 0 )
{
dlight_t *el = effects->CL_AllocElight( LIGHT_INDEX_MUZZLEFLASH + entityIndex );
el->origin = origin;
el->color.r = 255;
el->color.g = 192;
el->color.b = 64;
el->color.exponent = exponent;
el->radius = random->RandomInt( nMinRadius, nMaxRadius );
el->decay = el->radius / 0.05f;
el->die = gpGlobals->curtime + 0.1f;
}
}
}
//-----------------------------------------------------------------------------
// Airboat muzzle flashes
//-----------------------------------------------------------------------------
void MuzzleFlash_Airboat( ClientEntityHandle_t hEntity, int attachmentIndex )
{
VPROF_BUDGET( "MuzzleFlash_Airboat", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
CSmartPtr<CLocalSpaceEmitter> pSimple = CLocalSpaceEmitter::Create( "MuzzleFlash", hEntity, attachmentIndex );
SimpleParticle *pParticle;
Vector forward(1,0,0), offset; //NOTENOTE: All coords are in local space
float flScale = random->RandomFloat( 0.75f, IsXbox() ? 2.0f : 2.5f );
PMaterialHandle pMuzzle[2];
pMuzzle[0] = pSimple->GetPMaterial( "effects/combinemuzzle1" );
pMuzzle[1] = pSimple->GetPMaterial( "effects/combinemuzzle2" );
// Flash
for ( int i = 1; i < 7; i++ )
{
offset = (forward * (i*6.0f*flScale));
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pMuzzle[random->RandomInt(0,1)], offset );
if ( pParticle == NULL )
return;
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = IsXbox() ? 0.0001f : 0.01f;
pParticle->m_vecVelocity.Init();
pParticle->m_uchColor[0] = 255;
pParticle->m_uchColor[1] = 255;
pParticle->m_uchColor[2] = 255;
pParticle->m_uchStartAlpha = 255;
pParticle->m_uchEndAlpha = 128;
pParticle->m_uchStartSize = ( (random->RandomFloat( 6.0f, 8.0f ) * (9-(i))/7) * flScale );
pParticle->m_uchEndSize = pParticle->m_uchStartSize;
pParticle->m_flRoll = random->RandomInt( 0, 360 );
pParticle->m_flRollDelta = 0.0f;
}
// Tack on the smoke
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "sprites/ar2_muzzle1" ), vec3_origin );
if ( pParticle == NULL )
return;
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = 0.05f;
pParticle->m_vecVelocity.Init();
pParticle->m_uchColor[0] = 255;
pParticle->m_uchColor[1] = 255;
pParticle->m_uchColor[2] = 255;
pParticle->m_uchStartAlpha = 255;
pParticle->m_uchEndAlpha = 128;
pParticle->m_uchStartSize = random->RandomFloat( 16.0f, 24.0f );
pParticle->m_uchEndSize = pParticle->m_uchStartSize;
float spokePos = random->RandomInt( 0, 5 );
pParticle->m_flRoll = (360.0/6.0f)*spokePos;
pParticle->m_flRollDelta = 0.0f;
#ifndef _XBOX
// Grab the origin out of the transform for the attachment
if ( muzzleflash_light.GetInt() )
{
// If the client hasn't seen this entity yet, bail.
matrix3x4_t matAttachment;
if ( FX_GetAttachmentTransform( hEntity, attachmentIndex, matAttachment ) )
{
Vector origin;
MatrixGetColumn( matAttachment, 3, &origin );
CreateMuzzleflashELight( origin, 5, 64, 128, hEntity );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void AirboatMuzzleFlashCallback( const CEffectData &data )
{
MuzzleFlash_Airboat( data.m_hEntity, data.m_nAttachmentIndex );
}
DECLARE_CLIENT_EFFECT( "AirboatMuzzleFlash", AirboatMuzzleFlashCallback );
//-----------------------------------------------------------------------------
// Chopper muzzle flashes
//-----------------------------------------------------------------------------
void MuzzleFlash_Chopper( ClientEntityHandle_t hEntity, int attachmentIndex )
{
VPROF_BUDGET( "MuzzleFlash_Chopper", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
matrix3x4_t matAttachment;
// If the client hasn't seen this entity yet, bail.
if ( !FX_GetAttachmentTransform( hEntity, attachmentIndex, matAttachment ) )
return;
CSmartPtr<CLocalSpaceEmitter> pSimple = CLocalSpaceEmitter::Create( "MuzzleFlash", hEntity, attachmentIndex );
SimpleParticle *pParticle;
Vector forward(1,0,0), offset; //NOTENOTE: All coords are in local space
float flScale = random->RandomFloat( 2.5f, 4.5f );
// Flash
for ( int i = 1; i < 7; i++ )
{
offset = (forward * (i*2.0f*flScale));
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( VarArgs( "effects/combinemuzzle%d", random->RandomInt(1,2) ) ), offset );
if ( pParticle == NULL )
return;
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = random->RandomFloat( 0.05f, 0.1f );
pParticle->m_vecVelocity.Init();
pParticle->m_uchColor[0] = 255;
pParticle->m_uchColor[1] = 255;
pParticle->m_uchColor[2] = 255;
pParticle->m_uchStartAlpha = 255;
pParticle->m_uchEndAlpha = 128;
pParticle->m_uchStartSize = ( (random->RandomFloat( 6.0f, 8.0f ) * (10-(i))/7) * flScale );
pParticle->m_uchEndSize = pParticle->m_uchStartSize;
pParticle->m_flRoll = random->RandomInt( 0, 360 );
pParticle->m_flRollDelta = 0.0f;
}
// Grab the origin out of the transform for the attachment
Vector origin;
MatrixGetColumn( matAttachment, 3, &origin );
CreateMuzzleflashELight( origin, 6, 128, 256, hEntity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ChopperMuzzleFlashCallback( const CEffectData &data )
{
MuzzleFlash_Chopper( data.m_hEntity, data.m_nAttachmentIndex );
}
DECLARE_CLIENT_EFFECT( "ChopperMuzzleFlash", ChopperMuzzleFlashCallback );
//-----------------------------------------------------------------------------
// Gunship muzzle flashes
//-----------------------------------------------------------------------------
void MuzzleFlash_Gunship( ClientEntityHandle_t hEntity, int attachmentIndex )
{
VPROF_BUDGET( "MuzzleFlash_Gunship", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
// If the client hasn't seen this entity yet, bail.
matrix3x4_t matAttachment;
if ( !FX_GetAttachmentTransform( hEntity, attachmentIndex, matAttachment ) )
return;
CSmartPtr<CLocalSpaceEmitter> pSimple = CLocalSpaceEmitter::Create( "MuzzleFlash", hEntity, attachmentIndex );
SimpleParticle *pParticle;
Vector forward(1,0,0), offset; //NOTENOTE: All coords are in local space
float flScale = random->RandomFloat( 2.5f, 4.5f );
// Flash
offset = (forward * (2.0f*flScale));
pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/gunshipmuzzle" ), offset );
if ( pParticle == NULL )
return;
pParticle->m_flLifetime = 0.0f;
pParticle->m_flDieTime = random->RandomFloat( 0.05f, 0.1f );
pParticle->m_vecVelocity.Init();
pParticle->m_uchColor[0] = 255;
pParticle->m_uchColor[1] = 255;
pParticle->m_uchColor[2] = 255;
pParticle->m_uchStartAlpha = 255;
pParticle->m_uchEndAlpha = 128;
pParticle->m_uchStartSize = ( (random->RandomFloat( 6.0f, 8.0f ) * 10.0/7.0) * flScale );
pParticle->m_uchEndSize = pParticle->m_uchStartSize;
pParticle->m_flRoll = random->RandomInt( 0, 360 );
pParticle->m_flRollDelta = 0.0f;
// Grab the origin out of the transform for the attachment
Vector origin;
MatrixGetColumn( matAttachment, 3, &origin );
CreateMuzzleflashELight( origin, 6, 128, 256, hEntity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void GunshipMuzzleFlashCallback( const CEffectData &data )
{
MuzzleFlash_Gunship( data.m_hEntity, data.m_nAttachmentIndex );
}
DECLARE_CLIENT_EFFECT( "GunshipMuzzleFlash", GunshipMuzzleFlashCallback );
//-----------------------------------------------------------------------------
// Hunter muzzle flashes
//-----------------------------------------------------------------------------
void MuzzleFlash_Hunter( ClientEntityHandle_t hEntity, int attachmentIndex )
{
VPROF_BUDGET( "MuzzleFlash_Hunter", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
// If the client hasn't seen this entity yet, bail.
matrix3x4_t matAttachment;
if ( !FX_GetAttachmentTransform( hEntity, attachmentIndex, matAttachment ) )
return;
// Grab the origin out of the transform for the attachment
Vector origin;
MatrixGetColumn( matAttachment, 3, &origin );
dlight_t *el = effects->CL_AllocElight( LIGHT_INDEX_MUZZLEFLASH );
el->origin = origin;// + Vector( 12.0f, 0, 0 );
el->color.r = 50;
el->color.g = 222;
el->color.b = 213;
el->color.exponent = 5;
el->radius = random->RandomInt( 120, 200 );
el->decay = el->radius / 0.05f;
el->die = gpGlobals->curtime + 0.05f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void HunterMuzzleFlashCallback( const CEffectData &data )
{
MuzzleFlash_Hunter( data.m_hEntity, data.m_nAttachmentIndex );
}
DECLARE_CLIENT_EFFECT( "HunterMuzzleFlash", HunterMuzzleFlashCallback );