forked from a1batross/Paranoia2_original
1171 lines
29 KiB
C++
1171 lines
29 KiB
C++
// 02/08/02 November235: Particle System
|
|
#include "hud.h"
|
|
#include "cl_util.h"
|
|
#include "const.h"
|
|
#include <stringlib.h>
|
|
#include "entity_state.h"
|
|
#include "event_api.h"
|
|
#include "cl_entity.h"
|
|
#include "triangleapi.h"
|
|
#include "com_model.h"
|
|
#include "pmtrace.h" // for contents and traceline
|
|
#include "pm_defs.h"
|
|
#include "gl_local.h"
|
|
#include "gl_studio.h"
|
|
#include "gl_aurora.h"
|
|
|
|
CParticleSystemManager g_pParticleSystems; // buz - static single object
|
|
|
|
void UTIL_CreateAurora( cl_entity_t *ent, const char *file, int attachment, float lifetime )
|
|
{
|
|
if( !g_fXashEngine || !g_fRenderInitialized )
|
|
return;
|
|
|
|
int iCompare;
|
|
|
|
// verify file exists
|
|
// g-cont. idea! use COMPARE_FILE_TIME instead of LOAD_FILE
|
|
if( COMPARE_FILE_TIME( file, file, &iCompare ))
|
|
{
|
|
CParticleSystem *pSystem = new CParticleSystem( ent, file, attachment, lifetime );
|
|
g_pParticleSystems.AddSystem( pSystem );
|
|
}
|
|
else
|
|
{
|
|
ALERT( at_error, "CreateAurora: couldn't load %s\n", file );
|
|
}
|
|
}
|
|
|
|
void UTIL_RemoveAurora( cl_entity_t *ent )
|
|
{
|
|
if( !g_fXashEngine || !g_fRenderInitialized )
|
|
return;
|
|
|
|
CParticleSystem *pSystem = g_pParticleSystems.FindSystem( NULL, ent );
|
|
|
|
// find all the partsystems that attached with this entity
|
|
while( pSystem != NULL )
|
|
{
|
|
g_pParticleSystems.MarkSystemForDeletion( pSystem );
|
|
pSystem = g_pParticleSystems.FindSystem( pSystem, ent );
|
|
}
|
|
}
|
|
|
|
CParticleSystemManager :: CParticleSystemManager( void )
|
|
{
|
|
m_pFirstSystem = NULL;
|
|
}
|
|
|
|
CParticleSystemManager :: ~CParticleSystemManager( void )
|
|
{
|
|
ClearSystems();
|
|
}
|
|
|
|
void CParticleSystemManager :: AddSystem( CParticleSystem *pNewSystem )
|
|
{
|
|
pNewSystem->m_pNextSystem = m_pFirstSystem;
|
|
m_pFirstSystem = pNewSystem;
|
|
}
|
|
|
|
CParticleSystem *CParticleSystemManager :: FindSystem( CParticleSystem *pFirstSystem, cl_entity_t *pEntity )
|
|
{
|
|
CParticleSystem *pSys;
|
|
|
|
if( pFirstSystem != NULL )
|
|
pSys = pFirstSystem->m_pNextSystem;
|
|
else pSys = m_pFirstSystem;
|
|
|
|
while( pSys != NULL )
|
|
{
|
|
if( pEntity == pSys->m_pEntity )
|
|
return pSys;
|
|
pSys = pSys->m_pNextSystem;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void CParticleSystemManager :: MarkSystemForDeletion( CParticleSystem *pSys )
|
|
{
|
|
// parent entity is removed from server.
|
|
pSys->MarkForDeletion();
|
|
pSys->m_pEntity = NULL;
|
|
}
|
|
|
|
// blended particles don't use the z-buffer, so we need to sort them before drawing.
|
|
// for efficiency, only the systems are sorted - individual particles just get drawn in order of creation.
|
|
// (this should actually make things look better - no ugly popping when one particle passes through another.)
|
|
void CParticleSystemManager :: SortSystems( void )
|
|
{
|
|
CParticleSystem *pSystem, *pLast;
|
|
CParticleSystem *pBeforeCompare, *pCompare;
|
|
|
|
if( !m_pFirstSystem ) return;
|
|
|
|
// calculate how far away each system is from the viewer
|
|
for( pSystem = m_pFirstSystem; pSystem; pSystem = pSystem->m_pNextSystem )
|
|
pSystem->CalculateDistance();
|
|
|
|
// do an insertion sort on the systems
|
|
pLast = m_pFirstSystem;
|
|
pSystem = pLast->m_pNextSystem;
|
|
|
|
while( pSystem )
|
|
{
|
|
if( pLast->m_fViewerDist < pSystem->m_fViewerDist )
|
|
{
|
|
// pSystem is in the wrong place! First, let's unlink it from the list
|
|
pLast->m_pNextSystem = pSystem->m_pNextSystem;
|
|
|
|
// then find somewhere to insert it
|
|
if( m_pFirstSystem == pLast || m_pFirstSystem->m_fViewerDist < pSystem->m_fViewerDist )
|
|
{
|
|
// pSystem comes before the first system, insert it there
|
|
pSystem->m_pNextSystem = m_pFirstSystem;
|
|
m_pFirstSystem = pSystem;
|
|
}
|
|
else
|
|
{
|
|
// insert pSystem somewhere within the sorted part of the list
|
|
pBeforeCompare = m_pFirstSystem;
|
|
pCompare = pBeforeCompare->m_pNextSystem;
|
|
|
|
while( pCompare != pLast )
|
|
{
|
|
if( pCompare->m_fViewerDist < pSystem->m_fViewerDist )
|
|
{
|
|
// pSystem comes before pCompare. We've found where it belongs.
|
|
break;
|
|
}
|
|
|
|
pBeforeCompare = pCompare;
|
|
pCompare = pBeforeCompare->m_pNextSystem;
|
|
}
|
|
|
|
// we've found where pSystem belongs. Insert it between pBeforeCompare and pCompare.
|
|
pBeforeCompare->m_pNextSystem = pSystem;
|
|
pSystem->m_pNextSystem = pCompare;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// pSystem is in the right place, move on
|
|
pLast = pSystem;
|
|
}
|
|
|
|
pSystem = pLast->m_pNextSystem;
|
|
}
|
|
}
|
|
|
|
void CParticleSystemManager :: UpdateSystems( void )
|
|
{
|
|
AURSTATE state;
|
|
|
|
if( FBitSet( RI->params, ( RP_ENVVIEW|RP_SKYVIEW )))
|
|
return;
|
|
|
|
CParticleSystem *pSystem;
|
|
CParticleSystem *pLast = NULL;
|
|
pSystem = m_pFirstSystem;
|
|
|
|
while( pSystem )
|
|
{
|
|
state = pSystem->UpdateSystem( tr.frametime );
|
|
|
|
if( state != AURORA_REMOVE )
|
|
{
|
|
if( state == AURORA_DRAW )
|
|
pSystem->DrawSystem();
|
|
|
|
pLast = pSystem;
|
|
pSystem = pSystem->m_pNextSystem;
|
|
}
|
|
else
|
|
{
|
|
// delete this system
|
|
if( pLast )
|
|
{
|
|
pLast->m_pNextSystem = pSystem->m_pNextSystem;
|
|
delete pSystem;
|
|
pSystem = pLast->m_pNextSystem;
|
|
}
|
|
else
|
|
{
|
|
// deleting the first system
|
|
m_pFirstSystem = pSystem->m_pNextSystem;
|
|
delete pSystem;
|
|
pSystem = m_pFirstSystem;
|
|
}
|
|
}
|
|
}
|
|
|
|
gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
|
|
}
|
|
|
|
void CParticleSystemManager :: ClearSystems( void )
|
|
{
|
|
CParticleSystem *pSystem = m_pFirstSystem;
|
|
CParticleSystem *pTemp;
|
|
|
|
while( pSystem )
|
|
{
|
|
pTemp = pSystem->m_pNextSystem;
|
|
delete pSystem;
|
|
pSystem = pTemp;
|
|
}
|
|
|
|
m_pFirstSystem = NULL;
|
|
}
|
|
|
|
CParticleType :: CParticleType( CParticleType *pNext )
|
|
{
|
|
m_pSprayType = m_pOverlayType = NULL;
|
|
m_StartAngle = RandomRange( 45.0f );
|
|
m_pNext = pNext;
|
|
m_szName[0] = 0;
|
|
m_hSprite = 0;
|
|
|
|
m_StartRed = m_StartGreen = m_StartBlue = m_StartAlpha = RandomRange( 1.0f );
|
|
m_EndRed = m_EndGreen = m_EndBlue = m_EndAlpha = RandomRange( 1.0f );
|
|
|
|
m_iRenderMode = kRenderTransAdd;
|
|
m_iDrawCond = CONTENTS_NONE;
|
|
m_bIsDefined = false;
|
|
m_bEndFrame = false;
|
|
m_bBouncing = false;
|
|
}
|
|
|
|
CParticle* CParticleType :: CreateParticle( CParticleSystem *pSys )
|
|
{
|
|
if( !pSys ) return NULL;
|
|
|
|
CParticle *pPart = pSys->ActivateParticle();
|
|
if( !pPart ) return NULL;
|
|
|
|
pPart->age = 0.0f;
|
|
pPart->age_death = m_Life.GetInstance();
|
|
|
|
InitParticle( pPart, pSys );
|
|
|
|
return pPart;
|
|
}
|
|
|
|
void CParticleType :: InitParticle( CParticle *pPart, CParticleSystem *pSys )
|
|
{
|
|
float fLifeRecip;
|
|
|
|
if( pPart->age_death > 0.0f )
|
|
fLifeRecip = 1.0f / pPart->age_death;
|
|
else fLifeRecip = 1.0f;
|
|
|
|
pPart->pType = this;
|
|
|
|
pPart->velocity = pPart->origin = g_vecZero;
|
|
pPart->accel.x = pPart->accel.y = 0.0f;
|
|
pPart->accel.z = m_Gravity.GetInstance();
|
|
pPart->m_pEntity = NULL;
|
|
|
|
CParticle *pOverlay = NULL;
|
|
|
|
if( m_pOverlayType )
|
|
{
|
|
// create an overlay for this particle
|
|
pOverlay = pSys->ActivateParticle();
|
|
|
|
if( pOverlay )
|
|
{
|
|
pOverlay->age = pPart->age;
|
|
pOverlay->age_death = pPart->age_death;
|
|
m_pOverlayType->InitParticle( pOverlay, pSys );
|
|
}
|
|
}
|
|
|
|
pPart->m_pOverlay = pOverlay;
|
|
|
|
if( m_pSprayType )
|
|
pPart->age_spray = 1.0f / m_SprayRate.GetInstance();
|
|
else pPart->age_spray = 0.0f;
|
|
|
|
pPart->m_fSize = m_StartSize.GetInstance();
|
|
|
|
if( m_EndSize.IsDefined( ))
|
|
pPart->m_fSizeStep = m_EndSize.GetOffset( pPart->m_fSize ) * fLifeRecip;
|
|
else pPart->m_fSizeStep = m_SizeDelta.GetInstance();
|
|
|
|
pPart->frame = m_StartFrame.GetInstance();
|
|
|
|
if( m_EndFrame.IsDefined( ))
|
|
pPart->m_fFrameStep = m_EndFrame.GetOffset( pPart->frame ) * fLifeRecip;
|
|
else pPart->m_fFrameStep = m_FrameRate.GetInstance();
|
|
|
|
pPart->m_fAlpha = m_StartAlpha.GetInstance();
|
|
pPart->m_fAlphaStep = m_EndAlpha.GetOffset( pPart->m_fAlpha ) * fLifeRecip;
|
|
pPart->m_fRed = m_StartRed.GetInstance();
|
|
pPart->m_fRedStep = m_EndRed.GetOffset( pPart->m_fRed ) * fLifeRecip;
|
|
pPart->m_fGreen = m_StartGreen.GetInstance();
|
|
pPart->m_fGreenStep = m_EndGreen.GetOffset( pPart->m_fGreen ) * fLifeRecip;
|
|
pPart->m_fBlue = m_StartBlue.GetInstance();
|
|
pPart->m_fBlueStep = m_EndBlue.GetOffset( pPart->m_fBlue ) * fLifeRecip;
|
|
|
|
pPart->m_fAngle = m_StartAngle.GetInstance();
|
|
pPart->m_fAngleStep = m_AngleDelta.GetInstance();
|
|
|
|
pPart->m_fDrag = m_Drag.GetInstance();
|
|
|
|
float fWindStrength = m_WindStrength.GetInstance();
|
|
float fWindYaw = m_WindYaw.GetInstance();
|
|
|
|
if( fWindStrength != 0 )
|
|
{
|
|
if( fWindYaw == 0 )
|
|
{
|
|
// angle = 0, sin 0, cos 1
|
|
pPart->m_vecWind.x = 1.0f;
|
|
pPart->m_vecWind.y = 0.0f;
|
|
pPart->m_vecWind.z = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
float fSinWindYaw = CParticleSystem :: CosLookup( fWindYaw );
|
|
float fCosWindYaw = CParticleSystem :: SinLookup( fWindYaw );
|
|
|
|
pPart->m_vecWind.x = fCosWindYaw;
|
|
pPart->m_vecWind.y = fSinWindYaw;
|
|
pPart->m_vecWind.z = 0;
|
|
}
|
|
|
|
// rotate wind vector into world space
|
|
pPart->m_vecWind = pSys->entityMatrix.VectorRotate( pPart->m_vecWind ) * fWindStrength;
|
|
}
|
|
else
|
|
{
|
|
pPart->m_vecWind = g_vecZero;
|
|
}
|
|
}
|
|
|
|
float CParticleSystem :: c_fCosTable[360 + 90];
|
|
bool CParticleSystem :: c_bCosTableInit = false;
|
|
|
|
//============================================
|
|
CParticleSystem :: CParticleSystem( cl_entity_t *ent, const char *szFilename, int attachment, float lifetime )
|
|
{
|
|
int iParticles = 100; // default
|
|
m_iKillCondition = CONTENTS_NONE;
|
|
m_iEntAttachment = attachment;
|
|
m_pActiveParticle = NULL;
|
|
m_pMainParticle = NULL;
|
|
m_fLifeTime = lifetime;
|
|
m_pNextSystem = NULL;
|
|
m_iLightingModel = 0;
|
|
m_fViewerDist = 0.0f;
|
|
m_pFirstType = NULL;
|
|
m_pEntity = ent;
|
|
enable = true;
|
|
|
|
entityMatrix.Identity();
|
|
|
|
if( !c_bCosTableInit )
|
|
{
|
|
for( int i = 0; i < 360 + 90; i++ )
|
|
c_fCosTable[i] = cos( i * M_PI / 180.0f );
|
|
c_bCosTableInit = true;
|
|
}
|
|
|
|
char *afile = (char *)gEngfuncs.COM_LoadFile( (char *)szFilename, 5, NULL );
|
|
char szToken[1024];
|
|
char *pfile = afile;
|
|
|
|
if( !afile )
|
|
{
|
|
ALERT( at_error, "couldn't load %s.\n", szFilename );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
|
|
while( pfile )
|
|
{
|
|
if( !Q_stricmp( szToken, "particles" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
iParticles = Q_atoi( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "maintype" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
m_pMainType = AddPlaceholderType( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "attachment" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
m_iEntAttachment = Q_atoi( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "lightmodel" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
m_iLightingModel = Q_atoi( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "lifetime" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
m_fLifeTime = tr.time + Q_atof( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "killcondition" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
|
|
if( !Q_stricmp( szToken, "empty" ))
|
|
{
|
|
m_iKillCondition = CONTENTS_EMPTY;
|
|
}
|
|
else if( !Q_stricmp( szToken, "water" ))
|
|
{
|
|
m_iKillCondition = CONTENTS_WATER;
|
|
}
|
|
else if( !Q_stricmp( szToken, "solid" ))
|
|
{
|
|
m_iKillCondition = CONTENTS_SOLID;
|
|
}
|
|
}
|
|
else if( !Q_stricmp( szToken, "{" ))
|
|
{
|
|
// parse new type
|
|
this->ParseType( pfile );
|
|
}
|
|
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
}
|
|
}
|
|
|
|
gEngfuncs.COM_FreeFile( afile );
|
|
AllocateParticles( iParticles );
|
|
}
|
|
|
|
void CParticleSystem :: AllocateParticles( int iParticles )
|
|
{
|
|
m_pAllParticles = new CParticle[iParticles];
|
|
memset( m_pAllParticles, 0, sizeof( CParticle ) * iParticles );
|
|
m_pFreeParticle = m_pAllParticles;
|
|
m_pActiveParticle = NULL;
|
|
m_pMainParticle = NULL;
|
|
|
|
// initialise the linked list
|
|
CParticle *pLast = m_pAllParticles;
|
|
CParticle *pParticle = pLast + 1;
|
|
|
|
for( int i = 1; i < iParticles; i++ )
|
|
{
|
|
pLast->nextpart = pParticle;
|
|
pLast = pParticle;
|
|
pParticle++;
|
|
}
|
|
|
|
pLast->nextpart = NULL;
|
|
}
|
|
|
|
CParticleSystem :: ~CParticleSystem( void )
|
|
{
|
|
delete[] m_pAllParticles;
|
|
|
|
CParticleType *pType = m_pFirstType;
|
|
CParticleType *pNext;
|
|
|
|
while( pType )
|
|
{
|
|
pNext = pType->m_pNext;
|
|
delete pType;
|
|
pType = pNext;
|
|
}
|
|
}
|
|
|
|
// returns the CParticleType with the given name, if there is one
|
|
CParticleType *CParticleSystem :: GetType( const char *szName )
|
|
{
|
|
for( CParticleType *pType = m_pFirstType; pType != NULL; pType = pType->m_pNext )
|
|
{
|
|
if( !Q_stricmp( pType->m_szName, szName ))
|
|
return pType;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CParticleType *CParticleSystem :: AddPlaceholderType( const char *szName )
|
|
{
|
|
m_pFirstType = new CParticleType( m_pFirstType );
|
|
Q_strncpy( m_pFirstType->m_szName, szName, sizeof( m_pFirstType->m_szName ));
|
|
|
|
return m_pFirstType;
|
|
}
|
|
|
|
// creates a new particletype from the given file
|
|
// NB: this changes the value of szFile.
|
|
CParticleType *CParticleSystem :: ParseType( char *&pfile )
|
|
{
|
|
CParticleType *pType = new CParticleType();
|
|
|
|
// parse the .aur file
|
|
char szToken[1024];
|
|
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
|
|
while( Q_stricmp( szToken, "}" ))
|
|
{
|
|
if( !pfile ) break;
|
|
|
|
if( !Q_stricmp( szToken, "name" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
Q_strncpy( pType->m_szName, szToken, sizeof( pType->m_szName ));
|
|
|
|
CParticleType *pTemp = GetType( szToken );
|
|
|
|
if( pTemp )
|
|
{
|
|
// there's already a type with this name
|
|
if( pTemp->m_bIsDefined )
|
|
ALERT( at_warning, "Particle type %s is defined more than once!\n", szToken );
|
|
|
|
// copy all our data into the existing type, throw away the type we were making
|
|
*pTemp = *pType;
|
|
delete pType;
|
|
pType = pTemp;
|
|
pType->m_bIsDefined = true; // record the fact that it's defined, so we won't need to add it to the list
|
|
}
|
|
}
|
|
else if( !Q_stricmp( szToken, "gravity" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_Gravity = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "windyaw" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_WindYaw = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "windstrength" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_WindStrength = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "sprite" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_hSprite = SPR_Load( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "startalpha" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_StartAlpha = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "endalpha" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_EndAlpha = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "startred" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_StartRed = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "endred" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_EndRed = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "startgreen" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_StartGreen = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "endgreen" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_EndGreen = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "startblue" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_StartBlue = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "endblue" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_EndBlue = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "startsize" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_StartSize = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "sizedelta" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_SizeDelta = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "endsize" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_EndSize = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "startangle" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_StartAngle = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "angledelta" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_AngleDelta = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "startframe" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_StartFrame = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "endframe" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_EndFrame = RandomRange( szToken );
|
|
pType->m_bEndFrame = true;
|
|
}
|
|
else if( !Q_stricmp( szToken, "framerate" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_FrameRate = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "lifetime" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_Life = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "spraytype" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
CParticleType *pTemp = GetType( szToken );
|
|
|
|
if( pTemp )
|
|
pType->m_pSprayType = pTemp;
|
|
else
|
|
pType->m_pSprayType = AddPlaceholderType( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "overlaytype" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
CParticleType *pTemp = GetType( szToken );
|
|
|
|
if( pTemp )
|
|
pType->m_pOverlayType = pTemp;
|
|
else
|
|
pType->m_pOverlayType = AddPlaceholderType( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "sprayrate" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_SprayRate = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "sprayforce" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_SprayForce = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "spraypitch" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_SprayPitch = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "sprayyaw" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_SprayYaw = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "drag" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_Drag = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "bounce" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_Bounce = RandomRange( szToken );
|
|
|
|
if( pType->m_Bounce.m_flMin != 0 || pType->m_Bounce.m_flMax != 0 )
|
|
pType->m_bBouncing = true;
|
|
}
|
|
else if( !Q_stricmp( szToken, "bouncefriction" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
pType->m_BounceFriction = RandomRange( szToken );
|
|
}
|
|
else if( !Q_stricmp( szToken, "rendermode" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
|
|
if( !Q_stricmp( szToken, "additive" ))
|
|
{
|
|
pType->m_iRenderMode = kRenderTransAdd;
|
|
}
|
|
else if( !Q_stricmp( szToken, "solid" ))
|
|
{
|
|
pType->m_iRenderMode = kRenderTransAlpha;
|
|
}
|
|
else if( !Q_stricmp( szToken, "texture" ))
|
|
{
|
|
pType->m_iRenderMode = kRenderTransTexture;
|
|
}
|
|
else if( !Q_stricmp( szToken, "color" ))
|
|
{
|
|
pType->m_iRenderMode = kRenderTransColor;
|
|
}
|
|
}
|
|
else if( !Q_stricmp( szToken, "drawcondition" ))
|
|
{
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
|
|
if( !Q_stricmp( szToken, "empty" ))
|
|
{
|
|
pType->m_iDrawCond = CONTENTS_EMPTY;
|
|
}
|
|
else if( !Q_stricmp( szToken, "water" ))
|
|
{
|
|
pType->m_iDrawCond = CONTENTS_WATER;
|
|
}
|
|
else if( !Q_stricmp( szToken, "solid" ))
|
|
{
|
|
pType->m_iDrawCond = CONTENTS_SOLID;
|
|
}
|
|
else if( !Q_stricmp( szToken, "special" ) || !Q_stricmp( szToken, "special1" ))
|
|
{
|
|
pType->m_iDrawCond = CONTENTS_SPECIAL1;
|
|
}
|
|
else if( !Q_stricmp( szToken, "special2" ))
|
|
{
|
|
pType->m_iDrawCond = CONTENTS_SPECIAL2;
|
|
}
|
|
else if( !Q_stricmp( szToken, "special3" ))
|
|
{
|
|
pType->m_iDrawCond = CONTENTS_SPECIAL3;
|
|
}
|
|
else if( !Q_stricmp( szToken, "spotlight" ))
|
|
{
|
|
pType->m_iDrawCond = CONTENTS_SPOTLIGHT;
|
|
}
|
|
}
|
|
|
|
// get the next token
|
|
pfile = COM_ParseFile( pfile, szToken );
|
|
}
|
|
|
|
if( !pType->m_bIsDefined )
|
|
{
|
|
// if this is a newly-defined type, we need to add it to the list
|
|
pType->m_pNext = m_pFirstType;
|
|
m_pFirstType = pType;
|
|
pType->m_bIsDefined = true;
|
|
}
|
|
|
|
return pType;
|
|
}
|
|
|
|
CParticle *CParticleSystem :: ActivateParticle( void )
|
|
{
|
|
CParticle *pActivated = m_pFreeParticle;
|
|
|
|
if( pActivated )
|
|
{
|
|
m_pFreeParticle = pActivated->nextpart;
|
|
pActivated->nextpart = m_pActiveParticle;
|
|
m_pActiveParticle = pActivated;
|
|
}
|
|
|
|
return pActivated;
|
|
}
|
|
|
|
void CParticleSystem :: MarkForDeletion( void )
|
|
{
|
|
if( m_pMainParticle )
|
|
{
|
|
m_pMainParticle->age_death = 0.0f; // die now
|
|
m_pMainParticle = NULL;
|
|
}
|
|
|
|
// completely remove for time-based systems
|
|
if( m_fLifeTime != 0.0f ) m_pEntity = NULL;
|
|
}
|
|
|
|
void CParticleSystem :: CalculateDistance( void )
|
|
{
|
|
if( !m_pActiveParticle )
|
|
return;
|
|
|
|
Vector offset = GetVieworg() - m_pActiveParticle->origin; // just pick one
|
|
m_fViewerDist = DotProduct( offset, offset );
|
|
}
|
|
|
|
AURSTATE CParticleSystem :: UpdateSystem( float frametime )
|
|
{
|
|
if( m_pEntity != NULL )
|
|
{
|
|
// don't update if the system is outside the player's PVS.
|
|
if( m_pEntity->curstate.messagenum != r_currentMessageNum )
|
|
return AURORA_INVISIBLE;
|
|
|
|
// time-based particle system
|
|
if( m_fLifeTime != 0.0f )
|
|
{
|
|
enable = (m_fLifeTime >= tr.time) ? true : false;
|
|
}
|
|
else
|
|
{
|
|
enable = (m_pEntity->curstate.body) ? true : false;
|
|
}
|
|
|
|
// check for contents to remove
|
|
if( m_iKillCondition == POINT_CONTENTS( m_pEntity->origin ))
|
|
{
|
|
m_pEntity = NULL;
|
|
enable = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
enable = false;
|
|
}
|
|
|
|
if( m_pEntity != NULL )
|
|
{
|
|
Vector angles = m_pEntity->angles;
|
|
|
|
// stupid quake bug
|
|
if( m_pEntity == GET_VIEWMODEL( ))
|
|
angles.x = -angles.x;
|
|
|
|
// get the system entity matrix
|
|
if( m_iEntAttachment && m_pEntity->model->type == mod_studio )
|
|
angles = R_StudioAttachmentAng( m_pEntity, m_iEntAttachment - 1 );
|
|
entityMatrix = matrix3x3( angles );
|
|
}
|
|
|
|
if( m_pMainParticle == NULL )
|
|
{
|
|
if( enable )
|
|
{
|
|
CParticleType *pType = m_pMainType;
|
|
|
|
if( pType )
|
|
{
|
|
m_pMainParticle = pType->CreateParticle( this );
|
|
|
|
if( m_pMainParticle )
|
|
{
|
|
// first origin initialize
|
|
if( m_iEntAttachment && m_pEntity->model->type == mod_studio )
|
|
m_pMainParticle->origin = R_StudioAttachmentPos( m_pEntity, m_iEntAttachment - 1 );
|
|
else m_pMainParticle->origin = m_pEntity->origin;
|
|
|
|
m_pMainParticle->m_pEntity = m_pEntity;
|
|
m_pMainParticle->age_death = -1.0f; // never die
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if( !enable )
|
|
{
|
|
MarkForDeletion();
|
|
}
|
|
|
|
// last particle is died, allow to remove partsystem
|
|
if( !m_pEntity && !m_pActiveParticle )
|
|
return AURORA_REMOVE;
|
|
|
|
CParticle *pParticle = m_pActiveParticle;
|
|
CParticle *pLast = NULL;
|
|
|
|
while( pParticle )
|
|
{
|
|
if( UpdateParticle( pParticle, frametime ))
|
|
{
|
|
pLast = pParticle;
|
|
pParticle = pParticle->nextpart;
|
|
}
|
|
else
|
|
{
|
|
// deactivate it
|
|
if( pLast )
|
|
{
|
|
pLast->nextpart = pParticle->nextpart;
|
|
pParticle->nextpart = m_pFreeParticle;
|
|
m_pFreeParticle = pParticle;
|
|
pParticle = pLast->nextpart;
|
|
}
|
|
else
|
|
{
|
|
// deactivate the first CParticle in the list
|
|
m_pActiveParticle = pParticle->nextpart;
|
|
pParticle->nextpart = m_pFreeParticle;
|
|
m_pFreeParticle = pParticle;
|
|
pParticle = m_pActiveParticle;
|
|
}
|
|
}
|
|
}
|
|
|
|
return AURORA_DRAW;
|
|
}
|
|
|
|
void CParticleSystem :: DrawSystem( void )
|
|
{
|
|
CParticle *pParticle = m_pActiveParticle;
|
|
|
|
if( m_pEntity != NULL )
|
|
{
|
|
// don't draw if the system is outside the player's PVS.
|
|
if( m_pEntity->curstate.messagenum != r_currentMessageNum )
|
|
return;
|
|
}
|
|
|
|
m_fHasProjectionLighting = HasDynamicLights();
|
|
|
|
for( pParticle = m_pActiveParticle; pParticle; pParticle = pParticle->nextpart )
|
|
{
|
|
if( pParticle->m_fSize <= 0 || !ParticleIsVisible( pParticle ))
|
|
continue;
|
|
DrawParticle( pParticle, GetVLeft(), GetVUp( ));
|
|
}
|
|
}
|
|
|
|
bool CParticleSystem :: ParticleIsVisible( CParticle *part )
|
|
{
|
|
if( R_CullSphere( part->origin, part->m_fSize + 1 ))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CParticleSystem :: UpdateParticle( CParticle *part, float frametime )
|
|
{
|
|
if( frametime == 0 )
|
|
return true;
|
|
|
|
part->age += frametime;
|
|
|
|
// is this particle bound to an entity?
|
|
if( part->m_pEntity )
|
|
{
|
|
if( enable )
|
|
{
|
|
if( m_iEntAttachment && m_pEntity->model->type == mod_studio )
|
|
{
|
|
float flSpeed = (R_StudioAttachmentPos( m_pEntity, m_iEntAttachment - 1 ) - part->origin).Length() * frametime;
|
|
part->velocity = entityMatrix.GetForward() * flSpeed;
|
|
part->origin = R_StudioAttachmentPos( m_pEntity, m_iEntAttachment - 1 );
|
|
}
|
|
else
|
|
{
|
|
float flSpeed = (m_pEntity->origin - part->origin).Length() * frametime;
|
|
part->velocity = entityMatrix.GetForward() * flSpeed;
|
|
part->origin = m_pEntity->origin;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// entity is switched off, die
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// not tied to an entity, check whether it's time to die
|
|
if( part->age_death >= 0.0f && part->age > part->age_death )
|
|
return false;
|
|
|
|
// apply acceleration and velocity
|
|
if( part->m_fDrag )
|
|
part->velocity += (part->velocity - part->m_vecWind) * (-part->m_fDrag * frametime);
|
|
|
|
part->velocity += part->accel * frametime;
|
|
part->origin += part->velocity * frametime;
|
|
|
|
if( part->pType->m_bBouncing )
|
|
{
|
|
Vector vecTarget = part->origin + part->velocity * frametime;
|
|
pmtrace_t *tr = gEngfuncs.PM_TraceLine( part->origin, vecTarget, PM_TRACELINE_PHYSENTSONLY, 2, -1 );
|
|
|
|
if( tr->fraction < 1.0f )
|
|
{
|
|
part->origin = tr->endpos;
|
|
float bounceforce = DotProduct( tr->plane.normal, part->velocity );
|
|
float newspeed = (1.0f - part->pType->m_BounceFriction.GetInstance( ));
|
|
part->velocity = part->velocity * newspeed;
|
|
part->velocity += tr->plane.normal * (-bounceforce * (newspeed + part->pType->m_Bounce.GetInstance()));
|
|
}
|
|
}
|
|
}
|
|
|
|
// spray children
|
|
if( part->age_spray && part->age > part->age_spray )
|
|
{
|
|
part->age_spray = part->age + 1.0f / part->pType->m_SprayRate.GetInstance();
|
|
|
|
if( part->pType->m_pSprayType )
|
|
{
|
|
CParticle *pChild = part->pType->m_pSprayType->CreateParticle( this );
|
|
|
|
if( pChild )
|
|
{
|
|
pChild->origin = part->origin;
|
|
pChild->velocity = part->velocity;
|
|
float fSprayForce = part->pType->m_SprayForce.GetInstance();
|
|
|
|
if( fSprayForce )
|
|
{
|
|
Vector vecLocalAngles, vecSprayDir;
|
|
vecLocalAngles.x = part->pType->m_SprayPitch.GetInstance();
|
|
vecLocalAngles.y = part->pType->m_SprayYaw.GetInstance();
|
|
vecLocalAngles.z = 0.0f;
|
|
|
|
// setup particle local direction
|
|
if( vecLocalAngles != g_vecZero )
|
|
AngleVectors( vecLocalAngles, vecSprayDir, NULL, NULL );
|
|
else vecSprayDir = Vector( 1, 0, 0 ); // fast case
|
|
pChild->velocity += entityMatrix.VectorRotate( vecSprayDir ) * fSprayForce;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
part->m_fSize += part->m_fSizeStep * frametime;
|
|
part->m_fAlpha += part->m_fAlphaStep * frametime;
|
|
part->m_fRed += part->m_fRedStep * frametime;
|
|
part->m_fGreen += part->m_fGreenStep * frametime;
|
|
part->m_fBlue += part->m_fBlueStep * frametime;
|
|
part->frame += part->m_fFrameStep * frametime;
|
|
|
|
if( part->m_fAngleStep )
|
|
{
|
|
part->m_fAngle += part->m_fAngleStep * frametime;
|
|
while( part->m_fAngle < 0 ) part->m_fAngle += 360;
|
|
while( part->m_fAngle > 360 ) part->m_fAngle -= 360;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CParticleSystem :: DrawParticle( CParticle *part, const vec3_t &right, const vec3_t &up )
|
|
{
|
|
float fSize = part->m_fSize;
|
|
|
|
Vector point[4];
|
|
Vector origin = part->origin;
|
|
Vector absmin, absmax;
|
|
Vector4D partColor;
|
|
|
|
float fCosSize = CosLookup( part->m_fAngle ) * fSize;
|
|
float fSinSize = SinLookup( part->m_fAngle ) * fSize;
|
|
|
|
// calculate the four corners of the sprite
|
|
point[0] = origin + up * -fCosSize + right * -fSinSize;
|
|
point[1] = origin + up * fSinSize + right * -fCosSize;
|
|
point[2] = origin + up * fCosSize + right * fSinSize;
|
|
point[3] = origin + up * -fSinSize + right * fCosSize;
|
|
|
|
ClearBounds( absmin, absmax );
|
|
for( int i = 0; i < 4; i++ )
|
|
AddPointToBounds( point[i], absmin, absmax );
|
|
|
|
int iContents = CONTENTS_NONE;
|
|
model_t *pModel;
|
|
|
|
for( CParticle *pDraw = part; pDraw; pDraw = pDraw->m_pOverlay )
|
|
{
|
|
if( !pDraw->pType->m_hSprite )
|
|
continue;
|
|
|
|
if( pDraw->pType->m_iDrawCond )
|
|
{
|
|
if( pDraw->pType->m_iDrawCond == CONTENTS_SPOTLIGHT )
|
|
{
|
|
int i;
|
|
if( !m_fHasProjectionLighting )
|
|
continue; // fast reject
|
|
|
|
for( i = 0; i < MAX_DLIGHTS; i++ )
|
|
{
|
|
CDynLight *pl = &tr.dlights[i];
|
|
|
|
if( !pl->Active( )) continue;
|
|
|
|
if( !pl->frustum.CullSphere( part->origin, part->m_fSize + 1 ))
|
|
break; // cone intersected with particle
|
|
|
|
}
|
|
|
|
if( i == MAX_DLIGHTS )
|
|
continue; // no intersection
|
|
}
|
|
else
|
|
{
|
|
if( iContents == CONTENTS_NONE )
|
|
iContents = POINT_CONTENTS( origin );
|
|
|
|
if( iContents != pDraw->pType->m_iDrawCond )
|
|
continue;
|
|
}
|
|
}
|
|
|
|
pModel = (model_t *)gEngfuncs.GetSpritePointer( pDraw->pType->m_hSprite );
|
|
|
|
// if we've reached the end of the sprite's frames, loop back
|
|
while( pDraw->frame > pModel->numframes )
|
|
pDraw->frame -= pModel->numframes;
|
|
|
|
while( pDraw->frame < 0 )
|
|
pDraw->frame += pModel->numframes;
|
|
|
|
if( m_iLightingModel >= 1 )
|
|
{
|
|
Vector lightColor;
|
|
|
|
gEngfuncs.pTriAPI->LightAtPoint( part->origin, (float *)&lightColor );
|
|
lightColor *= (1.0f / 255.0f);
|
|
partColor.x = pDraw->m_fRed * lightColor.x;
|
|
partColor.y = pDraw->m_fGreen * lightColor.y;
|
|
partColor.z = pDraw->m_fBlue * lightColor.z;
|
|
partColor.w = pDraw->m_fAlpha;
|
|
}
|
|
else
|
|
{
|
|
partColor = Vector4D( pDraw->m_fRed, pDraw->m_fGreen, pDraw->m_fBlue, pDraw->m_fAlpha );
|
|
}
|
|
#if 0
|
|
if( !gEngfuncs.pTriAPI->SpriteTexture( pModel, (int)pDraw->frame ))
|
|
continue;
|
|
|
|
gEngfuncs.pTriAPI->RenderMode( pDraw->pType->m_iRenderMode );
|
|
pglColor4f( partColor.x, partColor.y, partColor.z, partColor.w );
|
|
pglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
|
|
pglBegin( GL_QUADS );
|
|
pglTexCoord2f( 0.0f, 1.0f );
|
|
pglVertex3fv( point[0] );
|
|
|
|
pglTexCoord2f( 0.0f, 0.0f );
|
|
pglVertex3fv( point[1] );
|
|
|
|
pglTexCoord2f( 1.0f, 0.0f );
|
|
pglVertex3fv( point[2] );
|
|
|
|
pglTexCoord2f( 1.0f, 1.0f );
|
|
pglVertex3fv( point[3] );
|
|
pglEnd();
|
|
#else
|
|
int hTexture;
|
|
|
|
if(( hTexture = R_GetSpriteTexture( pModel, pDraw->frame )) == 0 )
|
|
continue;
|
|
|
|
CTransEntry entry;
|
|
entry.SetRenderPrimitive( point, partColor, hTexture, pDraw->pType->m_iRenderMode );
|
|
entry.ComputeViewDistance( absmin, absmax );
|
|
RI->frame.trans_list.AddToTail( entry );
|
|
#endif
|
|
}
|
|
} |