992 lines
23 KiB
C++
992 lines
23 KiB
C++
#include "cg_local.h"
|
|
#include "FX_Public.h"
|
|
|
|
vec3_t WHITE = {1.0, 1.0, 1.0};
|
|
int numFX = 0;
|
|
|
|
void FX_PrintDebugInfo( void );
|
|
|
|
FX_state_t FX_renderList[ MAX_EFFECTS ];
|
|
FX_state_t *FX_nextValid = &FX_renderList[0];
|
|
|
|
#ifdef _DEBUG
|
|
|
|
#define HOP_RESOLUTION 32
|
|
#define ACTIVE_RESOLUTION 32 //Frames
|
|
|
|
int hopTable[ HOP_RESOLUTION ];
|
|
int curHop = 0;
|
|
int hopAverage = 0;
|
|
|
|
int activeTable[ ACTIVE_RESOLUTION ];
|
|
int curActive = 0;
|
|
int activeAverage = 0;
|
|
|
|
#endif
|
|
|
|
/*
|
|
===============
|
|
FX_Init
|
|
|
|
Allocates all FX
|
|
===============
|
|
*/
|
|
|
|
int FX_Init( void )
|
|
{
|
|
FX_Free(); //Make sure the system is cleaned out
|
|
FXMEM_Init(); //Flush out the memory manager
|
|
|
|
FX_nextValid = &FX_renderList[0];
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
FX_FreeMember
|
|
-------------------------
|
|
*/
|
|
|
|
void FX_FreeMember( FX_state_t *state )
|
|
{
|
|
numFX--;
|
|
|
|
delete state->effect;
|
|
state->effect = NULL;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_Free
|
|
|
|
Frees all FX
|
|
===============
|
|
*/
|
|
|
|
int FX_Free( void )
|
|
{
|
|
for ( int i = 0; i < MAX_EFFECTS; i++ )
|
|
{
|
|
if ( FX_renderList[ i ].effect == NULL )
|
|
continue;
|
|
|
|
FX_FreeMember( &FX_renderList[ i ] );
|
|
}
|
|
|
|
//Clear the FX memory
|
|
FXMEM_Flush();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_Add
|
|
|
|
Adds all client effects (within the FX wrapper) to the view
|
|
===============
|
|
*/
|
|
|
|
void FX_Add( void )
|
|
{
|
|
FX_state_t *state;
|
|
|
|
#ifdef _DEBUG
|
|
|
|
FXMEMD_searchPeak = 0;
|
|
FXMEMD_allocListPeak = 0;
|
|
FXMEMD_freeListPeak = 0;
|
|
FXMEMD_allocatePeak = 0;
|
|
|
|
#endif
|
|
|
|
for ( int i = 0; i < MAX_EFFECTS; i++ )
|
|
{
|
|
if ( FX_renderList[ i ].effect == NULL )
|
|
continue;
|
|
|
|
state = &FX_renderList[ i ];
|
|
|
|
if ( cg_freezeFX.integer )
|
|
state->killTime += cg.frametime; //Keep the effects alive
|
|
|
|
//Clean up old events
|
|
if ( ( ( state->killTime < cg.time ) && ( state->killTime != -1 ) ) )
|
|
{
|
|
//Free out the effect primitive
|
|
FX_FreeMember( state );
|
|
continue;
|
|
}
|
|
|
|
//Update the effect
|
|
if ( !cg_freezeFX.integer && ( cg.frametime > 0 ) ) //not paused
|
|
{
|
|
//If the function returns false, this effect has been removed
|
|
if ( state->effect->Update() == qfalse )
|
|
{
|
|
FX_FreeMember( state );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//Cull the effect
|
|
if ( state->effect->Cull() == qfalse )
|
|
{
|
|
//Draw the effect
|
|
state->effect->Draw();
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
|
|
curActive++;
|
|
|
|
if ( curActive > ( ACTIVE_RESOLUTION - 1 ) )
|
|
{
|
|
curActive = 0;
|
|
activeAverage = 0;
|
|
|
|
for ( int i = 0; i < ACTIVE_RESOLUTION; i++ )
|
|
activeAverage += activeTable[ i ];
|
|
|
|
activeAverage /= ACTIVE_RESOLUTION;
|
|
|
|
for ( i = 0; i < ACTIVE_RESOLUTION; i++ )
|
|
activeTable[ i ] = 0;
|
|
}
|
|
|
|
activeTable[ curActive ] = numFX;
|
|
|
|
#endif
|
|
|
|
//Print any debugging information, if requested
|
|
if ( cg_debugFX.value )
|
|
FX_PrintDebugInfo();
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
FX_FindNextValid
|
|
-------------------------
|
|
*/
|
|
|
|
FX_state_t *FX_FindNextValid( void )
|
|
{
|
|
|
|
#ifdef _DEBUG
|
|
|
|
//Compute the new hop average if applicable
|
|
|
|
curHop++;
|
|
|
|
if ( curHop > ( HOP_RESOLUTION - 1 ) )
|
|
{
|
|
curHop = 0;
|
|
hopAverage = 0;
|
|
|
|
for ( int i = 0; i < HOP_RESOLUTION; i++ )
|
|
hopAverage += hopTable[ i ];
|
|
|
|
hopAverage /= HOP_RESOLUTION;
|
|
|
|
for ( i = 0; i < HOP_RESOLUTION; i++ )
|
|
hopTable[ i ] = 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
for ( int i = 0; i < MAX_EFFECTS; i++ )
|
|
{
|
|
FX_nextValid = ( ( FX_nextValid + 1 ) > &FX_renderList[ MAX_EFFECTS - 1 ] ) ? &FX_renderList[ 0 ] : FX_nextValid + 1;
|
|
|
|
#ifdef _DEBUG
|
|
|
|
hopTable[ curHop ]++; //Increment the number of hops made
|
|
|
|
#endif
|
|
|
|
if ( FX_nextValid->effect == NULL )
|
|
return FX_nextValid;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
FX_AddPrimitive
|
|
-------------------------
|
|
*/
|
|
|
|
void FX_AddPrimitive( FXPrimitive *primitive, int killTime )
|
|
{
|
|
//assert( cg.frametime >= 0 );
|
|
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
{
|
|
delete primitive;
|
|
return;
|
|
}
|
|
|
|
if ( ( FX_nextValid == NULL ) || ( FX_nextValid->effect ) )
|
|
{
|
|
//Com_Printf("MAX EFFECTS REACHED!\n");
|
|
FX_nextValid = &FX_renderList[ 0 ]; //FIXME: Blah
|
|
FX_FreeMember( FX_nextValid );
|
|
}
|
|
|
|
//If this effect is free, take it over
|
|
if ( FX_nextValid->effect == NULL )
|
|
{
|
|
// Stash these in the primitive so it has easy access to the vals
|
|
primitive->m_start_time = cg.time;
|
|
primitive->m_end_time = killTime;
|
|
|
|
FX_nextValid->effect = primitive;
|
|
FX_nextValid->killTime = killTime;
|
|
|
|
FX_nextValid = FX_FindNextValid();
|
|
|
|
numFX++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddSprite
|
|
|
|
Adds a sprite to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
inline FXSprite *FX_AddSprite( vec3_t origin, vec3_t velocity, vec3_t acceleration, float scale, float dscale, float startalpha, float endalpha, float roll, float elasticity, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddSprite( origin, velocity, acceleration, scale, dscale,
|
|
startalpha, endalpha, WHITE, WHITE,
|
|
roll, elasticity, killTime, shader, flags );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddSprite
|
|
|
|
Adds a sprite to the FX wrapper render list
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXSprite *FX_AddSprite( vec3_t origin, vec3_t velocity, vec3_t acceleration, float scale, float dscale, float startalpha, float endalpha, vec3_t startRGB, vec3_t endRGB, float roll, float elasticity, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXSprite *sprite;
|
|
|
|
sprite = new FXSprite;
|
|
|
|
sprite->SetOrigin( origin );
|
|
sprite->SetVelocity( velocity );
|
|
sprite->SetAcceleration( acceleration );
|
|
sprite->SetShader( shader );
|
|
sprite->SetScale( scale );
|
|
sprite->SetStartAlpha( startalpha );
|
|
sprite->SetElasticity( elasticity );
|
|
|
|
sprite->SetScaleDelta( dscale );
|
|
sprite->SetEndAlpha( endalpha );
|
|
|
|
sprite->SetStartRGB( startRGB );
|
|
sprite->SetEndRGB( endRGB );
|
|
|
|
sprite->SetRoll( 0 ); //FIXME: Pass this in
|
|
sprite->SetRollDelta( roll );
|
|
|
|
sprite->SetFlags( flags );
|
|
|
|
FX_AddPrimitive( sprite, killTime + cg.time );
|
|
|
|
return sprite;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddElectricity
|
|
|
|
Adds a electricity bolt to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
inline FXElectricity *FX_AddElectricity( vec3_t origin, vec3_t origin2, float stScale, float scale, float dscale,
|
|
float startalpha, float endalpha, float killTime, qhandle_t shader,
|
|
int flags, float deviation )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXElectricity *electricity;
|
|
|
|
electricity = new FXElectricity;
|
|
|
|
electricity->SetOrigin( origin );
|
|
electricity->SetOrigin2( origin2 );
|
|
electricity->SetShader( shader );
|
|
electricity->SetScale( scale );
|
|
electricity->SetStartAlpha( startalpha );
|
|
|
|
electricity->SetStartRGB( WHITE );
|
|
electricity->SetEndRGB( WHITE );
|
|
|
|
electricity->SetScaleDelta( dscale );
|
|
electricity->SetEndAlpha( endalpha );
|
|
electricity->SetFlags( flags );
|
|
|
|
electricity->SetSTScale( stScale );
|
|
electricity->SetDeviation( deviation );
|
|
|
|
electricity->Build();
|
|
|
|
FX_AddPrimitive( electricity, killTime + cg.time );
|
|
|
|
return electricity;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddElectricity
|
|
|
|
Adds a electricity bolt to the FX wrapper render list
|
|
overloaded to pass default deviation
|
|
===============
|
|
*/
|
|
|
|
inline FXElectricity *FX_AddElectricity( vec3_t origin, vec3_t origin2, float stScale, float scale, float dscale,
|
|
float startalpha, float endalpha, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddElectricity( origin, origin2, stScale, scale, dscale, startalpha, endalpha, killTime, shader, flags, DEFAULT_DEVIATION );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddParticle
|
|
|
|
Adds a particle to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
inline FXParticle *FX_AddParticle( centity_t *owner, vec3_t origin, vec3_t velocity, vec3_t acceleration, float scale, float dscale, float startalpha, float endalpha, float roll, float elasticity, float killTime, qhandle_t shader, int flags, bool (*think)(FXPrimitive *, centity_t *) )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddParticle( owner, origin, velocity, acceleration, scale, dscale,
|
|
startalpha, endalpha, WHITE, WHITE,
|
|
roll, elasticity, killTime, shader, flags, think );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddParticle
|
|
|
|
Adds a particle to the FX wrapper render list
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXParticle *FX_AddParticle( centity_t *owner, vec3_t origin, vec3_t velocity, vec3_t acceleration, float scale, float dscale, float startalpha, float endalpha, vec3_t startRGB, vec3_t endRGB, float roll, float elasticity, float killTime, qhandle_t shader, int flags, bool (*think)(FXPrimitive *, centity_t *) )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXParticle *particle;
|
|
|
|
particle = new FXParticle;
|
|
|
|
particle->SetOrigin( origin );
|
|
particle->SetVelocity( velocity );
|
|
particle->SetAcceleration( acceleration );
|
|
particle->SetShader( shader );
|
|
particle->SetScale( scale );
|
|
particle->SetStartAlpha( startalpha );
|
|
particle->SetElasticity( elasticity );
|
|
|
|
particle->SetScaleDelta( dscale );
|
|
particle->SetEndAlpha( endalpha );
|
|
|
|
particle->SetStartRGB( startRGB );
|
|
particle->SetEndRGB( endRGB );
|
|
|
|
particle->SetRoll( 0 ); //FIXME: Pass this in
|
|
particle->SetRollDelta( roll );
|
|
|
|
particle->SetFlags( flags );
|
|
particle->SetThink( think );
|
|
particle->SetCOwner( owner );
|
|
|
|
FX_AddPrimitive( particle, killTime + cg.time );
|
|
|
|
return particle;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddTri
|
|
|
|
Adds a triangle to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
inline FXTri *FX_AddTri( vec3_t origin, vec3_t origin2, vec3_t origin3, float startalpha, float endalpha, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddTri( origin, origin2, origin3, startalpha, endalpha, WHITE, WHITE, killTime, shader, flags );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddTri
|
|
|
|
Adds a triangle to the FX wrapper render list
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXTri *FX_AddTri( vec3_t origin, vec3_t origin2, vec3_t origin3, float startalpha, float endalpha, vec3_t startRGB, vec3_t endRGB, float killTime, qhandle_t shader, int flags)
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXTri *tri;
|
|
|
|
tri = new FXTri;
|
|
|
|
tri->SetOrigin( origin );
|
|
tri->SetOrigin2( origin2 );
|
|
tri->SetOrigin3( origin3 );
|
|
|
|
tri->SetShader( shader );
|
|
|
|
tri->SetStartAlpha( startalpha );
|
|
tri->SetEndAlpha( endalpha );
|
|
|
|
tri->SetStartRGB( startRGB );
|
|
tri->SetEndRGB( endRGB );
|
|
|
|
tri->SetFlags( flags );
|
|
|
|
FX_AddPrimitive( tri, killTime + cg.time );
|
|
|
|
return tri;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddQuad
|
|
|
|
Adds a quad to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
inline FXQuad *FX_AddQuad( vec3_t origin, vec3_t normal, vec3_t velocity, vec3_t acceleration, float scale, float dscale, float startalpha, float endalpha, float roll, float droll, float elasticity, float killTime, qhandle_t shader )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddQuad( origin, normal, velocity, acceleration,
|
|
scale, dscale, startalpha, endalpha, WHITE, WHITE,
|
|
roll, droll, elasticity, killTime, shader );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddQuad
|
|
|
|
Adds a quad to the FX wrapper render list
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXQuad *FX_AddQuad( vec3_t origin, vec3_t normal, vec3_t velocity, vec3_t acceleration, float scale, float dscale, float startalpha, float endalpha, vec3_t startRGB, vec3_t endRGB, float roll, float droll, float elasticity, float killTime, qhandle_t shader )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXQuad *quad;
|
|
|
|
quad = new FXQuad;
|
|
|
|
quad->SetOrigin( origin );
|
|
quad->SetNormal( normal );
|
|
quad->SetVelocity( velocity );
|
|
quad->SetAcceleration( acceleration );
|
|
quad->SetShader( shader );
|
|
quad->SetScale( scale );
|
|
quad->SetStartAlpha( startalpha );
|
|
|
|
quad->SetStartRGB( startRGB );
|
|
quad->SetEndRGB( endRGB );
|
|
|
|
quad->SetElasticity( elasticity );
|
|
|
|
quad->SetScaleDelta( dscale * 4 );
|
|
quad->SetEndAlpha( endalpha );
|
|
|
|
quad->SetRoll( roll );
|
|
quad->SetRollDelta( droll );
|
|
|
|
FX_AddPrimitive( quad, killTime + cg.time );
|
|
|
|
return quad;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddLine
|
|
|
|
Adds a line to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
inline FXLine *FX_AddLine( vec3_t origin, vec3_t origin2, float stScale, float scale, float dscale, float startalpha, float endalpha, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddLine( origin, origin2, stScale, scale, dscale,
|
|
startalpha, endalpha, WHITE, WHITE,
|
|
killTime, shader, flags );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddLine
|
|
|
|
Adds a line to the FX wrapper render list
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXLine *FX_AddLine( vec3_t origin, vec3_t origin2, float stScale, float scale, float dscale, float startalpha, float endalpha, vec3_t startRGB, vec3_t endRGB, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXLine *line;
|
|
|
|
// Check to see if we need to generate a new ST scale based on the line length...
|
|
// this will cure the problem of textures on lines getting stretched out ( dreadnought gun ).
|
|
if ( flags & FXF_ADJUST_ST )
|
|
{
|
|
vec3_t dis;
|
|
float len;
|
|
|
|
VectorSubtract( origin, origin2, dis );
|
|
len = VectorNormalize( dis );
|
|
|
|
stScale = len / stScale;
|
|
}
|
|
|
|
line = new FXLine;
|
|
|
|
line->SetOrigin( origin );
|
|
line->SetOrigin2( origin2 );
|
|
line->SetShader( shader );
|
|
line->SetScale( scale );
|
|
line->SetStartAlpha( startalpha );
|
|
|
|
line->SetStartRGB( startRGB );
|
|
line->SetEndRGB( endRGB );
|
|
|
|
line->SetScaleDelta( dscale );
|
|
line->SetEndAlpha( endalpha );
|
|
|
|
line->SetFlags( flags );
|
|
line->SetSTScale( stScale );
|
|
line->SetEndcapShader( 0 );
|
|
|
|
FX_AddPrimitive( line, killTime + cg.time );
|
|
|
|
return line;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddLine2
|
|
|
|
Adds a line to the FX wrapper render list
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXLine2 *FX_AddLine2( vec3_t origin, vec3_t origin2, float stScale, float scale, float dscale, float scale2, float dscale2, float startalpha, float endalpha, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXLine2 *line;
|
|
|
|
line = new FXLine2;
|
|
|
|
line->SetOrigin( origin );
|
|
line->SetOrigin2( origin2 );
|
|
line->SetShader( shader );
|
|
line->SetScale( scale );
|
|
line->SetScale2( scale2 );
|
|
line->SetStartAlpha( startalpha );
|
|
|
|
line->SetStartRGB( WHITE );
|
|
line->SetEndRGB( WHITE );
|
|
|
|
line->SetScaleDelta( dscale );
|
|
line->SetScale2Delta( dscale2 );
|
|
line->SetEndAlpha( endalpha );
|
|
|
|
line->SetFlags( flags );
|
|
line->SetSTScale( stScale );
|
|
line->SetEndcapShader( 0 );
|
|
|
|
FX_AddPrimitive( line, killTime + cg.time );
|
|
|
|
return line;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddSpawner
|
|
===============
|
|
*/
|
|
|
|
inline FXSpawner *FX_AddSpawner( vec3_t origin, vec3_t angles, vec3_t velocity, vec3_t user, int delay, float variance, float killTime, void *think, localEntity_t *owner, int radius )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddSpawner( origin, angles, velocity, user, delay, variance, killTime, 0, think, owner, radius );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddSpawner
|
|
===============
|
|
*/
|
|
|
|
inline FXSpawner *FX_AddSpawner( vec3_t origin, vec3_t angles, vec3_t velocity, vec3_t user, int delay, float variance, float killTime, int flags, void *think, localEntity_t *owner, int radius )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXSpawner *spawner;
|
|
|
|
spawner = new FXSpawner;
|
|
|
|
spawner->SetOrigin( origin );
|
|
spawner->SetAngles( angles );
|
|
spawner->SetVelocity( velocity );
|
|
spawner->SetStartRGB( user );
|
|
|
|
spawner->SetDelay( delay );
|
|
spawner->SetVariance( variance );
|
|
|
|
spawner->SetFlags( flags );
|
|
spawner->SetRadius( radius );
|
|
|
|
spawner->SetOwner( owner );
|
|
|
|
spawner->Think = (void (__cdecl *)(vec3_t, vec3_t, vec3_t, vec3_t)) think;
|
|
|
|
if ( flags & FXF_DELAY_SPAWN )
|
|
{
|
|
spawner->m_nextThink = cg.time + ( ( delay + ( variance * crandom() )) );
|
|
}
|
|
else
|
|
{
|
|
spawner->m_nextThink = cg.time;
|
|
}
|
|
|
|
if ( killTime > 0 )
|
|
FX_AddPrimitive( spawner, killTime + cg.time );
|
|
else
|
|
FX_AddPrimitive( spawner, killTime );
|
|
|
|
return spawner;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddBezier
|
|
|
|
Adds a bezier curve
|
|
===============
|
|
*/
|
|
|
|
inline FXBezier *FX_AddBezier( vec3_t origin, vec3_t origin2, vec3_t control1, vec3_t control2, vec3_t control1_vel, vec3_t control2_vel, vec3_t control1_accel, vec3_t control2_accel, float scale, float dscale, float startalpha, float endalpha, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddBezier( origin, origin2, control1, control2,
|
|
control1_vel, control2_vel, control1_accel, control2_accel,
|
|
scale, dscale, startalpha, endalpha, WHITE, WHITE,
|
|
killTime, shader, flags );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddBezier
|
|
|
|
Adds a bezier curve
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXBezier *FX_AddBezier( vec3_t origin, vec3_t origin2, vec3_t control1, vec3_t control2, vec3_t control1_vel, vec3_t control2_vel, vec3_t control1_accel, vec3_t control2_accel, float scale, float dscale, float startalpha, float endalpha, vec3_t startRGB, vec3_t endRGB, float killTime, qhandle_t shader, int flags )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXBezier *bezier;
|
|
|
|
bezier = new FXBezier;
|
|
|
|
bezier->SetOrigin( origin );
|
|
bezier->SetOrigin2( origin2 );
|
|
bezier->SetShader( shader );
|
|
bezier->SetScale( scale );
|
|
bezier->SetStartAlpha( startalpha );
|
|
|
|
bezier->SetStartRGB( startRGB );
|
|
bezier->SetEndRGB( endRGB );
|
|
|
|
bezier->SetScaleDelta( dscale );
|
|
bezier->SetEndAlpha( endalpha );
|
|
|
|
bezier->SetControl1( control1 );
|
|
bezier->SetControl2( control2 );
|
|
|
|
bezier->SetControl1_Velocity( control1_vel );
|
|
bezier->SetControl2_Velocity( control2_vel );
|
|
|
|
bezier->SetControl1_Acceleration( control1_accel );
|
|
bezier->SetControl2_Acceleration( control2_accel );
|
|
|
|
bezier->SetFlags( flags );
|
|
|
|
FX_AddPrimitive( bezier, killTime + cg.time );
|
|
|
|
return bezier;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddTrail
|
|
|
|
Adds a trail to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
inline FXTrail *FX_AddTrail( vec3_t origin, vec3_t velocity, vec3_t acceleration, float length, float dlength, float scale, float dscale, float startalpha, float endalpha, float elasticity, float killTime, qhandle_t shader, int flags)
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddTrail( origin, velocity, acceleration, length, dlength, scale, dscale,
|
|
startalpha, endalpha, WHITE, WHITE, elasticity,
|
|
killTime, shader, flags);
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddTrail
|
|
|
|
Adds a trail to the FX wrapper render list
|
|
overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
inline FXTrail *FX_AddTrail( vec3_t origin, vec3_t velocity, vec3_t acceleration, float length, float dlength, float scale, float dscale, float startalpha, float endalpha, vec3_t startRGB, vec3_t endRGB, float elasticity, float killTime, qhandle_t shader, int flags)
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXTrail *trail;
|
|
|
|
trail = new FXTrail;
|
|
|
|
trail->SetLength( length );
|
|
trail->SetLengthDelta( dlength );
|
|
|
|
trail->SetOrigin( origin );
|
|
trail->SetOldOrigin( origin );
|
|
trail->SetVelocity( velocity );
|
|
trail->SetAcceleration( acceleration );
|
|
trail->SetShader( shader );
|
|
trail->SetScale( scale );
|
|
trail->SetStartAlpha( startalpha );
|
|
trail->SetElasticity( elasticity );
|
|
|
|
trail->SetStartRGB( startRGB );
|
|
trail->SetEndRGB( endRGB );
|
|
|
|
trail->SetScaleDelta( dscale );
|
|
trail->SetEndAlpha( endalpha );
|
|
|
|
trail->SetFlags( flags );
|
|
|
|
FX_AddPrimitive( trail, killTime + cg.time );
|
|
|
|
return trail;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddCylinder
|
|
|
|
Adds a cylinder to the FX wrapper render list
|
|
===============
|
|
*/
|
|
|
|
//NOTENOTE: The reigning king of parameters!
|
|
|
|
inline FXCylinder *FX_AddCylinder( vec3_t start,
|
|
vec3_t normal,
|
|
float height,
|
|
float dheight,
|
|
float scale,
|
|
float dscale,
|
|
float scale2,
|
|
float dscale2,
|
|
float startalpha,
|
|
float endalpha,
|
|
float killTime,
|
|
qhandle_t shader,
|
|
float bias )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
return FX_AddCylinder( start, normal, height, dheight, scale, dscale, scale2, dscale2,
|
|
startalpha, endalpha, WHITE, WHITE, killTime, shader, bias );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_AddCylinder
|
|
|
|
Adds a cylinder to the FX wrapper render list
|
|
Overloaded for RGB
|
|
===============
|
|
*/
|
|
|
|
//NOTENOTE: The reigning king of parameters!
|
|
#define DEFAULT_ST_SCALE 1.0f
|
|
|
|
inline FXCylinder *FX_AddCylinder( vec3_t start,
|
|
vec3_t normal,
|
|
float height,
|
|
float dheight,
|
|
float scale,
|
|
float dscale,
|
|
float scale2,
|
|
float dscale2,
|
|
float startalpha,
|
|
float endalpha,
|
|
vec3_t startRGB,
|
|
vec3_t endRGB,
|
|
float killTime,
|
|
qhandle_t shader,
|
|
float bias )
|
|
{
|
|
if (cg.frametime <= 0) //skip out if paused
|
|
return NULL;
|
|
|
|
FXCylinder *cylinder;
|
|
|
|
cylinder = new FXCylinder;
|
|
|
|
cylinder->SetStart( start );
|
|
cylinder->SetNormal( normal );
|
|
|
|
cylinder->SetHeight( height );
|
|
cylinder->SetHeightDelta( dheight );
|
|
|
|
cylinder->SetScale( scale );
|
|
cylinder->SetScaleDelta( dscale );
|
|
|
|
cylinder->SetScale2( scale2 );
|
|
cylinder->SetScaleDelta2( dscale2 );
|
|
|
|
cylinder->SetStartAlpha( startalpha );
|
|
cylinder->SetEndAlpha( endalpha );
|
|
|
|
cylinder->SetStartRGB( startRGB );
|
|
cylinder->SetEndRGB( endRGB );
|
|
|
|
cylinder->SetShader( shader );
|
|
|
|
cylinder->SetBias( bias );
|
|
cylinder->SetSTScale( DEFAULT_ST_SCALE );
|
|
|
|
if ( killTime > 0 )
|
|
FX_AddPrimitive( cylinder, killTime + cg.time );
|
|
else
|
|
FX_AddPrimitive( cylinder, killTime );
|
|
|
|
return cylinder;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
FX_DetailLevel
|
|
|
|
Returns a value for the relative detail level an effect has
|
|
===============
|
|
*/
|
|
|
|
float FX_DetailLevel( vec3_t origin, float near_clip, float far_clip )
|
|
{
|
|
vec3_t dir;
|
|
float len;
|
|
|
|
//TODO: Account for the FOV range
|
|
|
|
VectorSubtract( origin, cg.refdef.vieworg, dir );
|
|
len = VectorNormalize( dir );
|
|
|
|
if ( len < near_clip )
|
|
return 0.0f;
|
|
|
|
if ( len > far_clip )
|
|
return 0.0f;
|
|
|
|
return (float) len / far_clip;
|
|
}
|
|
|
|
/*
|
|
-------------------------
|
|
FX_PrintDebugInfo
|
|
-------------------------
|
|
*/
|
|
|
|
void FX_PrintDebugInfo( void )
|
|
{
|
|
Com_Printf( "Number of Effects Active: %d\n", numFX );
|
|
|
|
#ifdef _DEBUG
|
|
|
|
Com_Printf( "Average Hops: %d\n", hopAverage );
|
|
Com_Printf( "Average Active Effects: %d\n", activeAverage );
|
|
|
|
#endif
|
|
|
|
if ( fx_memoryInfo.value )
|
|
FXMEM_PrintDebugInfo();
|
|
}
|