685 lines
No EOL
19 KiB
C++
685 lines
No EOL
19 KiB
C++
#if !defined(G2_H_INC)
|
|
#include "../ghoul2/ghoul2_shared.h"
|
|
#endif
|
|
|
|
#if !defined(FX_SYSTEM_H_INC)
|
|
#include "FxSystem.h"
|
|
#endif
|
|
|
|
#ifndef FX_PRIMITIVES_H_INC
|
|
#define FX_PRIMITIVES_H_INC
|
|
|
|
#ifdef CHC
|
|
#define MAX_EFFECTS 1024
|
|
#else // anything else
|
|
#define MAX_EFFECTS 1800
|
|
#endif
|
|
|
|
// Generic group flags, used by parser, then get converted to the appropriate specific flags
|
|
#define FX_PARM_MASK 0xC // use this to mask off any transition types that use a parm
|
|
#define FX_GENERIC_MASK 0xF
|
|
#define FX_LINEAR 0x1
|
|
#define FX_RAND 0x2
|
|
#define FX_NONLINEAR 0x4
|
|
#define FX_WAVE 0x8
|
|
#define FX_CLAMP 0xC
|
|
|
|
// Group flags
|
|
#define FX_ALPHA_SHIFT 0
|
|
#define FX_ALPHA_PARM_MASK 0x0000000C
|
|
#define FX_ALPHA_LINEAR 0x00000001
|
|
#define FX_ALPHA_RAND 0x00000002
|
|
#define FX_ALPHA_NONLINEAR 0x00000004
|
|
#define FX_ALPHA_WAVE 0x00000008
|
|
#define FX_ALPHA_CLAMP 0x0000000C
|
|
|
|
#define FX_RGB_SHIFT 4
|
|
#define FX_RGB_PARM_MASK 0x000000C0
|
|
#define FX_RGB_LINEAR 0x00000010
|
|
#define FX_RGB_RAND 0x00000020
|
|
#define FX_RGB_NONLINEAR 0x00000040
|
|
#define FX_RGB_WAVE 0x00000080
|
|
#define FX_RGB_CLAMP 0x000000C0
|
|
|
|
#define FX_SIZE_SHIFT 8
|
|
#define FX_SIZE_PARM_MASK 0x00000C00
|
|
#define FX_SIZE_LINEAR 0x00000100
|
|
#define FX_SIZE_RAND 0x00000200
|
|
#define FX_SIZE_NONLINEAR 0x00000400
|
|
#define FX_SIZE_WAVE 0x00000800
|
|
#define FX_SIZE_CLAMP 0x00000C00
|
|
|
|
#define FX_LENGTH_SHIFT 12
|
|
#define FX_LENGTH_PARM_MASK 0x0000C000
|
|
#define FX_LENGTH_LINEAR 0x00001000
|
|
#define FX_LENGTH_RAND 0x00002000
|
|
#define FX_LENGTH_NONLINEAR 0x00004000
|
|
#define FX_LENGTH_WAVE 0x00008000
|
|
#define FX_LENGTH_CLAMP 0x0000C000
|
|
|
|
#define FX_SIZE2_SHIFT 16
|
|
#define FX_SIZE2_PARM_MASK 0x000C0000
|
|
#define FX_SIZE2_LINEAR 0x00010000
|
|
#define FX_SIZE2_RAND 0x00020000
|
|
#define FX_SIZE2_NONLINEAR 0x00040000
|
|
#define FX_SIZE2_WAVE 0x00080000
|
|
#define FX_SIZE2_CLAMP 0x000C0000
|
|
|
|
// Feature flags
|
|
#define FX_DEPTH_HACK 0x00100000
|
|
#define FX_RELATIVE 0x00200000
|
|
#define FX_SET_SHADER_TIME 0x00400000 // when the shader time gets set in-game, animating textures start animating at the first frame
|
|
#define FX_EXPENSIVE_PHYSICS 0x00800000
|
|
|
|
#define FX_ATTACHED_MODEL 0x01000000
|
|
|
|
#define FX_APPLY_PHYSICS 0x02000000
|
|
#define FX_USE_BBOX 0x04000000 // can make physics more accurate at the expense of speed
|
|
|
|
#define FX_USE_ALPHA 0x08000000 // the FX system actually uses RGB to do fades, but this will override that
|
|
// and cause it to fill in the alpha.
|
|
|
|
#define FX_EMIT_FX 0x10000000 // emitters technically don't have to emit stuff, but when they do
|
|
// this flag needs to be set
|
|
#define FX_DEATH_RUNS_FX 0x20000000 // Normal death triggers effect, but not kill_on_impact
|
|
#define FX_KILL_ON_IMPACT 0x40000000 // works just like it says, but only when physics are on.
|
|
#define FX_IMPACT_RUNS_FX 0x80000000 // an effect can call another effect when it hits something.
|
|
|
|
// Lightning flags, duplicates of existing flags, but lightning doesn't use those flags in that context...and nothing will ever use these in this context..so we are safe.
|
|
#define FX_TAPER 0x01000000 // tapers as it moves towards its endpoint
|
|
#define FX_BRANCH 0x02000000 // enables lightning branching
|
|
#define FX_GROW 0x04000000 // lightning grows from start point to end point over the course of its life
|
|
|
|
class CFxBoltInterface
|
|
{
|
|
private:
|
|
bool mIsValid;
|
|
vec3_t mOrg;
|
|
vec3_t mFwd;
|
|
vec3_t mScale;
|
|
CGhoul2Info_v *mG2Inst;
|
|
int mModelNum;
|
|
int mBoltNum;
|
|
int mEntNum;
|
|
|
|
vec3_t mInitialPartOrg;
|
|
vec3_t mInitialOffset;
|
|
|
|
public:
|
|
|
|
CFxBoltInterface() { mIsValid = true; };
|
|
virtual ~CFxBoltInterface() {};
|
|
|
|
void GetOrigin( vec3_t org ) { VectorCopy(mOrg, org); }; // the fx system will call this to get the new origin
|
|
void GetForward( vec3_t dir ) { VectorCopy(mFwd, dir); }; // and this to get the new forward. Getting the whole axis is not necessary
|
|
void GetScale( vec3_t scale ) { VectorCopy(mScale, scale); }; // and this to get the new forward. Getting the whole axis is not necessary
|
|
|
|
void GetInitialPartOrg( vec3_t org ) { VectorCopy(mInitialPartOrg, org); };
|
|
void GetInitialOffset( vec3_t org ) { VectorCopy(mInitialOffset, org); };
|
|
|
|
CGhoul2Info_v *GetG2Handle( void ) { return mG2Inst; }
|
|
int GetModelNum( void ) { return mModelNum; }
|
|
int GetBoltNum( void ) { return mBoltNum; }
|
|
int GetEntNum( void ) { return mEntNum; }
|
|
|
|
void SetOrigin( vec3_t org ) { VectorCopy(org, mOrg); }; // the fx system will call this to get the new origin
|
|
void SetForward( vec3_t dir ) { VectorCopy(dir, mFwd); }; // and this to get the new forward. Getting the whole axis is not necessary
|
|
void SetScale( vec3_t scale ) { VectorCopy(scale, mScale); }; // and this to get the new forward. Getting the whole axis is not necessary
|
|
|
|
void SetInitialPartOrg( vec3_t org ) { VectorCopy(org, mInitialPartOrg); };
|
|
void SetInitialOffset( vec3_t org ) { VectorCopy(org, mInitialOffset); };
|
|
|
|
void SetG2Handle( CGhoul2Info_v *g2Inst ) { mG2Inst = g2Inst; }
|
|
void SetModelNum( int modelNum ) { mModelNum = modelNum; }
|
|
void SetBoltNum( int boltNum ) { mBoltNum = boltNum; }
|
|
void SetEntNum( int entNum ) { mEntNum = entNum; }
|
|
|
|
bool IsValid( void ) { return mIsValid; }
|
|
void Invalidate( void ) { mIsValid = false; } // If the thing we are bolted to is no longer valid, clue up the fx system so it doesn't try to do dumb things
|
|
void Validate() { mIsValid = true; }
|
|
};
|
|
|
|
//------------------------------
|
|
class CEffect
|
|
{
|
|
protected:
|
|
|
|
vec3_t mOrigin1;
|
|
|
|
int mTimeStart;
|
|
int mTimeEnd;
|
|
|
|
int mFlags;
|
|
|
|
// Size of our object, useful for things that have physics
|
|
vec3_t mMin;
|
|
vec3_t mMax;
|
|
|
|
int mImpactFxID; // if we have an impact event, we may have to call an effect
|
|
int mDeathFxID; // if we have a death event, we may have to call an effect
|
|
|
|
int mKillTime;
|
|
|
|
CFxBoltInterface mBoltInterface;
|
|
bool mBoltInterfaceValid;
|
|
|
|
miniRefEntity_t mRefEnt;
|
|
CEffect *mNext;
|
|
|
|
public:
|
|
|
|
CEffect();
|
|
virtual ~CEffect();
|
|
|
|
virtual void Die();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
inline miniRefEntity_t &GetRefEnt(void) { return mRefEnt; }
|
|
|
|
inline void SetNext(CEffect *Next) { mNext = Next; }
|
|
inline CEffect *GetNext(void) { return mNext; }
|
|
inline void SetKillTime(int KillTime) { mKillTime = KillTime; }
|
|
inline int GetKillTime(void) { return mKillTime; }
|
|
inline int GetFlags(void) { return mFlags; }
|
|
|
|
inline void SetSTScale(float s,float t) { mRefEnt.shaderTexCoord[0]=s;mRefEnt.shaderTexCoord[1]=t;}
|
|
|
|
inline void SetMin( vec3_t min ) { if(min){VectorCopy(min,mMin);}else{VectorClear(mMin);} }
|
|
inline void SetMax( vec3_t max ) { if(max){VectorCopy(max,mMax);}else{VectorClear(mMax);} }
|
|
inline void SetFlags( int flags ) { mFlags = flags; }
|
|
inline void AddFlags( int flags ) { mFlags |= flags; }
|
|
inline void ClearFlags( int flags ) { mFlags &= ~flags; }
|
|
inline void SetOrigin1( vec3_t org ) { if(org){VectorCopy(org,mOrigin1);}else{VectorClear(mOrigin1);} }
|
|
inline void SetTimeStart( int time ) { mTimeStart = time; if (mFlags&FX_SET_SHADER_TIME) { mRefEnt.shaderTime = time * 0.001f; }}
|
|
inline void SetTimeEnd( int time ) { mTimeEnd = time; }
|
|
inline void SetImpactFxID( int id ) { mImpactFxID = id; }
|
|
inline void SetDeathFxID( int id ) { mDeathFxID = id; }
|
|
inline bool IsBoltInterfaceValid() { return mBoltInterfaceValid; }
|
|
inline CFxBoltInterface *GetBIPointer() { return &mBoltInterface; }
|
|
inline void GetOrigin1( vec3_t put_to ) { VectorCopy(mOrigin1, put_to); }
|
|
inline void ForceOrigin1( vec3_t shove_in ) { VectorCopy(shove_in, mOrigin1); }
|
|
|
|
inline void SetBoltInterface(CFxBoltInterface *obj)
|
|
{
|
|
vec3_t store;
|
|
|
|
mBoltInterface.SetEntNum(obj->GetEntNum());
|
|
mBoltInterface.SetBoltNum(obj->GetBoltNum());
|
|
mBoltInterface.SetModelNum(obj->GetModelNum());
|
|
mBoltInterface.SetG2Handle(obj->GetG2Handle());
|
|
|
|
obj->GetForward(store);
|
|
mBoltInterface.SetForward(store);
|
|
obj->GetOrigin(store);
|
|
mBoltInterface.SetOrigin(store);
|
|
obj->GetScale(store);
|
|
mBoltInterface.SetScale(store);
|
|
obj->GetInitialOffset(store);
|
|
mBoltInterface.SetInitialOffset(store);
|
|
obj->GetInitialPartOrg(store);
|
|
mBoltInterface.SetInitialPartOrg(store);
|
|
|
|
mBoltInterfaceValid = true;
|
|
}
|
|
};
|
|
|
|
class CCloud : public CEffect
|
|
{
|
|
private:
|
|
int mNumPending;
|
|
|
|
public:
|
|
CCloud();
|
|
virtual ~CCloud();
|
|
|
|
void IncreasePending(void) { mNumPending++; }
|
|
void DecreasePending(void) { mNumPending--; }
|
|
virtual void Die();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
void AddEffect(CEffect *which);
|
|
};
|
|
|
|
//#ifdef CHC
|
|
//---------------------------------------------------
|
|
// This class is kind of an exception to the "rule".
|
|
// For now it exists only for allowing an easy way
|
|
// to get the saber slash trails rendered.
|
|
//---------------------------------------------------
|
|
class CTrail : public CEffect
|
|
{
|
|
// This is such a specific case thing, just grant public access to the goods.
|
|
public:
|
|
|
|
typedef struct
|
|
{
|
|
vec3_t origin;
|
|
|
|
// very specifc case, we can modulate the color and the alpha
|
|
vec3_t rgb;
|
|
vec3_t destrgb;
|
|
vec3_t curRGB;
|
|
|
|
float alpha;
|
|
float destAlpha;
|
|
float curAlpha;
|
|
|
|
// this is a very specific case thing...allow interpolating the st coords so we can map the texture
|
|
// properly as this segement progresses through it's life
|
|
float ST[2];
|
|
float destST[2];
|
|
float curST[2];
|
|
|
|
} TVert;
|
|
|
|
TVert mVerts[4];
|
|
qhandle_t mShader;
|
|
|
|
|
|
CTrail() {};
|
|
virtual ~CTrail() {};
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
};
|
|
//#endif // CHC
|
|
|
|
//------------------------------
|
|
class CLight : public CEffect
|
|
{
|
|
protected:
|
|
|
|
float mSizeStart;
|
|
float mSizeEnd;
|
|
float mSizeParm;
|
|
|
|
vec3_t mRGBStart;
|
|
vec3_t mRGBEnd;
|
|
float mRGBParm;
|
|
|
|
|
|
void UpdateSize();
|
|
void UpdateRGB();
|
|
|
|
public:
|
|
|
|
CLight();
|
|
virtual ~CLight();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
inline void SetSizeStart( float sz ) { mSizeStart = sz; }
|
|
inline void SetSizeEnd( float sz ) { mSizeEnd = sz; }
|
|
inline void SetSizeParm( float parm ) { mSizeParm = parm; }
|
|
|
|
inline void SetRGBStart( vec3_t rgb ) { if(rgb){VectorCopy(rgb,mRGBStart);}else{VectorClear(mRGBStart);} }
|
|
inline void SetRGBEnd( vec3_t rgb ) { if(rgb){VectorCopy(rgb,mRGBEnd);}else{VectorClear(mRGBEnd);} }
|
|
inline void SetRGBParm( float parm ) { mRGBParm = parm; }
|
|
};
|
|
|
|
//------------------------------
|
|
class CFlash : public CLight
|
|
{
|
|
public:
|
|
|
|
CFlash() {}
|
|
virtual ~CFlash() {}
|
|
|
|
virtual bool Cull() { return false; }
|
|
virtual bool Update();
|
|
virtual void Draw();
|
|
|
|
inline void SetShader( qhandle_t sh ) { mRefEnt.customShader = sh; }
|
|
void Init( void );
|
|
};
|
|
|
|
|
|
//------------------------------
|
|
class CParticle : public CEffect
|
|
{
|
|
protected:
|
|
|
|
vec3_t mVel;
|
|
vec3_t mAccel;
|
|
|
|
float mSizeStart;
|
|
float mSizeEnd;
|
|
float mSizeParm;
|
|
|
|
vec3_t mRGBStart;
|
|
vec3_t mRGBEnd;
|
|
float mRGBParm;
|
|
|
|
float mAlphaStart;
|
|
float mAlphaEnd;
|
|
float mAlphaParm;
|
|
|
|
float mRotationDelta;
|
|
float mElasticity;
|
|
|
|
|
|
bool UpdateOrigin();
|
|
void UpdateVelocity();
|
|
void UpdateSize();
|
|
void UpdateRGB();
|
|
void UpdateAlpha();
|
|
void UpdateRotation();
|
|
|
|
#ifndef EFFECTSED
|
|
#ifndef CHC
|
|
CFxBoltInterface *mObj;
|
|
CFxBoltInterface storedObj;
|
|
#endif
|
|
#endif
|
|
|
|
public:
|
|
|
|
CParticle();
|
|
virtual ~CParticle();
|
|
|
|
virtual void Die();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
inline void SetShader( qhandle_t sh ) { mRefEnt.customShader = sh; }
|
|
|
|
inline void SetVel( vec3_t vel ) { if(vel){VectorCopy(vel,mVel);}else{VectorClear(mVel);} }
|
|
inline void SetAccel( vec3_t ac ) { if(ac){VectorCopy(ac,mAccel);}else{VectorClear(mAccel);} }
|
|
|
|
inline void SetSizeStart( float sz ) { mSizeStart = sz; }
|
|
inline void SetSizeEnd( float sz ) { mSizeEnd = sz; }
|
|
inline void SetSizeParm( float parm ) { mSizeParm = parm; }
|
|
|
|
inline void SetRGBStart( vec3_t rgb ) { if(rgb){VectorCopy(rgb,mRGBStart);}else{VectorClear(mRGBStart);} }
|
|
inline void SetRGBEnd( vec3_t rgb ) { if(rgb){VectorCopy(rgb,mRGBEnd);}else{VectorClear(mRGBEnd);} }
|
|
inline void SetRGBParm( float parm ) { mRGBParm = parm; }
|
|
|
|
inline void SetAlphaStart( float al ) { mAlphaStart = al; }
|
|
inline void SetAlphaEnd( float al ) { mAlphaEnd = al; }
|
|
inline void SetAlphaParm( float parm ) { mAlphaParm = parm; }
|
|
|
|
inline void SetRotation( float rot ) { mRefEnt.rotation = rot; }
|
|
inline void SetRotationDelta( float rot ) { mRotationDelta = rot; }
|
|
inline void SetElasticity( float el ) { mElasticity = el; }
|
|
|
|
#ifndef EFFECTSED
|
|
#ifndef CHC
|
|
inline void SetObj( CFxBoltInterface *obj ) { mObj = obj; }
|
|
|
|
inline void SetObjNew( CFxBoltInterface *obj )
|
|
{ //This is necessary when we want to copy the contents of a temporary variable and use them in a scheduled effect
|
|
vec3_t store;
|
|
|
|
mObj = &storedObj;
|
|
|
|
mObj->SetEntNum(obj->GetEntNum());
|
|
mObj->SetBoltNum(obj->GetBoltNum());
|
|
mObj->SetModelNum(obj->GetModelNum());
|
|
mObj->SetG2Handle(obj->GetG2Handle());
|
|
|
|
obj->GetForward(store);
|
|
mObj->SetForward(store);
|
|
obj->GetOrigin(store);
|
|
mObj->SetOrigin(store);
|
|
obj->GetScale(store);
|
|
mObj->SetScale(store);
|
|
obj->GetInitialOffset(store);
|
|
mObj->SetInitialOffset(store);
|
|
obj->GetInitialPartOrg(store);
|
|
mObj->SetInitialPartOrg(store);
|
|
}
|
|
#endif
|
|
#endif
|
|
};
|
|
|
|
|
|
//------------------------------
|
|
class CLine : public CParticle
|
|
{
|
|
protected:
|
|
|
|
vec3_t mOrigin2;
|
|
|
|
public:
|
|
|
|
CLine();
|
|
virtual ~CLine();
|
|
|
|
virtual void Die();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
inline void SetOrigin2( vec3_t org2 ) { VectorCopy( org2, mOrigin2 ); }
|
|
};
|
|
|
|
//------------------------------
|
|
class CBezier : public CLine
|
|
{
|
|
protected:
|
|
|
|
vec3_t mControl1;
|
|
vec3_t mControl1Vel;
|
|
|
|
vec3_t mControl2;
|
|
vec3_t mControl2Vel;
|
|
|
|
bool mInit;
|
|
|
|
public:
|
|
|
|
CBezier(){ mInit = false; }
|
|
virtual ~CBezier() {}
|
|
virtual void Die() {}
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
void DrawSegment( vec3_t start, vec3_t end, float texcoord1, float texcoord2 );
|
|
|
|
inline void SetControlPoints( vec3_t ctrl1, vec3_t ctrl2 ) { VectorCopy( ctrl1, mControl1 ); VectorCopy( ctrl2, mControl2 ); }
|
|
inline void SetControlVel( vec3_t ctrl1v, vec3_t ctrl2v ) { VectorCopy( ctrl1v, mControl1Vel ); VectorCopy( ctrl2v, mControl2Vel ); }
|
|
};
|
|
|
|
//------------------------------
|
|
class CElectricity : public CLine
|
|
{
|
|
protected:
|
|
|
|
float mChaos;
|
|
|
|
public:
|
|
|
|
CElectricity();
|
|
virtual ~CElectricity();
|
|
|
|
virtual void Die();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
void Initialize();
|
|
|
|
inline void SetChaos( float chaos ) { mChaos = chaos; }
|
|
};
|
|
|
|
|
|
// Oriented quad
|
|
//------------------------------
|
|
class COrientedParticle : public CParticle
|
|
{
|
|
protected:
|
|
|
|
vec3_t mNormal;
|
|
|
|
public:
|
|
|
|
COrientedParticle();
|
|
virtual ~COrientedParticle();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
inline void SetNormal( vec3_t norm ) { VectorCopy( norm, mNormal ); }
|
|
};
|
|
|
|
//------------------------------
|
|
class CTail : public CParticle
|
|
{
|
|
protected:
|
|
|
|
vec3_t mOldOrigin;
|
|
|
|
float mLengthStart;
|
|
float mLengthEnd;
|
|
float mLengthParm;
|
|
|
|
float mLength;
|
|
|
|
void UpdateLength();
|
|
void CalcNewEndpoint();
|
|
|
|
public:
|
|
|
|
CTail();
|
|
virtual ~CTail();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
inline void SetLengthStart( float len ) { mLengthStart = len; }
|
|
inline void SetLengthEnd( float len ) { mLengthEnd = len; }
|
|
inline void SetLengthParm( float len ) { mLengthParm = len; }
|
|
};
|
|
|
|
|
|
//------------------------------
|
|
class CCylinder : public CTail
|
|
{
|
|
protected:
|
|
|
|
float mSize2Start;
|
|
float mSize2End;
|
|
float mSize2Parm;
|
|
|
|
void UpdateSize2();
|
|
|
|
public:
|
|
|
|
CCylinder();
|
|
virtual ~CCylinder();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
|
|
inline void SetSize2Start( float sz ) { mSize2Start = sz; }
|
|
inline void SetSize2End( float sz ) { mSize2End = sz; }
|
|
inline void SetSize2Parm( float parm ) { mSize2Parm = parm; }
|
|
|
|
inline void SetNormal( vec3_t norm ) { VectorCopy( norm, mRefEnt.axis[0] ); }
|
|
};
|
|
|
|
|
|
//------------------------------
|
|
// Emitters are derived from particles because, although they don't draw, any effect called
|
|
// from them can borrow an initial or ending value from the emitters current alpha, rgb, etc..
|
|
class CEmitter : public CParticle
|
|
{
|
|
protected:
|
|
|
|
vec3_t mOldOrigin; // we use these to do some nice
|
|
vec3_t mLastOrigin; // tricks...
|
|
vec3_t mOldVelocity; //
|
|
int mOldTime;
|
|
|
|
vec3_t mAngles; // for a rotating thing, using a delta
|
|
vec3_t mAngleDelta; // as opposed to an end angle is probably much easier
|
|
|
|
int mEmitterFxID; // if we have emitter fx, this is our id
|
|
|
|
float mDensity; // controls how often emitter chucks an effect
|
|
float mVariance; // density sloppiness
|
|
|
|
void UpdateAngles();
|
|
|
|
public:
|
|
|
|
CEmitter();
|
|
virtual ~CEmitter();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
inline void SetModel( qhandle_t model ) { mRefEnt.hModel = model; }
|
|
inline void SetAngles( vec3_t ang ) { if(ang){VectorCopy(ang,mAngles);}else{VectorClear(mAngles);} }
|
|
inline void SetAngleDelta( vec3_t ang ) { if(ang){VectorCopy(ang,mAngleDelta);}else{VectorClear(mAngleDelta);} }
|
|
inline void SetEmitterFxID( int id ) { mEmitterFxID = id; }
|
|
inline void SetDensity( float density ) { mDensity = density; }
|
|
inline void SetVariance( float var ) { mVariance = var; }
|
|
inline void SetOldTime( int time ) { mOldTime = time; }
|
|
inline void SetLastOrg( vec3_t org ) { if(org){VectorCopy(org,mLastOrigin);}else{VectorClear(mLastOrigin);} }
|
|
inline void SetLastVel( vec3_t vel ) { if(vel){VectorCopy(vel,mOldVelocity);}else{VectorClear(mOldVelocity);} }
|
|
|
|
};
|
|
|
|
// We're getting pretty low level here, not the kind of thing to abuse considering how much overhead this
|
|
// adds to a SINGLE triangle or quad....
|
|
// The editor doesn't need to see or do anything with this
|
|
//------------------------------
|
|
#define MAX_CPOLY_VERTS 5
|
|
|
|
class CPoly : public CParticle
|
|
{
|
|
protected:
|
|
|
|
int mCount;
|
|
vec3_t mRotDelta;
|
|
int mTimeStamp;
|
|
|
|
public:
|
|
|
|
vec3_t mOrg[MAX_CPOLY_VERTS];
|
|
vec2_t mST[MAX_CPOLY_VERTS];
|
|
|
|
float mRot[3][3];
|
|
int mLastFrameTime;
|
|
|
|
|
|
CPoly();
|
|
virtual ~CPoly();
|
|
|
|
virtual bool Update();
|
|
virtual bool Cull();
|
|
virtual void Draw();
|
|
|
|
void PolyInit();
|
|
void CalcRotateMatrix();
|
|
void Rotate();
|
|
|
|
inline void SetNumVerts( int c ) { mCount = c; }
|
|
inline void SetRot( vec3_t r ) { if(r){VectorCopy(r,mRotDelta);}else{VectorClear(mRotDelta);}}
|
|
inline void SetMotionTimeStamp( int t ) { mTimeStamp = theFxHelper.GetTime() + t; }
|
|
inline int GetMotionTimeStamp() { return mTimeStamp; }
|
|
};
|
|
|
|
|
|
#endif //FX_PRIMITIVES_H_INC
|