tf2/tf2_src/common/ihfx/ihfxeffect.h

 
#ifndef IHFXEFFECT_H_
#define IHFXEFFECT_H_
#include ".\\HFXConfig.h"
#include ".\\IHFXParam.h"
 
struct IHapticEffectParamGroup; 
typedef IHapticEffectParamGroup IHFXParamGroup; 
class IProcessor; 
typedef IProcessor IHFXProcessor; 
class IStack; 
typedef IStack IHFXStack; 
enum HFXStateBits
{
	// when a state variable is made it uses the below value
	HFXSTATE_INITIAL		=0, 
	// explicite pause
	HFXSTATE_PAUSE			=(1<<0), 
	// explicite    mute
	HFXSTATE_MUTE			=(1<<1), 
	// the effect has gone into  its exit phase.
	HFXSTATE_EXITING		=(1<<2), 
	HFXSTATE_WANT_SYNC		=(1<<3), 
	HFXSTATE_CLIENT_ONLY	=4, 
	//everything below will be uncontrolled by servo
	HFXSTATE_WANT_UPDATE	=(1<<HFXSTATE_CLIENT_ONLY), 
	HFXSTATE_RUNNING		=(1<<(HFXSTATE_CLIENT_ONLY+1)), 
	HFXSTATE_HAULT			=(1<<(HFXSTATE_CLIENT_ONLY+2)), 
	HFXSTATE_HOLDING_EFFECT	=(1<<(HFXSTATE_CLIENT_ONLY+3)), 
	HFXSTATE_COUNT			=8, 
	// number of state bits before non servo controlled bits
}; 
typedef unsigned __int8 HFXSTATE; 
typedef HFXSTATE HFXStateStorage; 
 
#if WIN64
typedef const HFXStateStorage &HFXStateTransfer; 
#else
typedef const HFXStateStorage HFXStateTransfer; 
#endif
 
// utility union, takes up same memory as a flagset but gives you
// inline operators and helper functions for state flags
union HFX_ALIGN(8) HFXStateFlags
{
public: 
	//default constructor
	HFX_INLINE HFXStateFlags(){}; 
 
	//copy constructor
	HFX_INLINE HFXStateFlags(const HFXStateFlags &copy) : Storage(copy.Storage){}; 
 
	HFX_INLINE HFXStateFlags(HFXStateStorage flags) : Storage(flags){}; 
 
	HFX_INLINE HFXStateFlags(	 
		bool bRunning, bool bPaused, bool bMuted, bool bHaulted, bool bExiting
		) : Storage((bRunning ? HFXSTATE_RUNNING : 0)|
					(bPaused ? HFXSTATE_PAUSE : 0)|
					(bMuted ? HFXSTATE_MUTE : 0)|
					(bHaulted ? HFXSTATE_HAULT : 0)|
					(bExiting ? HFXSTATE_EXITING : 0)	) 
	{}; 
	// actual flags. (shared memory)
	HFXStateStorage Storage; 
	// flags in boolean form. (shared memory)
	struct {
		bool Running:1; 
		bool Paused:1; 
		bool Muted:1; 
		bool Haulted:1; 
		bool Exiting:1; 
	}; 
	// flags in bool group ( for -> operator )
	struct HFXStateFlagGroup{
		bool Running:1; 
		bool Paused:1; 
		bool Muted:1; 
		bool Haulted:1; 
		bool Exiting:1; 
	}Flags; 
 
	// type cast operators to flagstorage type
	HFX_INLINE operator HFXStateStorage &(){return Storage;}
	HFX_INLINE operator const HFXStateStorage &()const{return Storage;}
	HFX_INLINE operator HFXStateStorage (){return Storage;}
	HFX_INLINE operator const HFXStateStorage ()const{return Storage;}
 
	// at operator to get reference of storage.
	HFX_INLINE HFXStateStorage &operator *(){return Storage;}; 
	HFX_INLINE const HFXStateStorage &operator *()const{return Storage;}; 
	 
	// bool operator, to see if there are any flags set.
	HFX_INLINE bool operator()(int bit){return (Storage & bit)!=0;}; 
 
	// -> operator to get boolean access flags quickly.
	HFX_INLINE HFXStateFlagGroup *operator ->(){return &Flags;}; 
	HFX_INLINE const HFXStateFlagGroup *operator ->()const{return &Flags;}; 
	 
	HFX_INLINE HFXStateStorage *operator &(){return &Storage;}; 
	HFX_INLINE const HFXStateStorage *operator &()const{return &Storage;}; 
 
