920 lines
32 KiB
C++
920 lines
32 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
//
|
|
// This module implements the particle manager for the client DLL.
|
|
// In a nutshell, to create your own effect, implement the ParticleEffect
|
|
// interface and call CParticleMgr::AddEffect to add your effect. Then you can
|
|
// add particles and simulate and render them.
|
|
|
|
/*
|
|
|
|
Particle manager documentation
|
|
-----------------------------------------------------------------------------
|
|
|
|
All particle effects are managed by a class called CParticleMgr. It tracks
|
|
the list of particles, manages their materials, sorts the particles, and
|
|
has callbacks to render them.
|
|
|
|
Conceptually, CParticleMgr is NOT part of VEngine's entity system. It does
|
|
not care about entities, only particle effects. Usually, the two are implemented
|
|
together, but you should be aware the CParticleMgr talks to you through its
|
|
own interfaces and does not talk to entities. Thus, it is possible to have
|
|
particle effects that are not entities.
|
|
|
|
To make a particle effect, you need two things:
|
|
|
|
1. An implementation of the IParticleEffect interface. This is how CParticleMgr
|
|
talks to you for things like rendering and updating your effect.
|
|
|
|
2. A (member) variable of type CParticleEffectBinding. This allows CParticleMgr to
|
|
store its internal data associated with your effect.
|
|
|
|
Once you have those two things, you call CParticleMgr::AddEffect and pass them
|
|
both in. You will then get updates through IParticleEffect::Update, and you will
|
|
be asked to render your particles with IParticleEffect::SimulateAndRender.
|
|
|
|
When you want to remove the effect, call CParticleEffectBinding::SetRemoveFlag(), which
|
|
tells CParticleMgr to remove the effect next chance it gets.
|
|
|
|
Example class:
|
|
|
|
class CMyEffect : public IParticleEffect
|
|
{
|
|
public:
|
|
// Call this to start the effect by adding it to the particle manager.
|
|
void Start()
|
|
{
|
|
ParticleMgr()->AddEffect( &m_ParticleEffect, this );
|
|
}
|
|
|
|
// implementation of IParticleEffect functions go here...
|
|
|
|
public:
|
|
CParticleEffectBinding m_ParticleEffect;
|
|
};
|
|
|
|
|
|
|
|
How the particle effects are integrated with the entity system
|
|
-----------------------------------------------------------------------------
|
|
|
|
There are two helper classes that you can use to create particles for your
|
|
entities. Each one is useful under different conditions.
|
|
|
|
1. CSimpleEmitter is a class that does some of the dirty work of using particles.
|
|
If you want, you can just instantiate one of these with CSimpleEmitter::Create
|
|
and call its AddParticle functions to add particles. When you are done and
|
|
want to 'free' it, call its Release function rather than deleting it, and it
|
|
will wait until all of its particles have gone away before removing itself
|
|
(so you don't have to write code to wait for all of the particles to go away).
|
|
|
|
In most cases, it is the easiest and most clear to use CSimpleEmitter or
|
|
derive a class from it, then use that class from inside an entity that wants
|
|
to make particles.
|
|
|
|
CSimpleEmitter and derived classes handle adding themselves to the particle
|
|
manager, tracking how many particles in the effect are active, and
|
|
rendering the particles.
|
|
|
|
CSimpleEmitter has code to simulate and render particles in a generic fashion,
|
|
but if you derive a class from it, you can override some of its behavior
|
|
with virtuals like UpdateAlpha, UpdateScale, UpdateColor, etc..
|
|
|
|
Example code:
|
|
CSimpleEmitter *pEmitter = CSimpleEmitter::Create();
|
|
|
|
CEffectMaterialHandle hMaterial = pEmitter->GetCEffectMaterial( "mymaterial" );
|
|
|
|
for( int i=0; i < 100; i++ )
|
|
pEmitter->AddParticle( hMaterial, RandomVector(0,10), 4 );
|
|
|
|
pEmitter->Release();
|
|
|
|
2. Some older effects derive from C_BaseParticleEffect and implement an entity
|
|
and a particle system at the same time. This gets nasty and is not encouraged anymore.
|
|
|
|
*/
|
|
|
|
|
|
#ifndef PARTICLEMGR_H
|
|
#define PARTICLEMGR_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "materialsystem/imaterial.h"
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "mathlib/vector.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "iclientrenderable.h"
|
|
#include "clientleafsystem.h"
|
|
#include "tier0/fasttimer.h"
|
|
#include "utllinkedlist.h"
|
|
#include "utldict.h"
|
|
#ifdef WIN32
|
|
#include <typeinfo.h>
|
|
#else
|
|
#include <typeinfo>
|
|
#endif
|
|
#include "tier1/utlintrusivelist.h"
|
|
#include "tier1/utlstring.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class IParticleEffect;
|
|
class IClientParticleListener;
|
|
struct Particle;
|
|
class ParticleDraw;
|
|
class CMeshBuilder;
|
|
class CUtlMemoryPool;
|
|
class CEffectMaterial;
|
|
class CParticleSimulateIterator;
|
|
class CParticleRenderIterator;
|
|
class IThreadPool;
|
|
class CParticleSystemDefinition;
|
|
class CParticleMgr;
|
|
class CNewParticleEffect;
|
|
class CParticleCollection;
|
|
|
|
#define INVALID_MATERIAL_HANDLE NULL
|
|
|
|
|
|
// Various stats, disabled
|
|
// extern int g_nParticlesDrawn;
|
|
// extern CCycleCount g_ParticleTimer;
|
|
|
|
|
|
class CParticleSubTexture;
|
|
class CParticleSubTextureGroup;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The basic particle description; all particles need to inherit from this.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct Particle
|
|
{
|
|
Particle *m_pPrev, *m_pNext;
|
|
|
|
// Which sub texture this particle uses (so we can get at the tcoord mins and maxs).
|
|
CParticleSubTexture *m_pSubTexture;
|
|
|
|
// If m_Pos isn't used to store the world position, then implement IParticleEffect::GetParticlePosition()
|
|
Vector m_Pos; // Position of the particle in world space
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is the CParticleMgr's reference to a material in the material system.
|
|
// Particles are sorted by material.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// This indexes CParticleMgr::m_SubTextures.
|
|
typedef CParticleSubTexture* PMaterialHandle;
|
|
|
|
// Each effect stores a list of particles associated with each material. The list is
|
|
// hashed on the IMaterial pointer.
|
|
class CEffectMaterial
|
|
{
|
|
public:
|
|
CEffectMaterial();
|
|
|
|
public:
|
|
// This provides the material that gets bound for this material in this effect.
|
|
// There can be multiple subtextures all within the same CEffectMaterial.
|
|
CParticleSubTextureGroup *m_pGroup;
|
|
|
|
Particle m_Particles;
|
|
CEffectMaterial *m_pHashedNext;
|
|
};
|
|
|
|
|
|
class CParticleSubTextureGroup
|
|
{
|
|
public:
|
|
CParticleSubTextureGroup();
|
|
~CParticleSubTextureGroup();
|
|
|
|
// Even though each of the subtextures has its own material, they should all basically be
|
|
// the same exact material and just use different texture coordinates, so this is the
|
|
// material of the first subtexture that is bound.
|
|
//
|
|
// This is gotten from GetMaterialPage().
|
|
IMaterial *m_pPageMaterial;
|
|
};
|
|
|
|
// Precalculated data for each material used for particles.
|
|
// This allows us to put multiple subtextures into one VTF and sort them against each other.
|
|
class CParticleSubTexture
|
|
{
|
|
public:
|
|
CParticleSubTexture();
|
|
|
|
float m_tCoordMins[2]; // bbox in texel space that this particle material uses.
|
|
float m_tCoordMaxs[2]; // Specified in the SubTextureMins/SubTextureMaxs parameter in the materials.
|
|
|
|
// Which group does this subtexture belong to?
|
|
CParticleSubTextureGroup *m_pGroup;
|
|
CParticleSubTextureGroup m_DefaultGroup; // This is used as the group if a particle's material
|
|
// isn't using a group.
|
|
|
|
#ifdef _DEBUG
|
|
char *m_szDebugName;
|
|
#endif
|
|
|
|
IMaterial *m_pMaterial;
|
|
};
|
|
|
|
// Particle simulation list, used to determine what particles to simulate and how.
|
|
struct ParticleSimListEntry_t
|
|
{
|
|
CNewParticleEffect* m_pNewParticleEffect;
|
|
bool m_bBoundingBoxOnly;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// interface IParticleEffect:
|
|
//
|
|
// This is the interface that particles effects must implement. The effect is
|
|
// responsible for starting itself and calling CParticleMgr::AddEffect, then it
|
|
// will get the callbacks it needs to simulate and render the particles.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
abstract_class IParticleEffect
|
|
{
|
|
// Overridables.
|
|
public:
|
|
|
|
virtual ~IParticleEffect() {}
|
|
|
|
// Called at the beginning of a frame to precalculate data for rendering
|
|
// the particles. If you manage your own list of particles and want to
|
|
// simulate them all at once, you can do that here and just render them in
|
|
// the SimulateAndRender call.
|
|
virtual void Update( float fTimeDelta ) {}
|
|
|
|
// Called once for the entire effect before the batch of SimulateAndRender() calls.
|
|
// For particle systems using FLAGS_CAMERASPACE (the default), effectMatrix transforms the particles from
|
|
// world space into camera space. You can change this matrix if you want your particles relative to something
|
|
// else like an attachment's space.
|
|
virtual void StartRender( VMatrix &effectMatrix ) {}
|
|
|
|
// Simulate the particles.
|
|
virtual bool ShouldSimulate() const = 0;
|
|
virtual void SetShouldSimulate( bool bSim ) = 0;
|
|
virtual void SimulateParticles( CParticleSimulateIterator *pIterator ) = 0;
|
|
|
|
// Render the particles.
|
|
virtual void RenderParticles( CParticleRenderIterator *pIterator ) = 0;
|
|
|
|
// Implementing this is optional. It is called when an effect is removed. It is useful if
|
|
// you hold onto pointers to the particles you created (so when this is called, you should
|
|
// clean up your data so you don't reference the particles again).
|
|
// NOTE: after calling this, the particle manager won't touch the IParticleEffect
|
|
// or its associated CParticleEffectBinding anymore.
|
|
virtual void NotifyRemove() {}
|
|
|
|
// This method notifies the effect a particle is about to be deallocated.
|
|
// Implementations should *not* actually deallocate it.
|
|
// NOTE: The particle effect's GetNumActiveParticles is updated BEFORE this is called
|
|
// so if GetNumActiveParticles returns 0, then you know this is the last particle
|
|
// in the system being removed.
|
|
virtual void NotifyDestroyParticle( Particle* pParticle ) {}
|
|
|
|
// Fill in the origin used to sort this entity.
|
|
// This is a world space position.
|
|
virtual const Vector &GetSortOrigin() = 0;
|
|
|
|
// Fill in the origin used to sort this entity.
|
|
// TODO: REMOVE THIS. ALL PARTICLE SYSTEMS SHOULD EITHER SET m_Pos IN CONJUNCTION WITH THE
|
|
// PARTICLE_LOCALSPACE FLAG, OR DO SETBBOX THEMSELVES.
|
|
virtual const Vector *GetParticlePosition( Particle *pParticle ) { return &pParticle->m_Pos; }
|
|
|
|
virtual const char *GetEffectName() { return "???"; }
|
|
};
|
|
|
|
#define REGISTER_EFFECT( effect ) \
|
|
IParticleEffect* effect##_Factory() \
|
|
{ \
|
|
return new effect; \
|
|
} \
|
|
struct effect##_RegistrationHelper \
|
|
{ \
|
|
effect##_RegistrationHelper() \
|
|
{ \
|
|
ParticleMgr()->RegisterEffect( typeid( effect ).name(), effect##_Factory ); \
|
|
} \
|
|
}; \
|
|
static effect##_RegistrationHelper g_##effect##_RegistrationHelper
|
|
|
|
#define REGISTER_EFFECT_USING_CREATE( effect ) \
|
|
IParticleEffect* effect##_Factory() \
|
|
{ \
|
|
return effect::Create( #effect ).GetObject(); \
|
|
} \
|
|
struct effect##_RegistrationHelper \
|
|
{ \
|
|
effect##_RegistrationHelper() \
|
|
{ \
|
|
ParticleMgr()->RegisterEffect( typeid( effect ).name(), effect##_Factory ); \
|
|
} \
|
|
}; \
|
|
static effect##_RegistrationHelper g_##effect##_RegistrationHelper
|
|
|
|
|
|
// In order to create a particle effect, you must have one of these around and
|
|
// implement IParticleEffect. Pass them both into CParticleMgr::AddEffect and you
|
|
// are good to go.
|
|
class CParticleEffectBinding : public CDefaultClientRenderable
|
|
{
|
|
friend class CParticleMgr;
|
|
friend class CParticleSimulateIterator;
|
|
friend class CNewParticleEffect;
|
|
|
|
public:
|
|
CParticleEffectBinding();
|
|
~CParticleEffectBinding();
|
|
|
|
|
|
// Helper functions to setup, add particles, etc..
|
|
public:
|
|
|
|
// Simulate all the particles.
|
|
void SimulateParticles( float flTimeDelta );
|
|
|
|
// Use this to specify materials when adding particles.
|
|
// Returns the index of the material it found or added.
|
|
// Returns INVALID_MATERIAL_HANDLE if it couldn't find or add a material.
|
|
PMaterialHandle FindOrAddMaterial( const char *pMaterialName );
|
|
|
|
// Allocate particles. The Particle manager will automagically
|
|
// deallocate them when the IParticleEffect SimulateAndRender() method
|
|
// returns false. The first argument is the size of the particle
|
|
// structure in bytes
|
|
Particle* AddParticle( int sizeInBytes, PMaterialHandle pMaterial );
|
|
|
|
// This is an optional call you can make if you want to manually manage the effect's
|
|
// bounding box. Normally, the bounding box is managed automatically, but in certain
|
|
// cases it is more efficient to set it manually.
|
|
//
|
|
// Note: this is a WORLD SPACE bounding box, even if you've used SetLocalSpaceTransform.
|
|
//
|
|
// After you make this call, the particle manager will no longer update the bounding
|
|
// box automatically if bDisableAutoUpdate is true.
|
|
void SetBBox( const Vector &bbMin, const Vector &bbMax, bool bDisableAutoUpdate = true );
|
|
// gets a copy of the current bbox mins/maxs in worldspace
|
|
void GetWorldspaceBounds( Vector *pMins, Vector *pMaxs );
|
|
|
|
// This tells the particle manager that your particles are transformed by the specified matrix.
|
|
// That way, it can transform the bbox defined by Particle::m_Pos into world space correctly.
|
|
//
|
|
// It also sets up the matrix returned by CParticleMgr::GetModelView() to include this matrix, so you
|
|
// can do TransformParticle with it like any other particle system.
|
|
const matrix3x4_t& GetLocalSpaceTransform() const;
|
|
void SetLocalSpaceTransform( const matrix3x4_t &transform );
|
|
|
|
// This expands the bbox to contain the specified point. Returns true if bbox changed
|
|
bool EnlargeBBoxToContain( const Vector &pt );
|
|
|
|
// The EZ particle singletons use this - they don't want to be added to all the leaves and drawn through the
|
|
// leaf system - they are specifically told to draw each frame at a certain point.
|
|
void SetDrawThruLeafSystem( int bDraw );
|
|
|
|
// Some view model particle effects want to be drawn right before the view model (after everything else is
|
|
// drawn).
|
|
void SetDrawBeforeViewModel( int bDraw );
|
|
|
|
// Call this to have the effect removed whenever it safe to do so.
|
|
// This is a lot safer than calling CParticleMgr::RemoveEffect.
|
|
int GetRemoveFlag() { return GetFlag( FLAGS_REMOVE ); }
|
|
void SetRemoveFlag() { SetFlag( FLAGS_REMOVE, 1 ); }
|
|
|
|
// Set this flag to tell the particle manager to simulate your particles even
|
|
// if the particle system isn't visible. Tempents and fast effects can always use
|
|
// this if they want since they want to simulate their particles until they go away.
|
|
// This flag is ON by default.
|
|
int GetAlwaysSimulate() { return GetFlag( FLAGS_ALWAYSSIMULATE ); }
|
|
void SetAlwaysSimulate( int bAlwaysSimulate ) { SetFlag( FLAGS_ALWAYSSIMULATE, bAlwaysSimulate ); }
|
|
|
|
void SetIsNewParticleSystem( void ) { SetFlag( FLAGS_NEW_PARTICLE_SYSTEM, 1 ); }
|
|
// Set if the effect was drawn the previous frame.
|
|
// This can be used by particle effect classes
|
|
// to decide whether or not they want to spawn
|
|
// new particles - if they weren't drawn, then
|
|
// they can 'freeze' the particle system to avoid
|
|
// overhead.
|
|
int WasDrawnPrevFrame() { return GetFlag( FLAGS_DRAWN_PREVFRAME ); }
|
|
void SetWasDrawnPrevFrame( int bWasDrawnPrevFrame ) { SetFlag( FLAGS_DRAWN_PREVFRAME, bWasDrawnPrevFrame ); }
|
|
|
|
// When the effect is in camera space mode, then the transforms are setup such that
|
|
// the particle vertices are specified in camera space (in CParticleDraw) rather than world space.
|
|
//
|
|
// This makes it faster to specify the particles - you only have to transform the center
|
|
// by CParticleMgr::GetModelView then add to X and Y to build the quad.
|
|
//
|
|
// Effects that want to specify verts (in CParticleDraw) in world space should set this to false and
|
|
// ignore CParticleMgr::GetModelView.
|
|
//
|
|
// Camera space mode is ON by default.
|
|
int IsEffectCameraSpace() { return GetFlag( FLAGS_CAMERASPACE ); }
|
|
void SetEffectCameraSpace( int bCameraSpace ) { SetFlag( FLAGS_CAMERASPACE, bCameraSpace ); }
|
|
|
|
// This tells it whether or not to apply the local transform to the matrix returned by CParticleMgr::GetModelView().
|
|
// Usually, you'll want this, so you can just say TransformParticle( pMgr->GetModelView(), vPos ), but you may want
|
|
// to manually apply your local transform before saying TransformParticle.
|
|
//
|
|
// This is ON by default.
|
|
int GetAutoApplyLocalTransform() const { return GetFlag( FLAGS_AUTOAPPLYLOCALTRANSFORM ); }
|
|
void SetAutoApplyLocalTransform( int b ) { SetFlag( FLAGS_AUTOAPPLYLOCALTRANSFORM, b ); }
|
|
|
|
// If this is true, then the bbox is calculated from particle positions. This works
|
|
// fine if you always simulate (SetAlwaysSimulateFlag) so the system can become visible
|
|
// if it moves into the PVS. If you don't use this, then you should call SetBBox at
|
|
// least once to tell the particle manager where your entity is.
|
|
int GetAutoUpdateBBox() { return GetFlag( FLAGS_AUTOUPDATEBBOX ); }
|
|
void SetAutoUpdateBBox( int bAutoUpdate ) { SetFlag( FLAGS_AUTOUPDATEBBOX, bAutoUpdate ); }
|
|
|
|
// Get the current number of particles in the effect.
|
|
int GetNumActiveParticles();
|
|
|
|
// The is the max size of the particles for use in bounding computation
|
|
void SetParticleCullRadius( float flMaxParticleRadius );
|
|
|
|
// Build a list of all active particles, returns actual count filled in
|
|
int GetActiveParticleList( int nCount, Particle **ppParticleList );
|
|
|
|
// detect origin/bbox changes and update leaf system if necessary
|
|
void DetectChanges();
|
|
|
|
private:
|
|
// Change flags..
|
|
void SetFlag( int flag, int bOn ) { if( bOn ) m_Flags |= flag; else m_Flags &= ~flag; }
|
|
int GetFlag( int flag ) const { return m_Flags & flag; }
|
|
|
|
void Init( CParticleMgr *pMgr, IParticleEffect *pSim );
|
|
void Term();
|
|
|
|
// Get rid of the specified particle.
|
|
void RemoveParticle( Particle *pParticle );
|
|
|
|
void StartDrawMaterialParticles(
|
|
CEffectMaterial *pMaterial,
|
|
float flTimeDelta,
|
|
IMesh* &pMesh,
|
|
CMeshBuilder &builder,
|
|
ParticleDraw &particleDraw,
|
|
bool bWireframe );
|
|
|
|
int DrawMaterialParticles(
|
|
bool bBucketSort,
|
|
CEffectMaterial *pMaterial,
|
|
float flTimeDelta,
|
|
bool bWireframe
|
|
);
|
|
|
|
void GrowBBoxFromParticlePositions( CEffectMaterial *pMaterial, bool &bboxSet, Vector &bbMin, Vector &bbMax );
|
|
|
|
void RenderStart( VMatrix &mTempModel, VMatrix &mTempView );
|
|
void RenderEnd( VMatrix &mModel, VMatrix &mView );
|
|
|
|
void BBoxCalcStart( Vector &bbMin, Vector &bbMax );
|
|
void BBoxCalcEnd( bool bboxSet, Vector &bbMin, Vector &bbMax );
|
|
|
|
void DoBucketSort(
|
|
CEffectMaterial *pMaterial,
|
|
float *zCoords,
|
|
int nZCoords,
|
|
float minZ,
|
|
float maxZ );
|
|
|
|
int GetRemovalInProgressFlag() { return GetFlag( FLAGS_REMOVALINPROGRESS ); }
|
|
void SetRemovalInProgressFlag() { SetFlag( FLAGS_REMOVALINPROGRESS, 1 ); }
|
|
|
|
// BBox is recalculated before it's put into the tree for the first time.
|
|
int GetNeedsBBoxUpdate() { return GetFlag( FLAGS_NEEDS_BBOX_UPDATE ); }
|
|
void SetNeedsBBoxUpdate( int bFirstUpdate ) { SetFlag( FLAGS_NEEDS_BBOX_UPDATE, bFirstUpdate ); }
|
|
|
|
// Set on creation and cleared after the first PostRender (whether or not the system was rendered).
|
|
int GetFirstFrameFlag() { return GetFlag( FLAGS_FIRST_FRAME ); }
|
|
void SetFirstFrameFlag( int bFirstUpdate ) { SetFlag( FLAGS_FIRST_FRAME, bFirstUpdate ); }
|
|
|
|
int WasDrawn() { return GetFlag( FLAGS_DRAWN ); }
|
|
void SetDrawn( int bDrawn ) { SetFlag( FLAGS_DRAWN, bDrawn ); }
|
|
|
|
// Update m_Min/m_Max. Returns false and sets the bbox to the sort origin if there are no particles.
|
|
bool RecalculateBoundingBox();
|
|
|
|
CEffectMaterial* GetEffectMaterial( CParticleSubTexture *pSubTexture );
|
|
|
|
// IClientRenderable overrides.
|
|
public:
|
|
|
|
virtual const Vector& GetRenderOrigin( void );
|
|
virtual const QAngle& GetRenderAngles( void );
|
|
virtual const matrix3x4_t & RenderableToWorldTransform();
|
|
virtual void GetRenderBounds( Vector& mins, Vector& maxs );
|
|
virtual bool ShouldDraw( void );
|
|
virtual bool IsTransparent( void );
|
|
virtual int DrawModel( int flags );
|
|
|
|
|
|
private:
|
|
|
|
enum
|
|
{
|
|
FLAGS_REMOVE = (1<<0), // Set in SetRemoveFlag
|
|
FLAGS_REMOVALINPROGRESS = (1<<1), // Set while the effect is being removed to prevent
|
|
// infinite recursion.
|
|
FLAGS_NEEDS_BBOX_UPDATE = (1<<2), // This is set until the effect's bbox has been updated once.
|
|
FLAGS_AUTOUPDATEBBOX = (1<<3), // Update bbox automatically? Cleared in SetBBox.
|
|
FLAGS_ALWAYSSIMULATE = (1<<4), // See SetAlwaysSimulate.
|
|
FLAGS_DRAWN = (1<<5), // Set if the effect is drawn through the leaf system.
|
|
FLAGS_DRAWN_PREVFRAME = (1<<6), // Set if the effect was drawn the previous frame.
|
|
// This can be used by particle effect classes
|
|
// to decide whether or not they want to spawn
|
|
// new particles - if they weren't drawn, then
|
|
// they can 'freeze' the particle system to avoid
|
|
// overhead.
|
|
FLAGS_CAMERASPACE = (1<<7), // See SetEffectCameraSpace.
|
|
FLAGS_DRAW_THRU_LEAF_SYSTEM=(1<<8), // This is the default - do the effect's visibility through the leaf system.
|
|
FLAGS_DRAW_BEFORE_VIEW_MODEL=(1<<9),// Draw before the view model? If this is set, it assumes FLAGS_DRAW_THRU_LEAF_SYSTEM goes off.
|
|
FLAGS_AUTOAPPLYLOCALTRANSFORM=(1<<10), // Automatically apply the local transform to CParticleMgr::GetModelView()'s matrix.
|
|
FLAGS_FIRST_FRAME = (1<<11), // Cleared after the first frame that this system exists (so it can simulate after rendering once).
|
|
FLAGS_NEW_PARTICLE_SYSTEM= (1<<12) // uses new particle system
|
|
};
|
|
|
|
|
|
VMatrix m_LocalSpaceTransform;
|
|
bool m_bLocalSpaceTransformIdentity; // If this is true, then m_LocalSpaceTransform is assumed to be identity.
|
|
|
|
// Bounding box. Stored in WORLD space.
|
|
Vector m_Min;
|
|
Vector m_Max;
|
|
|
|
// paramter copies to detect changes
|
|
Vector m_LastMin;
|
|
Vector m_LastMax;
|
|
|
|
// The particle cull size
|
|
float m_flParticleCullRadius;
|
|
|
|
// Number of active particles.
|
|
unsigned short m_nActiveParticles;
|
|
|
|
// See CParticleMgr::m_FrameCode.
|
|
unsigned short m_FrameCode;
|
|
|
|
// For CParticleMgr's list index.
|
|
unsigned short m_ListIndex;
|
|
|
|
IParticleEffect *m_pSim;
|
|
CParticleMgr *m_pParticleMgr;
|
|
|
|
// Combination of the CParticleEffectBinding::FLAGS_ flags.
|
|
int m_Flags;
|
|
|
|
// Materials this effect is using.
|
|
enum { EFFECT_MATERIAL_HASH_SIZE = 8 };
|
|
CEffectMaterial *m_EffectMaterialHash[EFFECT_MATERIAL_HASH_SIZE];
|
|
|
|
// For faster iteration.
|
|
CUtlLinkedList<CEffectMaterial*, unsigned short> m_Materials;
|
|
|
|
// auto updates the bbox after N frames
|
|
unsigned short m_UpdateBBoxCounter;
|
|
};
|
|
|
|
|
|
class CParticleLightInfo
|
|
{
|
|
public:
|
|
Vector m_vPos;
|
|
Vector m_vColor; // 0-1
|
|
float m_flIntensity;
|
|
};
|
|
|
|
typedef IParticleEffect* (*CreateParticleEffectFN)();
|
|
|
|
enum
|
|
{
|
|
TOOLPARTICLESYSTEMID_INVALID = -1,
|
|
};
|
|
|
|
|
|
class CParticleMgr
|
|
{
|
|
friend class CParticleEffectBinding;
|
|
friend class CParticleCollection;
|
|
|
|
public:
|
|
|
|
CParticleMgr();
|
|
virtual ~CParticleMgr();
|
|
|
|
// Call at init time to preallocate the bucket of particles.
|
|
bool Init(unsigned long nPreallocatedParticles, IMaterialSystem *pMaterial);
|
|
|
|
// Shutdown - free everything.
|
|
void Term();
|
|
|
|
void LevelInit();
|
|
|
|
void RegisterEffect( const char *pEffectType, CreateParticleEffectFN func );
|
|
IParticleEffect *CreateEffect( const char *pEffectType );
|
|
|
|
// Add and remove effects from the active list.
|
|
// Note: once you call AddEffect, CParticleEffectBinding will automatically call
|
|
// RemoveEffect in its destructor.
|
|
// Note: it's much safer to call CParticleEffectBinding::SetRemoveFlag instead of
|
|
// CParticleMgr::RemoveEffect.
|
|
bool AddEffect( CParticleEffectBinding *pEffect, IParticleEffect *pSim );
|
|
void RemoveEffect( CParticleEffectBinding *pEffect );
|
|
|
|
void AddEffect( CNewParticleEffect *pEffect );
|
|
void RemoveEffect( CNewParticleEffect *pEffect );
|
|
|
|
// Called at level shutdown to free all the lingering particle effects (usually
|
|
// CParticleEffect-derived effects that can linger with noone holding onto them).
|
|
void RemoveAllEffects();
|
|
|
|
// This should be called at the start of the frame.
|
|
void IncrementFrameCode();
|
|
|
|
// This updates all the particle effects and inserts them into the leaves.
|
|
void Simulate( float fTimeDelta );
|
|
|
|
// This just marks effects that were drawn so during their next simulation they can know
|
|
// if they were drawn in the previous frame.
|
|
void PostRender();
|
|
|
|
// Draw the effects marked with SetDrawBeforeViewModel.
|
|
void DrawBeforeViewModelEffects();
|
|
|
|
// Returns the modelview matrix
|
|
VMatrix& GetModelView();
|
|
|
|
Particle *AllocParticle( int size );
|
|
void FreeParticle( Particle * );
|
|
|
|
PMaterialHandle GetPMaterial( const char *pMaterialName );
|
|
IMaterial* PMaterialToIMaterial( PMaterialHandle hMaterial );
|
|
|
|
//HACKHACK: quick fix that compensates for the fact that this system was designed to never release materials EVER.
|
|
void RepairPMaterial( PMaterialHandle hMaterial );
|
|
|
|
// Particles drawn with the ParticleSphere material will use this info.
|
|
// This should be set in IParticleEffect.
|
|
void GetDirectionalLightInfo( CParticleLightInfo &info ) const;
|
|
void SetDirectionalLightInfo( const CParticleLightInfo &info );
|
|
|
|
// add a class that gets notified of entity events
|
|
void AddEffectListener( IClientParticleListener *pListener );
|
|
void RemoveEffectListener( IClientParticleListener *pListener );
|
|
|
|
// Tool effect ids
|
|
int AllocateToolParticleEffectId();
|
|
|
|
// Remove all new effects
|
|
void RemoveAllNewEffects();
|
|
|
|
// Should particle effects be rendered?
|
|
void RenderParticleSystems( bool bEnable );
|
|
bool ShouldRenderParticleSystems() const;
|
|
|
|
// Quick profiling (counts only, not clock cycles).
|
|
bool m_bStatsRunning;
|
|
int m_nStatsFramesSinceLastAlert;
|
|
|
|
void StatsAccumulateActiveParticleSystems();
|
|
void StatsReset();
|
|
void StatsSpewResults();
|
|
void StatsNewParticleEffectDrawn ( CNewParticleEffect *pParticles );
|
|
void StatsOldParticleEffectDrawn ( CParticleEffectBinding *pParticles );
|
|
|
|
private:
|
|
struct RetireInfo_t
|
|
{
|
|
CParticleCollection *m_pCollection;
|
|
float m_flScreenArea;
|
|
bool m_bFirstFrame;
|
|
};
|
|
|
|
// Call Update() on all the effects.
|
|
void UpdateAllEffects( float flTimeDelta );
|
|
|
|
void UpdateNewEffects( float flTimeDelta ); // update new particle effects
|
|
|
|
CParticleSubTextureGroup* FindOrAddSubTextureGroup( IMaterial *pPageMaterial );
|
|
|
|
int ComputeParticleDefScreenArea( int nInfoCount, RetireInfo_t *pInfo, float *pTotalArea, CParticleSystemDefinition* pDef,
|
|
const CViewSetup& view, const VMatrix &worldToPixels, float flFocalDist );
|
|
|
|
bool RetireParticleCollections( CParticleSystemDefinition* pDef, int nCount, RetireInfo_t *pInfo, float flScreenArea, float flMaxTotalArea );
|
|
|
|
void BuildParticleSimList( CUtlVector< ParticleSimListEntry_t > &list );
|
|
bool EarlyRetireParticleSystems( int nCount, ParticleSimListEntry_t *ppEffects );
|
|
static int RetireSort( const void *p1, const void *p2 );
|
|
|
|
private:
|
|
|
|
int m_nCurrentParticlesAllocated;
|
|
|
|
// Directional lighting info.
|
|
CParticleLightInfo m_DirectionalLight;
|
|
|
|
// Frame code, used to prevent CParticleEffects from simulating multiple times per frame.
|
|
// Their DrawModel can be called multiple times per frame because of water reflections,
|
|
// but we only want to simulate the particles once.
|
|
unsigned short m_FrameCode;
|
|
|
|
bool m_bUpdatingEffects;
|
|
bool m_bRenderParticleEffects;
|
|
|
|
// All the active effects.
|
|
CUtlLinkedList<CParticleEffectBinding*, unsigned short> m_Effects;
|
|
|
|
// all the active effects using the new particle interface
|
|
CUtlIntrusiveDList< CNewParticleEffect > m_NewEffects;
|
|
|
|
|
|
CUtlVector< IClientParticleListener *> m_effectListeners;
|
|
|
|
IMaterialSystem *m_pMaterialSystem;
|
|
|
|
// Store the concatenated modelview matrix
|
|
VMatrix m_mModelView;
|
|
|
|
CUtlVector<CParticleSubTextureGroup*> m_SubTextureGroups; // lookup by group name
|
|
CUtlDict<CParticleSubTexture*,unsigned short> m_SubTextures; // lookup by material name
|
|
CParticleSubTexture m_DefaultInvalidSubTexture; // Used when they specify an invalid material name.
|
|
|
|
CUtlMap< const char*, CreateParticleEffectFN > m_effectFactories;
|
|
|
|
int m_nToolParticleEffectId;
|
|
|
|
IThreadPool *m_pThreadPool[2];
|
|
};
|
|
|
|
inline int CParticleMgr::AllocateToolParticleEffectId()
|
|
{
|
|
return m_nToolParticleEffectId++;
|
|
}
|
|
|
|
// Implement this class and register with CParticleMgr to receive particle effect add/remove notification
|
|
class IClientParticleListener
|
|
{
|
|
public:
|
|
virtual void OnParticleEffectAdded( IParticleEffect *pEffect ) = 0;
|
|
virtual void OnParticleEffectRemoved( IParticleEffect *pEffect ) = 0;
|
|
};
|
|
|
|
|
|
|
|
// Helper functions to abstract out the particle testbed app.
|
|
float Helper_GetTime();
|
|
float Helper_GetFrameTime();
|
|
float Helper_RandomFloat( float minVal, float maxVal );
|
|
int Helper_RandomInt( int minVal, int maxVal );
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------ //
|
|
// CParticleMgr inlines
|
|
// ------------------------------------------------------------------------ //
|
|
|
|
inline VMatrix& CParticleMgr::GetModelView()
|
|
{
|
|
return m_mModelView;
|
|
}
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------ //
|
|
// CParticleEffectBinding inlines.
|
|
// ------------------------------------------------------------------------ //
|
|
|
|
inline const matrix3x4_t& CParticleEffectBinding::GetLocalSpaceTransform() const
|
|
{
|
|
return m_LocalSpaceTransform.As3x4();
|
|
}
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------ //
|
|
// GLOBALS
|
|
// ------------------------------------------------------------------------ //
|
|
|
|
CParticleMgr *ParticleMgr();
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// StandardParticle_t; this is just one type of particle
|
|
// effects may implement their own particle data structures
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct StandardParticle_t : public Particle
|
|
{
|
|
// Color and alpha values are 0 - 1
|
|
void SetColor(float r, float g, float b);
|
|
void SetAlpha(float a);
|
|
|
|
Vector m_Velocity;
|
|
|
|
// How this is used is up to the effect's discretion. Some use it for how long it has been alive
|
|
// and others use it to count down until the particle disappears.
|
|
float m_Lifetime;
|
|
|
|
unsigned char m_EffectData; // Data specific to the IParticleEffect. This can be used to distinguish between
|
|
// different types of particles the effect is simulating.
|
|
unsigned short m_EffectDataWord;
|
|
|
|
unsigned char m_Color[4]; // RGBA - not all effects need to use this.
|
|
};
|
|
|
|
|
|
// ------------------------------------------------------------------------ //
|
|
// Transform a particle.
|
|
// ------------------------------------------------------------------------ //
|
|
|
|
inline void TransformParticle(const VMatrix &vMat, const Vector &vIn, Vector &vOut)
|
|
{
|
|
//vOut = vMat.VMul4x3(vIn);
|
|
vOut.x = vMat.m[0][0]*vIn.x + vMat.m[0][1]*vIn.y + vMat.m[0][2]*vIn.z + vMat.m[0][3];
|
|
vOut.y = vMat.m[1][0]*vIn.x + vMat.m[1][1]*vIn.y + vMat.m[1][2]*vIn.z + vMat.m[1][3];
|
|
vOut.z = vMat.m[2][0]*vIn.x + vMat.m[2][1]*vIn.y + vMat.m[2][2]*vIn.z + vMat.m[2][3];
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------ //
|
|
// CEffectMaterial inlines
|
|
// ------------------------------------------------------------------------ //
|
|
|
|
inline void StandardParticle_t::SetColor(float r, float g, float b)
|
|
{
|
|
m_Color[0] = (unsigned char)(r * 255.9f);
|
|
m_Color[1] = (unsigned char)(g * 255.9f);
|
|
m_Color[2] = (unsigned char)(b * 255.9f);
|
|
}
|
|
|
|
inline void StandardParticle_t::SetAlpha(float a)
|
|
{
|
|
m_Color[3] = (unsigned char)(a * 255.9f);
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// List functions.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline void UnlinkParticle( Particle *pParticle )
|
|
{
|
|
pParticle->m_pPrev->m_pNext = pParticle->m_pNext;
|
|
pParticle->m_pNext->m_pPrev = pParticle->m_pPrev;
|
|
}
|
|
|
|
inline void InsertParticleBefore( Particle *pInsert, Particle *pNext )
|
|
{
|
|
// link pCur before pPrev
|
|
pInsert->m_pNext = pNext;
|
|
pInsert->m_pPrev = pNext->m_pPrev;
|
|
pInsert->m_pNext->m_pPrev = pInsert->m_pPrev->m_pNext = pInsert;
|
|
}
|
|
|
|
inline void InsertParticleAfter( Particle *pInsert, Particle *pPrev )
|
|
{
|
|
pInsert->m_pPrev = pPrev;
|
|
pInsert->m_pNext = pPrev->m_pNext;
|
|
|
|
pInsert->m_pNext->m_pPrev = pInsert->m_pPrev->m_pNext = pInsert;
|
|
}
|
|
|
|
inline void SwapParticles( Particle *pPrev, Particle *pCur )
|
|
{
|
|
// unlink pCur
|
|
UnlinkParticle( pCur );
|
|
InsertParticleBefore( pCur, pPrev );
|
|
}
|
|
|
|
|
|
#include "particle_iterators.h"
|
|
|
|
|
|
#endif
|
|
|
|
|