Initial commit.

2013-04-04 14:32:05 -07:00
parent ba5c81da32
commit d71d53e8ec
2180 changed files with 1393544 additions and 1 deletions
--- a/codemp/client/fxscheduler.h
+++ b/codemp/client/fxscheduler.h
@@ -0,0 +1,505 @@
+
+#if !defined(FX_UTIL_H_INC)
+	#include "FxUtil.h"
+#endif
+
+#if !defined(GENERICPARSER2_H_INC)
+	#include "../qcommon/GenericParser2.h"
+#endif
+
+#ifndef FX_SCHEDULER_H_INC
+#define FX_SCHEDULER_H_INC
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <vector>
+#include <map>
+#include <list>
+#include <string>
+#pragma warning (pop)
+
+using namespace std;
+
+
+#define FX_FILE_PATH	"effects"
+
+#define FX_MAX_TRACE_DIST		16384	// SOF2 uses a larger scale
+#define FX_MAX_EFFECTS				256		// how many effects the system can store
+#define FX_MAX_2DEFFECTS			64		// how many 2d effects the system can store
+#define FX_MAX_EFFECT_COMPONENTS	24		// how many primitives an effect can hold, this should be plenty
+#define FX_MAX_PRIM_NAME			32
+	
+//-----------------------------------------------
+// These are spawn flags for primitiveTemplates
+//-----------------------------------------------
+
+#define FX_ORG_ON_SPHERE		0x00001	// Pretty dang expensive, calculates a point on a sphere/ellipsoid
+#define FX_AXIS_FROM_SPHERE		0x00002	// Can be used in conjunction with org_on_sphere to cause particles to move out 
+										//	from the center of the sphere
+#define FX_ORG_ON_CYLINDER		0x00004	// calculate point on cylinder/disk
+
+#define FX_ORG2_FROM_TRACE		0x00010
+#define FX_TRACE_IMPACT_FX		0x00020	// if trace impacts, we should play one of the specified impact fx files
+#define FX_ORG2_IS_OFFSET		0x00040	// template specified org2 should be the offset from a trace endpos or 
+										//	passed in org2. You might use this to lend a random flair to the endpos.
+										//	Note: this is done pre-trace, so you may have to specify large numbers for this
+
+#define FX_CHEAP_ORG_CALC		0x00100	// Origin is calculated relative to passed in axis unless this is on.
+#define FX_CHEAP_ORG2_CALC		0x00200	// Origin2 is calculated relative to passed in axis unless this is on.
+#define FX_VEL_IS_ABSOLUTE		0x00400	// Velocity isn't relative to passed in axis with this flag on.
+#define FX_ACCEL_IS_ABSOLUTE	0x00800	// Acceleration isn't relative to passed in axis with this flag on.
+
+#define FX_RAND_ROT_AROUND_FWD	0x01000	// Randomly rotates up and right around forward vector
+#define FX_EVEN_DISTRIBUTION	0x02000	// When you have a delay, it normally picks a random time to play.  When
+										// this flag is on, it generates an even time distribution
+#define FX_RGB_COMPONENT_INTERP	0x04000	// Picks a color on the line defined by RGB min & max, default is to pick color in cube defined by min & max
+
+#define FX_AFFECTED_BY_WIND		0x10000	// this effect primitive needs to query wind
+
+//-----------------------------------------------------------------
+//
+// CMediaHandles
+//
+// Primitive templates might want to use a list of sounds, shaders 
+//	or models to get a bit more variation in their effects.
+//
+//-----------------------------------------------------------------
+class CMediaHandles
+{
+private:
+
+	vector<int>	mMediaList;
+
+public:
+
+	void	AddHandle( int item )	{ mMediaList.push_back( item );	}
+	int		GetHandle()				{ if (mMediaList.size()==0) {return 0;}
+										else {return mMediaList[irand(0,mMediaList.size()-1)];} }
+
+	void operator=(const CMediaHandles &that );
+};
+
+
+//-----------------------------------------------------------------
+//
+// CFxRange
+//
+// Primitive templates typically use this class to define each of
+//	its members.  This is done to make it easier to create effects 
+//	with a desired range of characteristics.
+//
+//-----------------------------------------------------------------
+class CFxRange
+{
+private:
+
+	float	mMin;
+	float	mMax;
+
+public:
+
+	CFxRange(void) 									{ mMin = 0.0f; mMax = 0.0f; }
+
+	inline void		SetRange(float min,float max)	{ mMin = min; mMax = max; }
+
+	inline float	GetMax(void) const				{ return mMax; }
+	inline float	GetMin(void) const				{ return mMin; }
+	inline float	GetVal(float fraction) const	{ if(mMin != mMax) { return mMin + fraction * (mMax - mMin); } else { return mMin; } }
+	inline float	GetVal(void) const	 			{ if(mMin != mMax) { return flrand(mMin,mMax); } else { return mMin; } }
+
+	inline int		GetRoundedVal() const			{if(mMin == mMax){return (int)mMin;}
+														return (int)(flrand(mMin, mMax) + 0.5f);}
+
+	bool operator==(const CFxRange &rhs) const		{ return ((mMin == rhs.mMin) &&	(mMax == rhs.mMax)); }
+};
+
+
+//----------------------------
+// Supported primitive types
+//----------------------------
+
+enum EPrimType
+{
+	None = 0,
+	Particle,		// sprite
+	Line,
+	Tail,			// comet-like tail thing
+	Cylinder,
+	Emitter,		// emits effects as it moves, can also attach a chunk
+	Sound,
+	Decal,			// projected onto architecture
+	OrientedParticle,
+	Electricity,
+	FxRunner,
+	Light,
+	CameraShake,
+	ScreenFlash
+};
+
+
+//-----------------------------------------------------------------
+//
+// CPrimitiveTemplate
+//
+// The primitive template is used to spawn 1 or more fx primitives 
+//	with the range of characteristics defined by the template.
+//
+// As such, I just made this one huge shared class knowing that 
+//	there won't be many of them in memory at once, 	and we won't 
+//	be dynamically creating and deleting them mid-game.  Also,
+//	note that not every primitive type will use all of these fields.
+//
+//-----------------------------------------------------------------
+class CPrimitiveTemplate
+{
+
+public:
+
+	// These kinds of things should not even be allowed to be accessed publicly
+	bool			mCopy;
+	int				mRefCount;		// For a copy of a primitive...when we figure out how many items we want to spawn, 
+									//	we'll store that here and then decrement us for each we actually spawn.  When we 
+									//	hit zero, we are no longer used and so we can just free ourselves
+
+	char			mName[FX_MAX_PRIM_NAME];
+
+	EPrimType		mType;
+
+	CFxRange		mSpawnDelay;
+	CFxRange		mSpawnCount;
+	CFxRange		mLife;
+	int				mCullRange;
+
+	CMediaHandles	mMediaHandles;
+	CMediaHandles	mImpactFxHandles;
+	CMediaHandles	mDeathFxHandles;
+	CMediaHandles	mEmitterFxHandles;
+	CMediaHandles	mPlayFxHandles;
+
+	int				mFlags;			// These need to get passed on to the primitive
+	int				mSpawnFlags;	// These are only used to control spawning, but never get passed to prims.
+
+	EMatImpactEffect	mMatImpactFX;
+
+	vec3_t			mMin;
+	vec3_t			mMax;
+
+	CFxRange		mOrigin1X;
+	CFxRange		mOrigin1Y;
+	CFxRange		mOrigin1Z;
+
+	CFxRange		mOrigin2X;
+	CFxRange		mOrigin2Y;
+	CFxRange		mOrigin2Z;
+
+	CFxRange		mRadius;		// spawn on sphere/ellipse/disk stuff.
+	CFxRange		mHeight;
+	CFxRange		mWindModifier;
+
+	CFxRange		mRotation;
+	CFxRange		mRotationDelta;
+
+	CFxRange		mAngle1;
+	CFxRange		mAngle2;
+	CFxRange		mAngle3;
+
+	CFxRange		mAngle1Delta;
+	CFxRange		mAngle2Delta;
+	CFxRange		mAngle3Delta;
+
+	CFxRange		mVelX;
+	CFxRange		mVelY;
+	CFxRange		mVelZ;
+
+	CFxRange		mAccelX;
+	CFxRange		mAccelY;
+	CFxRange		mAccelZ;
+
+	CFxRange		mGravity;
+
+	CFxRange		mDensity;
+	CFxRange		mVariance;
+
+	CFxRange		mRedStart;
+	CFxRange		mGreenStart;
+	CFxRange		mBlueStart;
+
+	CFxRange		mRedEnd;
+	CFxRange		mGreenEnd;
+	CFxRange		mBlueEnd;
+
+	CFxRange		mRGBParm;
+
+	CFxRange		mAlphaStart;
+	CFxRange		mAlphaEnd;
+	CFxRange		mAlphaParm;
+
+	CFxRange		mSizeStart;
+	CFxRange		mSizeEnd;
+	CFxRange		mSizeParm;
+
+	CFxRange		mSize2Start;
+	CFxRange		mSize2End;
+	CFxRange		mSize2Parm;
+
+	CFxRange		mLengthStart;
+	CFxRange		mLengthEnd;
+	CFxRange		mLengthParm;
+
+	CFxRange		mTexCoordS;
+	CFxRange		mTexCoordT;
+
+	CFxRange		mElasticity;
+
+	int				mSoundRadius;
+	int				mSoundVolume;
+
+	// Lower level parsing utilities
+	bool ParseVector( const char *val, vec3_t min, vec3_t max );
+	bool ParseFloat( const char *val, float *min, float *max );
+	bool ParseGroupFlags( const char *val, int *flags );
+
+	// Base key processing
+	// Note that these all have their own parse functions in case it becomes important to do certain kinds
+	//	of validation specific to that type.
+	bool ParseMin( const char *val );
+	bool ParseMax( const char *val );
+	bool ParseDelay( const char *val );
+	bool ParseCount( const char *val );
+	bool ParseLife( const char *val );
+	bool ParseElasticity( const char *val );
+	bool ParseFlags( const char *val );
+	bool ParseSpawnFlags( const char *val );
+
+	bool ParseOrigin1( const char *val );
+	bool ParseOrigin2( const char *val );
+	bool ParseRadius( const char *val );
+	bool ParseHeight( const char *val );
+	bool ParseWindModifier( const char *val );
+	bool ParseRotation( const char *val );
+	bool ParseRotationDelta( const char *val );
+	bool ParseAngle( const char *val );
+	bool ParseAngleDelta( const char *val );
+	bool ParseVelocity( const char *val );
+	bool ParseAcceleration( const char *val );
+	bool ParseGravity( const char *val );
+	bool ParseDensity( const char *val );
+	bool ParseVariance( const char *val );
+
+	// Group type processing
+	bool ParseRGB( CGPGroup *grp );
+	bool ParseAlpha( CGPGroup *grp );
+	bool ParseSize( CGPGroup *grp );
+	bool ParseSize2( CGPGroup *grp );
+	bool ParseLength( CGPGroup *grp );
+
+	bool ParseModels( CGPValue *grp );
+	bool ParseShaders( CGPValue *grp );
+	bool ParseSounds( CGPValue *grp );
+
+	bool ParseImpactFxStrings( CGPValue *grp );
+	bool ParseDeathFxStrings( CGPValue *grp );
+	bool ParseEmitterFxStrings( CGPValue *grp );
+	bool ParsePlayFxStrings( CGPValue *grp );
+
+	// Group keys
+	bool ParseRGBStart( const char *val );
+	bool ParseRGBEnd( const char *val );
+	bool ParseRGBParm( const char *val );
+	bool ParseRGBFlags( const char *val );
+
+	bool ParseAlphaStart( const char *val );
+	bool ParseAlphaEnd( const char *val );
+	bool ParseAlphaParm( const char *val );
+	bool ParseAlphaFlags( const char *val );
+
+	bool ParseSizeStart( const char *val );
+	bool ParseSizeEnd( const char *val );
+	bool ParseSizeParm( const char *val );
+	bool ParseSizeFlags( const char *val );
+
+	bool ParseSize2Start( const char *val );
+	bool ParseSize2End( const char *val );
+	bool ParseSize2Parm( const char *val );
+	bool ParseSize2Flags( const char *val );
+
+	bool ParseLengthStart( const char *val );
+	bool ParseLengthEnd( const char *val );
+	bool ParseLengthParm( const char *val );
+	bool ParseLengthFlags( const char *val );
+
+	bool ParseMaterialImpact(const char *val);
+
+public:
+
+	CPrimitiveTemplate();
+	~CPrimitiveTemplate()	{};
+
+	bool ParsePrimitive( CGPGroup *grp );
+
+	void operator=(const CPrimitiveTemplate &that);
+};
+
+// forward declaration
+struct SEffectTemplate;
+
+// Effects are built of one or more primitives
+struct SEffectTemplate
+{
+	bool	mInUse;
+	bool	mCopy;
+	char	mEffectName[MAX_QPATH];					// is this extraneous??
+	int		mPrimitiveCount;
+	int		mRepeatDelay;
+	CPrimitiveTemplate	*mPrimitives[FX_MAX_EFFECT_COMPONENTS];	 
+
+	bool operator == (const char * name) const 
+	{
+		return !stricmp( mEffectName, name );
+	}
+	void operator=(const SEffectTemplate &that);
+};
+
+
+
+//-----------------------------------------------------------------
+//
+// CFxScheduler
+//
+// The scheduler not only handles requests to play an effect, it 
+//	tracks the request throughout its life if necessary, creating 
+//	any of the delayed components as needed.
+//
+//-----------------------------------------------------------------
+class CFxScheduler
+{
+private:
+
+	// We hold a scheduled effect here
+	struct SScheduledEffect
+	{
+		CPrimitiveTemplate	*mpTemplate;	// primitive template
+		int		mStartTime;
+		char	mModelNum;		// uset to determine which ghoul2 model we want to bolt this effect to
+		char	mBoltNum;		// used to determine which bolt on the ghoul2 model we should be attaching this effect to
+		short	mEntNum;		// used to determine which entity this ghoul model is attached to.
+		bool	mPortalEffect;	// rww - render this before skyportals, and not in the normal world view.
+		bool	mIsRelative;	// bolt this puppy on keep it updated
+		int		iGhoul2;
+		vec3_t	mOrigin;
+		vec3_t	mAxis[3];
+
+		bool operator <= (const int time) const 
+		{
+			return mStartTime <= time;
+		}
+	};
+
+/* Looped Effects get stored and reschedule at mRepeatRate */
+	#define MAX_LOOPED_FX 32
+	// We hold a looped effect here
+	struct SLoopedEffect
+	{
+		int		mId;			// effect id
+		int		mBoltInfo;		// used to determine which bolt on the ghoul2 model we should be attaching this effect to
+		CGhoul2Info_v mGhoul2;
+		int		mNextTime;		//time to render again
+		int		mLoopStopTime;	//time to die
+		bool	mPortalEffect;	// rww - render this before skyportals, and not in the normal world view.
+		bool	mIsRelative;	// bolt this puppy on keep it updated
+	};
+
+	SLoopedEffect	mLoopedEffectArray[MAX_LOOPED_FX];
+
+	int		ScheduleLoopedEffect( int id, int boltInfo, int iGhoul2, bool isPortal, int iLoopTime, bool isRelative );
+	void	AddLoopedEffects( );
+
+
+	class CScheduled2DEffect
+	{
+	public:
+		CScheduled2DEffect():
+		mScreenX(0),
+		mScreenY(0),
+		mWidth(0),
+		mHeight(0),
+		mShaderHandle(0)
+		{mColor[0]=mColor[1]=mColor[2]=mColor[3]=1.0f;}
+
+	public:
+		float		mScreenX;
+		float		mScreenY;
+		float		mWidth;
+		float		mHeight;
+		vec4_t		mColor;		// bytes A, G, B, R -- see class paletteRGBA_c
+		qhandle_t	mShaderHandle;
+	};
+
+	// this makes looking up the index based on the string name much easier
+	typedef map<string, int>				TEffectID;
+
+	typedef list<SScheduledEffect*>			TScheduledEffect;
+
+	// Effects
+	SEffectTemplate		mEffectTemplates[FX_MAX_EFFECTS];
+	TEffectID			mEffectIDs;								// if you only have the unique effect name, you'll have to use this to get the ID.
+
+	// 2D effects
+	CScheduled2DEffect	m2DEffects[FX_MAX_2DEFFECTS];
+	int					mNextFree2DEffect;
+
+	// List of scheduled effects that will need to be created at the correct time.
+	TScheduledEffect	mFxSchedule;
+
+
+	// Private function prototypes
+	SEffectTemplate *GetNewEffectTemplate( int *id, const char *file );
+
+	void	AddPrimitiveToEffect( SEffectTemplate *fx, CPrimitiveTemplate *prim );
+	int		ParseEffect( const char *file, CGPGroup *base );
+
+	void	CreateEffect( CPrimitiveTemplate *fx, const vec3_t origin, vec3_t axis[3], int lateTime, int fxParm = -1,  int iGhoul2 = 0, int entNum = -1, int modelNum = -1, int boltNum = -1);
+	void	CreateEffect( CPrimitiveTemplate *fx, SScheduledEffect *schedFx );
+
+public:
+
+	CFxScheduler();
+	
+	int		RegisterEffect( const char *file, bool bHasCorrectPath = false );	// handles pre-caching
+
+	// Nasty overloaded madness
+	//rww - maybe this should be done differently.. it's more than a bit confusing.
+	//Remind me when I don't have 50 files checked out.
+	void	PlayEffect( int id, vec3_t org, vec3_t fwd, int vol = -1, int rad = -1, bool isPortal = false );				// builds arbitrary perp. right vector, does a cross product to define up
+	void	PlayEffect( int id, vec3_t origin, vec3_t axis[3], const int boltInfo=-1, int iGhoul2 = 0,
+				int fxParm = -1, int vol = -1, int rad = -1, bool isPortal = false, int iLoopTime = false, bool isRelative = false  );
+	void	PlayEffect( const char *file, vec3_t org, int vol = -1, int rad = -1 );					// uses a default up axis
+	void	PlayEffect( const char *file, vec3_t org, vec3_t fwd, int vol = -1, int rad = -1 );		// builds arbitrary perp. right vector, does a cross product to define up
+	void	PlayEffect( const char *file, vec3_t origin, 
+				vec3_t axis[3], const int boltInfo = -1, int iGhoul2 = 0, int fxParm = -1, int vol = -1, int rad = -1, int iLoopTime = false, bool isRelative = false );
+
+	void	StopEffect( const char *file, const int boltInfo, bool isPortal = false );	//find a scheduled Looping effect with these parms and kill it
+	void	AddScheduledEffects( bool portal );								// call once per CGame frame
+
+	// kef -- called for a 2D effect instead of addRefToScene
+	bool	Add2DEffect(float x, float y, float w, float h, vec4_t color, qhandle_t shaderHandle);
+	// kef -- called once per cgame frame AFTER cgi.RenderScene
+	void	Draw2DEffects(float screenXScale, float screenYScale);
+
+	int		NumScheduledFx()	{ return mFxSchedule.size();	}
+	void	Clean(bool bRemoveTemplates = true, int idToPreserve = 0);	// clean out the system
+
+	// FX Override functions
+	SEffectTemplate		*GetEffectCopy( int fxHandle, int *newHandle );
+	SEffectTemplate		*GetEffectCopy( const char *file, int *newHandle );
+
+	CPrimitiveTemplate	*GetPrimitiveCopy( SEffectTemplate *effectCopy, const char *componentName );
+
+	void	MaterialImpact(trace_t *tr, CEffect *effect);
+};
+
+//-------------------
+// The one and only
+//-------------------
+extern CFxScheduler theFxScheduler;
+
+#endif // FX_SCHEDULER_H_INC