	HFX_INLINE HFXStateStorage &operator =(HFXStateTransfer state){Storage = state; return Storage;}
	HFX_INLINE HFXStateStorage &operator |=(HFXStateTransfer state){Storage |= state; return Storage;}
	HFX_INLINE HFXStateStorage &operator &=(HFXStateTransfer state){Storage &= state; return Storage;}
	HFX_INLINE HFXStateStorage &operator ^=(HFXStateTransfer state){Storage |= state; return Storage;}
	HFX_INLINE HFXStateStorage operator ~()const{return ~Storage;}
	HFX_INLINE HFXStateStorage operator |(HFXStateTransfer state){return (Storage|state);}
	HFX_INLINE HFXStateStorage operator &(HFXStateTransfer state){return (Storage&state);}
	HFX_INLINE HFXStateStorage operator ^(HFXStateTransfer state){return (Storage^state);}
	HFX_INLINE bool operator ==(HFXStateTransfer state){return (Storage==state);}
	HFX_INLINE bool operator !=(HFXStateTransfer state){return (Storage!=state);}
	HFX_INLINE bool operator !(){return (Storage==0);}
	HFX_INLINE operator bool(){return (Storage!=0);}
	HFX_INLINE HFXStateFlags *UtilPointer(){return this;}; 
	HFX_INLINE const HFXStateFlags *UtilPointer()const{return this;}; 
	HFX_INLINE HFXStateFlags &Util(){return *this;}; 
	HFX_INLINE const HFXStateFlags &Util()const{return *this;}; 
}; 
 
enum HFXNeeds
{
	//effect has a application thread time sync
	HFXNEED_SYNC				=(1 << 0), 
	//effect has a servo thread time update
	HFXNEED_PROCESS				=(1 << 1), 
	//effect takes parameters
	HFXNEED_SET					=(1 << 2), 
	//effect needs stack access
	HFXNEED_STACK				=(1 << 3), 
	//device slots. if you need a device you need a stack.
	HFXNEED_DEVICE1				=(1 << 4), 
	HFXNEED_DEVICE2				=(1 << 5), 
	HFXNEED_DEVICE3				=(1 << 6), 
	HFXNEED_DEVICE4				=(1 << 7), 
	HFXNEED_DEVICE5				=(1 << 8), 
	HFXNEED_DEVICE6				=(1 << 9), 
	HFXNEED_DEVICE7				=(1 << 10), 
	HFXNEED_DEVICE8				=(1 << 11), 
	//ability to create/destroy sub effects
	HFXNEED_MANAGE				=(1 << 12), 
	//effect needs to know how long its been running.
	HFXNEED_RUNTIME				=(1 << 13), 
	//effect needs to know how long its been since the last time its processed a function.
	HFXNEED_FRAMETIME			=(1 << 14), 
	//effect needs a fixed time sent to its framtime
	HFXNEED_FIXEDTIME			=(1 << 15), 
	//effect has a init function
	HFXNEED_INSTANCE			=(1 << 16), 
	//effect needs owning stack's parent access
	HFXNEED_PARENT				=(1 << 17), 
	//effect is self deleting
	HFXNEED_REMOVE				=(1 << 18), 
	//effect does not give handles. these effects need to be self deleting
	HFXNEED_ENCAPSULATED		=(1 << 19), 
 
	HFXNEED_EXIT				=(1 << 20), 
 
	//state change inform flags
	HFXNEED_STATE_INFORM		=(1 << 21), 
	HFXNEED_RUNNING_INFORM		=(1 << 22), 
	HFXNEED_PAUSE_INFORM		=(1 << 23), 
	HFXNEED_HAULT_INFORM		=(1 << 24), 
	HFXNEED_MUTE_INFORM			=(1 << 25), 
	HFXNEED_EXITING_INFORM		=(1 << 26), 
 
	// USE THE BELOW FLAGS TO DECLARE FEATURES TO A EFFECT CLASS WHEN REGISTERING
	HFXNEED_DECL_SYNC			=(HFXNEED_SYNC), 
	HFXNEED_DECL_PROCESS		=(HFXNEED_PROCESS), 
	HFXNEED_DECL_STACK			=(HFXNEED_STACK), 
	HFXNEED_DECL_DEVICE1		=(HFXNEED_DEVICE1|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_DEVICE2		=(HFXNEED_DEVICE2|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_DEVICE3		=(HFXNEED_DEVICE3|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_DEVICE4		=(HFXNEED_DEVICE4|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_DEVICE5		=(HFXNEED_DEVICE5|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_DEVICE6		=(HFXNEED_DEVICE6|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_DEVICE7		=(HFXNEED_DEVICE7|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_DEVICE8		=(HFXNEED_DEVICE8|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_RUNTIME		=(HFXNEED_RUNTIME), 
	HFXNEED_DECL_FRAMETIME		=(HFXNEED_FRAMETIME), 
	// there is no decl for HFXNEED_FIXEDTIME as it is pointless without
	// a runtime or frametime decl.
	HFXNEED_DECL_FIXEDFRAME		=(HFXNEED_FRAMETIME|HFXNEED_FIXEDTIME), 
	HFXNEED_DECL_FIXEDRUNTIME	=(HFXNEED_DECL_RUNTIME|HFXNEED_FIXEDTIME), 
	HFXNEED_DECL_MANAGE			=(HFXNEED_DECL_FRAMETIME|HFXNEED_DECL_STACK), 
	HFXNEED_DECL_REMOVE			=(HFXNEED_REMOVE), 
	HFXNEED_DECL_ENCAPSULATED	=(HFXNEED_ENCAPSULATED|HFXNEED_DECL_REMOVE), 
	HFXNEED_DECL_PARENT			=(HFXNEED_PARENT), 
	HFXNEED_DECL_INSTANCE		=(HFXNEED_INSTANCE), 
	HFXNEED_DECL_SET			=(HFXNEED_SET), 
	// there is no HFXNEED_STATE_INFORM declare as it would be pointless without a
	// declaration of specific informs
	HFXNEED_DECL_RUNNING_INFORM	=(HFXNEED_RUNNING_INFORM|HFXNEED_STATE_INFORM), 
	HFXNEED_DECL_PAUSE_INFORM	=(HFXNEED_PAUSE_INFORM|HFXNEED_STATE_INFORM), 
	HFXNEED_DECL_MUTE_INFORM	=(HFXNEED_MUTE_INFORM|HFXNEED_STATE_INFORM), 
	HFXNEED_DECL_EXITING_INFORM	=(HFXNEED_EXITING_INFORM|HFXNEED_STATE_INFORM), 
	HFXNEED_DECL_HAULT_INFORM	=(HFXNEED_HAULT_INFORM|HFXNEED_STATE_INFORM), 
	// only use this if you will actually be using all informs!
	HFXNEED_DECL_TOTAL_INFORM	=(	HFXNEED_RUNNING_INFORM|HFXNEED_PAUSE_INFORM|
									HFXNEED_MUTE_INFORM|HFXNEED_EXITING_INFORM|
									HFXNEED_STATE_INFORM), 
	// INFORMATION FLAGS
	HFXNEED_INFO_DEVICE			=(	HFXNEED_DEVICE1|HFXNEED_DEVICE2|
									HFXNEED_DEVICE3|HFXNEED_DEVICE4|
									HFXNEED_DEVICE5|HFXNEED_DEVICE6|
									HFXNEED_DEVICE7|HFXNEED_DEVICE8), 
}; 
 
#define HFXNEED_UTIL_COUNT_DEVICES(flags) \
	( ( ( (flags) & HFXNEED_INFO_DEVICE ) != 0) ? ( \
		( ( ( (flags) & HFXNEED_DEVICE1 ) != 0) ? 1 : 0 ) + \
		( ( ( (flags) & HFXNEED_DEVICE2 ) != 0) ? 1 : 0 ) + \
		( ( ( (flags) & HFXNEED_DEVICE3 ) != 0) ? 1 : 0 ) + \
		( ( ( (flags) & HFXNEED_DEVICE4 ) != 0) ? 1 : 0 ) + \
		( ( ( (flags) & HFXNEED_DEVICE5 ) != 0) ? 1 : 0 ) + \
		( ( ( (flags) & HFXNEED_DEVICE6 ) != 0) ? 1 : 0 ) + \
		( ( ( (flags) & HFXNEED_DEVICE7 ) != 0) ? 1 : 0 ) + \
		( ( ( (flags) & HFXNEED_DEVICE8 ) != 0) ? 1 : 0 ) ) \
		: 0 ) 
 
typedef unsigned __int32 HFXNEED; 
 
#define HFX_XCHANGE 16
#define HFX_YCHANGE 17
#define HFX_ZCHANGE 18
 
enum HFXResult
{
	HFXRESULT_ERROR			=-2,	 
	HFXRESULT_FINISHED		=-1,	 
	HFXRESULT_CONTINUE		=0,	 
	// x axis was set		 
	HFXRESULT_XCHANGED		=(1 << HFX_XCHANGE),	 
	// y axis was set		 
	HFXRESULT_YCHANGED		=(1 << HFX_YCHANGE),	 
	// z axis was set		 
	HFXRESULT_ZCHANGED		=(1 << HFX_ZCHANGE),	 
	// x and y axis was set	 
	HFXRESULT_XYCHANGED		=(HFXRESULT_XCHANGED|HFXRESULT_YCHANGED),	 
	// x and z axis was set	 
	HFXRESULT_XZCHANGED		=(HFXRESULT_XCHANGED|HFXRESULT_ZCHANGED),	 
	// y and z axis was set	 
	HFXRESULT_YZCHANGED		=(HFXRESULT_YCHANGED|HFXRESULT_ZCHANGED),	 
	// x and y axis was set	 
	HFXRESULT_YXCHANGED		=HFXRESULT_XYCHANGED,	 
	// x and z axis was set	 
	HFXRESULT_ZXCHANGED		=HFXRESULT_XZCHANGED,	 
	// y and z axis was set	 
	HFXRESULT_ZYCHANGED		=HFXRESULT_YZCHANGED,	 
	// x, y and z axis  set	 
	HFXRESULT_XYZCHANGED	=(HFXRESULT_XCHANGED|HFXRESULT_YCHANGED|HFXRESULT_ZCHANGED),	 
	HFXRESULT_CHANGED		=HFXRESULT_XYZCHANGED,	 
}; 
 
typedef int HFXRESULT; 
 
 
class HFX_PURE_INTERFACE IHapticEffect
{
public: 
	// return false if you decide the processor given to you is not sufficient
	// or any other reason the effect should not be made. 
	// !called one time only. before any other funciton calls.
	// IF YOU WANT THIS TO BE CALLED YOU MUST REGISTER YOUR EFFECT WITH HFXNEED_DECL_INSTANCE
	virtual bool Initialize(IHFXProcessor &processor)=0; 
	// called by the game thread and blocks the haptics thread so the game and haptics loop are safe inside.
	// IF YOU WANT THIS TO BE CALLED YOU MUST REGISTER YOUR EFFECT WITH HFXNEED_DECL_SYNC
	virtual HFXRESULT SyncOp(IHFXProcessor &processor)=0; 
	//called at haptic rate. should set the output parameter to the target output force.
	// calculation should optimized and precise in here.
	// IF YOU WANT THIS TO BE CALLED YOU MUST REGISTER YOUR EFFECT WITH HFXNEED_DECL_PROCESS
	virtual HFXRESULT Update(IHFXProcessor &processor)=0; 
	//return true if parameters sent to you are sufficient.
	virtual bool Set(IHFXProcessor &processor, IHFXParamGroup *parameter)=0; 
	//notification of state change. 
	// WILL ONLY BE CALLED IF YOU DECLARE YOUR EFFECT REGISTER WITH A _INFORM decl and will ONLY be called with those.
	//   note: state will be only one bit. for every bit changed on sync this function will be called.
	virtual void OnStateChange(IHFXProcessor &processor, HFXSTATE state, bool flagged)=0; 
}; 
typedef IHapticEffect IHFXEffect; 
 
typedef void (*hfxFilterFunction)(double outvect[3]); 
typedef void (*HFXCreate_t)(IHFXEffect*&ptr); 
typedef void (*HFXDestroy_t)(IHFXEffect*&ptr); 
 
template<typename T> 
void HFXDefaultAllocateEffect(IHFXEffect *&ptr){ptr = new T;}; 
 
template<typename T> 
void HFXDefaultDeallocateEffect(IHFXEffect *&ptr){if(!ptr)return; delete ((T*)ptr); ptr=0;}; 
 
class IHapticsSystem; 
typedef IHapticsSystem IHFXSystem; 
class IDevice; 
typedef IDevice IHFXDevice; 
class IStack; 
typedef IStack IHFXStack; 
 
// T == effect class
template<typename T>  
inline HFXEffectID HFXDefaultRegisterEffect(IHFXSystem &hfxSystem, const char *tag, HFXNEED needs, IHFXParamGroup *defaults, HFXCreate_t specialCreate = HFXDefaultAllocateEffect<T>, HFXDestroy_t specialDestroy = HFXDefaultDeallocateEffect<T> )  
{
	hfxSystem.LogMessage((const int)1,"EFFECT REGISTERING! %s Size = %i \n", tag, sizeof(T));  
	return hfxSystem.RegisterEffectClass(  
		tag,   
		specialCreate,   
		specialDestroy,  
		needs,   
		defaults);  
};  
  
// T == effect class
// P == parametergroup class
template<typename T, typename P>  
inline HFXEffectID HFXDefaultRegisterEffect(IHFXSystem &hfxSystem, const char *tag, HFXNEED needs, HFXCreate_t specialCreate = 0, HFXDestroy_t specialDestroy = 0)  
{
	P *pGroup = new P;  
	HFXEffectID retval=0;  
	if(pGroup->CopyDefaults(pGroup))  
	{
		retval = HFXDefaultRegisterEffect<T>(hfxSystem, tag, needs, pGroup, specialCreate, specialDestroy);  
	}
	delete pGroup;  
	return retval;  
};  
 
#endif