mirror of
https://github.com/nillerusr/source-engine.git
synced 2026-08-07 17:29:36 +00:00
1
This commit is contained in:
FluorescentCIAAfricanAmerican
@@ -0,0 +1,59 @@
|
||||
#ifndef NOVINT_HFX_CONFIG_H
|
||||
#define NOVINT_HFX_CONFIG_H
|
||||
// COMPILER VERSION
|
||||
#if _MSC_VER
|
||||
#if _MSC_VER >= 1500
|
||||
#define HFX_MSVC9
|
||||
#define HFX_MSVC 9 // Microsoft Visual C++ 2008
|
||||
|
||||
#elif _MSC_VER >= 1400
|
||||
#define HFX_MSVC8
|
||||
#define HFX_MSVC 8 // Microsoft Visual C++ 2005
|
||||
|
||||
#elif _MSC_VER >= 1300
|
||||
#define HFX_MSVC7
|
||||
#define HFX_MSVC 7 // Microsoft Visual C++ 2003
|
||||
|
||||
#else
|
||||
#define HFX_MSVC6
|
||||
#define HFX_MSVC 6 // Microsoft Visual C++ 6
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//HFX_PURE_INTERFACE
|
||||
#if HFX_MSVC >= 7
|
||||
#define HFX_PURE_INTERFACE __declspec(novtable)
|
||||
#else
|
||||
#define HFX_PURE_INTERFACE
|
||||
#endif
|
||||
|
||||
//HFX_ABSTRACT
|
||||
#if HFX_MSVC >= 8
|
||||
#define HFX_ABSTRACT abstract
|
||||
#else
|
||||
#define HFX_ABSTRACT
|
||||
#endif
|
||||
|
||||
#define HFX_EXPLICIT explicit
|
||||
|
||||
//HFX_INLINE
|
||||
#if _MSC_VER>=1000
|
||||
#define HFX_INLINE __forceinline
|
||||
|
||||
#else
|
||||
#define HFX_INLINE inline
|
||||
#endif
|
||||
|
||||
//HFX_ALIGN
|
||||
#if HFX_MSVC > 6
|
||||
#define HFX_ALIGN(nBits) __declspec(align(nBits))
|
||||
#else
|
||||
#define HFX_ALIGN(nBits)
|
||||
#endif
|
||||
|
||||
#define HFX_MEMSET memset
|
||||
#define HFX_MEMCPY memcpy
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,707 @@
|
||||
#ifndef I_NOVINT_HFX
|
||||
#define I_NOVINT_HFX
|
||||
|
||||
#define HFX_VERSION_MAJOR 0
|
||||
#define HFX_VERSION_MAJOR_SZ "0"
|
||||
#define HFX_VERSION_MINOR 5
|
||||
#define HFX_VERSION_MINOR_SZ "5"
|
||||
#define HFX_VERSION_FLOAT 0.5
|
||||
#include "util/HFXInterfaceHelper.h"
|
||||
|
||||
//( NovintHFX )
|
||||
#include "HFXConfig.h"
|
||||
//( HFXClasses )
|
||||
namespace std{
|
||||
template<class _Ty>
|
||||
class allocator;
|
||||
template <class _Ty,
|
||||
class _Ax > class vector;
|
||||
};
|
||||
|
||||
#if _MSC_VER < 1400
|
||||
#define VECTOR_TYPE(type) std::vector<type>
|
||||
#endif
|
||||
|
||||
#if _MSC_VER >= 1400
|
||||
#define VECTOR_TYPE(type) ::std::vector<type, ::std::allocator<type> >
|
||||
#endif
|
||||
|
||||
#pragma warning( disable : 4251 )
|
||||
class EffectTag;
|
||||
|
||||
//ensure these are not int he NovintHFX namespace.
|
||||
#include "IHFXParam.h"
|
||||
#include "IHFXEffect.h"
|
||||
|
||||
typedef int _declspec(dllimport) (*LinkHFX_Fn)( const char * password, const char *cmdline, void **effects, void **system );
|
||||
//temporarily disable warning regarding to data classes
|
||||
// needing external classes
|
||||
#pragma warning(disable:4661)
|
||||
//forward decl.
|
||||
class IDevice;
|
||||
class IStack;
|
||||
struct IBaseEffectParams;
|
||||
class IBaseEffect;
|
||||
//( HapticsMath )
|
||||
#include "Types/hfxVec3.h"
|
||||
//( HapticsSystem )
|
||||
struct IHapticEffectParamGroup;
|
||||
typedef IHapticEffectParamGroup IHFXParamGroup;
|
||||
typedef int DeviceIndex;
|
||||
typedef unsigned long hfxPreciseTime;
|
||||
typedef bool (*EnableMouseFn)( void );
|
||||
|
||||
enum eMouseMove
|
||||
{
|
||||
eHFXMM_Delta=0,
|
||||
eHFXMM_Absolute=0,
|
||||
};
|
||||
|
||||
enum eMouseButton
|
||||
{
|
||||
eHFXMM_1232=0,//1=left 2=right 3=middle 4=right
|
||||
eHFXMM_1111,//1=left 2=left 3=left 4=left
|
||||
eHFXMM_1342,//1=left 2=middle 3=4th 4=right
|
||||
eHFXMM_None,
|
||||
};
|
||||
enum eMouseMethod
|
||||
{
|
||||
eHFXMouseMeth_OSInput=0,
|
||||
eHFXMouseMeth_fMouse,
|
||||
eHFXMouseMeth_useCallback,
|
||||
eHFXMouseMeth_smartDelta,
|
||||
eHFXMouseMeth_delta,
|
||||
eHFXMouseMeth_COUNT,
|
||||
};
|
||||
enum eMouseClick
|
||||
{
|
||||
eHFXMC_Left=0,
|
||||
eHFXMC_Right,
|
||||
eHFXMC_Middle,
|
||||
eHFXMC_Fourth,
|
||||
eHFXMC_COUNT,
|
||||
};
|
||||
typedef bool (*MouseEmulationFn)( const double &devicex_pos,
|
||||
const double &devicey_pos,
|
||||
const double &devicez_pos,
|
||||
const double &devicex_delta,
|
||||
const double &devicey_delta,
|
||||
const double &devicez_delta,
|
||||
const int &buttons_down,
|
||||
const int &buttons_pressed,
|
||||
const int &buttons_released,
|
||||
bool moved,
|
||||
/* adjust if you would liek to send a mouse button */
|
||||
bool buttonsDown[eHFXMC_COUNT]
|
||||
);
|
||||
|
||||
struct ApplicationData
|
||||
{
|
||||
};
|
||||
typedef void (*RollCallIndexSetCallBack)(IDevice *pDevice, const int devices_left);
|
||||
class HFX_PURE_INTERFACE IHapticsSystem
|
||||
{
|
||||
public:
|
||||
|
||||
// call this method prior to shutting down the game.
|
||||
virtual void ShutDown(bool hard=false) =0;
|
||||
// THIS FUNCTION MUST BE CALLED BY YOUR APPLICATION AND RETURN TRUE PRIOR TO CREATING A DEVICE!
|
||||
// window = the HWND of the program.
|
||||
// returns weather or not the applicationdata was sufficent.
|
||||
virtual bool AttachApplication(ApplicationData &app) =0;
|
||||
virtual bool AttachApplicationByProcessName(ApplicationData &app, const char *szProcessName) =0;
|
||||
|
||||
// If you want to use more than 1 device set this before. NOTE: for multiple devices you must use device lock
|
||||
//HFX_VIRTUAL bool SetOptionalDeviceCount( unsigned int nDevices );
|
||||
|
||||
// Use this function to create a device. (note: when making multiple devices they must be connected in numerical order.)
|
||||
virtual bool RunDevice(IDevice **ppDevice, const char *deviceName=0, const char *configDir=0) =0;
|
||||
|
||||
// When using multiple devices you _MUST_ lock devices after device connection attempts are made.
|
||||
virtual void LockDevices() =0;
|
||||
|
||||
// When using mutliple devices you _MUST_ unlock devices once they are locked to connect more devices and then lock again afterwards.
|
||||
virtual void UnlockDevices() =0;
|
||||
|
||||
// Note: this will return the max number of devices specified in the constructor of HapticsSystem.
|
||||
virtual unsigned int GetTargetDeviceCount() const =0;
|
||||
|
||||
// connects multiple devices at once. returns number of devices connected.
|
||||
// if targetNumber==-1 then all connected devices will be ran.
|
||||
virtual int RunMultipleDevices(const int targetNumber=-1) =0;
|
||||
|
||||
// returns true if device was stopped.
|
||||
virtual bool StopRunningDevice(IDevice **ppDevice) =0;
|
||||
|
||||
// returns true if all instances were stopped.
|
||||
virtual bool StopAllRunningDevices() =0;
|
||||
|
||||
//this will ask the user to press a button on each device. the order in which they
|
||||
// press a button on each connected device will order their device id from zero to the number
|
||||
// of falcons the user has minus one.
|
||||
// note: without roll call devices are ordered by their serial number.
|
||||
// returns false if only one falcon is connected.
|
||||
virtual bool RollCallDevices(RollCallIndexSetCallBack CallBackFn=0,bool bCreateThread=false) =0;
|
||||
|
||||
// will return true untill roll call is over.
|
||||
virtual bool IsInRollCall() const =0;
|
||||
|
||||
// updates roll call data. only call this if your in a roll call and the roll call was not started
|
||||
// with bCreateThread set to true.
|
||||
// returns true if still in roll call.
|
||||
virtual bool RollCallUpdate() =0;
|
||||
|
||||
// cancles roll call in progress. if ApplyMadeChanges is true the devices who responded
|
||||
// to the roll call will be set in and the unset will be moved to the end of the index list.
|
||||
virtual bool StopRollCall(bool ApplyMadeChanges=false) =0;
|
||||
|
||||
//only call this ONCE per game input tick.
|
||||
// returns number of devices updated.
|
||||
virtual int InputUpdate();
|
||||
|
||||
//void SetMouseMode(HWND window,eHFXMouseMove MoveMode=eHFXMM_Delta,eHFXMouseButton ButtonMode=eHFXMM_1232);
|
||||
virtual void SetMouseMode(eMouseMove MoveMode=eHFXMM_Delta,eMouseButton ButtonMode=eHFXMM_1232) =0;
|
||||
virtual void StartMouse(IDevice *pDev) =0;
|
||||
virtual void StartMouse(const DeviceIndex device) =0;
|
||||
virtual void StartMouse() =0;
|
||||
virtual void MouseUpdate() =0;
|
||||
virtual void StopMouse() =0;
|
||||
|
||||
// returns if we are in cursor emulation. If pDevice is null it will return weather any device is in mouse emulation.
|
||||
virtual bool IsMouseMode(const IDevice *pDevice=0) =0;
|
||||
|
||||
//returns true if forces are allowed.
|
||||
virtual bool ForcesAllowed() =0;
|
||||
|
||||
//returns true if input is allowed.
|
||||
virtual bool InputAllowed() =0;
|
||||
|
||||
//returns true if forces are enabled.
|
||||
// Note: this could be true and forces may not be allowed.
|
||||
// MouseMode RollCall window focus and possibly other things will not allow forces.
|
||||
virtual bool ForcesEnabled() =0;
|
||||
|
||||
//HFX_VIRTUAL void DisableForces() HFX_PURE;
|
||||
//HFX_VIRTUAL void EnableForces() HFX_PURE;
|
||||
//returns device of index nDevice
|
||||
virtual IDevice *GetRunningDeviceByIndex(const DeviceIndex nDevice) const =0;
|
||||
|
||||
//returns device on hardware index.
|
||||
virtual IDevice *GetRunningDeviceByHardwareIndex(const int nSerialOrder) const =0;
|
||||
|
||||
//returns number of running devices.
|
||||
virtual int RunningDeviceCount() const =0;
|
||||
|
||||
//returns number of devices connected to the users computer.
|
||||
virtual int ConnectedDeviceCount() const =0;
|
||||
|
||||
// this will re count available devices.
|
||||
// use ConnectedDeviceCount() to get the count.
|
||||
virtual void RecountConnectedDevices() =0;
|
||||
|
||||
virtual bool AllocateEffectParameter(IHFXParamGroup *&pIEffectParam, HFXEffectID associatedClass, const char *copyCachedSettings=0, const char *storageName=0) =0;
|
||||
HFX_INLINE bool AllocateEffectParameter(IHFXParamGroup *&pIEffectParam, const char *copyCachedSettings=(const char*)0, const char *storageName=0 ){return AllocateEffectParameter(pIEffectParam, 0, copyCachedSettings, storageName);}
|
||||
virtual bool DeallocateEffectParameter(IHFXParamGroup *&ppIEffectParam) =0;
|
||||
|
||||
virtual unsigned int GetCachedParameterCount() const =0;
|
||||
virtual IHFXParamGroup *GetCachedParameter(const char *name) =0;
|
||||
virtual IHFXParamGroup *GetCachedParameter(const unsigned int name) =0;
|
||||
virtual const char *GetCachedParameterName(const unsigned int id) const =0;
|
||||
|
||||
// Note: any format ( besides Bitfile ) where it cannot find the file specified will try to
|
||||
// load a encoded bitfile if it does not exist. A bit file will be generated when you load any
|
||||
// format. When release time comes around just delete the iniFile and include the bitfile output
|
||||
|
||||
// each format has a way to turn this functionality off. if you
|
||||
virtual bool CacheEffectParametersINI( const char *iniFile ) =0;
|
||||
|
||||
virtual bool CacheEffectParametersBitfile( const char *bitFile ) =0;
|
||||
// will add .nvnt extension
|
||||
virtual bool SaveCache( const char *file ) =0;
|
||||
|
||||
//HFX_VIRTUAL bool LoadHFXModule( const char *moduleName, const char *modulePassword=0 ) HFX_PURE;
|
||||
virtual hfxPreciseTime GetBaseTime() const =0;
|
||||
virtual hfxPreciseTime GetRunTime() const =0;
|
||||
virtual double GetRunTimeSeconds() const =0;
|
||||
virtual double GetBaseTimeSeconds() const =0;
|
||||
|
||||
virtual bool CreateNewEffectStack(const char *uniqueName, IStack**ppStack, unsigned int inputDevices=0) =0;
|
||||
virtual bool DeleteEffectStack(IStack**ppStack) =0;
|
||||
virtual IStack* FindEffectStack(const char *name) =0;
|
||||
|
||||
//command support
|
||||
//HFX_VIRTUAL int RunCommand( const char *cmd ) HFX_PURE;
|
||||
|
||||
//HFX_VIRTUAL bool InitFromXML(ApplicationData &appdata,unsigned int &devices, const char *xmlLoc) HFX_PURE;
|
||||
|
||||
virtual int LogMessage(const int type, const char *fmt, ...);
|
||||
virtual int LogMessage(const char *fmt, ...);
|
||||
|
||||
virtual bool SetMouseEmulation( eMouseMethod method ) =0;
|
||||
virtual bool SetMouseEmulationFunction( MouseEmulationFn method_function ) =0;
|
||||
#ifndef HFX_INTERNAL
|
||||
inline bool SetMouseEmulation( MouseEmulationFn method_function ){if(!method_function) return false; return ( SetMouseEmulation(eHFXMouseMeth_useCallback) && SetMouseEmulationFunction(method_function)); }
|
||||
#endif
|
||||
virtual bool ScaleDeviceCoordsForCursor( double &x, double &y, double width=-1, double height=-1, double offsetx=-1, double offsety=-1 ) =0;
|
||||
// try and put device to sleep. if null all devices will try to sleep. devices will sleep untill touched.
|
||||
virtual void AttemptSlumber(IDevice *device=0) =0;
|
||||
|
||||
virtual void ActivateDynamicWindowHandler(const char *windowClassName, const char *windowText, unsigned int msHeartInterval=70) =0;
|
||||
virtual void DeactivateDynamicWindowHandler() =0;
|
||||
virtual bool IsDynamicWindowHandlerRunning() const =0;
|
||||
|
||||
virtual HFXEffectID RegisterEffectClass(const char *tag, HFXCreate_t alloc, HFXDestroy_t dealloc, HFXNEED needs, IHFXParamGroup *defaults=0) =0;
|
||||
#define HFX_NON_ELEMENT 0xFFFFF0
|
||||
virtual bool SetParameterGroupVar(IHFXParamGroup ¶ms, HFXParamID var, const char *string, unsigned int element=HFX_NON_ELEMENT) =0;
|
||||
virtual bool SetParameterGroupVar(IHFXParamGroup ¶ms, const char *varString, const char *string, unsigned int element=HFX_NON_ELEMENT) =0;
|
||||
virtual HFXEffectID LookupEffectIDByName(const char *name) const =0;
|
||||
virtual const char *LookupEffectNameByID(HFXEffectID id) const =0;
|
||||
|
||||
// only call if explicit stack syncs are enabled
|
||||
virtual void SyncEffectStacks() =0;
|
||||
|
||||
virtual HFXParamID EnumerateEffectParameters( HFXEffectID id, HFXParamID LastParamID ) =0;
|
||||
virtual bool CacheEffectParameterGroupCopy(const char *cachename, IHFXParamGroup *params) =0;
|
||||
virtual bool SaveEffectParameterCache(const char *filename, const char *type = "ini") =0;
|
||||
virtual void DoReport() =0;
|
||||
};
|
||||
|
||||
//( HapticsDevice )
|
||||
//HFX BUTTON DEFINES : Based on HDL Button Defines.
|
||||
#define HFX_BUTTON_1 0x00000001 /**< Mask for button 1 */
|
||||
#define HFX_BUTTON_2 0x00000002 /**< Mask for button 2 */
|
||||
#define HFX_BUTTON_3 0x00000004 /**< Mask for button 3 */
|
||||
#define HFX_BUTTON_4 0x00000008 /**< Mask for button 4 */
|
||||
#define HFX_BUTTON_ANY 0xffffffff /**< Mask for any button */
|
||||
|
||||
//Internal class.
|
||||
struct HFX_PURE_INTERFACE IDeviceData
|
||||
{
|
||||
};
|
||||
|
||||
namespace NovintHFX{
|
||||
class Device;
|
||||
class Stack;
|
||||
namespace Effects{
|
||||
struct command_info;
|
||||
int ProcessCommand( IBaseEffect *pEffect, const char *argv[], const unsigned int argc );
|
||||
}
|
||||
};
|
||||
// This function callback type will be used with SetServoLoopCallbackFunction.
|
||||
// The main difference between hdlServoOp and this is that you get the device.
|
||||
typedef int (*OldServoLoopFn) (void *pParam, class IDevice *pDevice, double outforces[3]);
|
||||
class HFX_PURE_INTERFACE IDevice
|
||||
{
|
||||
public:
|
||||
//Is this device able to output forces?
|
||||
virtual bool AcceptingForces() const =0;
|
||||
|
||||
//The device is connected.
|
||||
virtual bool IsConnected() const =0;
|
||||
|
||||
//Sets pos to the tool Position.
|
||||
virtual void GetToolPosition(double pos[3]) const =0;
|
||||
virtual void GetToolPositionWorkspace(double pos[3]) const =0;
|
||||
virtual void GetButtonData(int *down=0, int *pressed=0, int *released=0) const =0;
|
||||
virtual void GetCurrentForce(double force[3]) const =0;
|
||||
virtual bool IsButtonDown( int nButton ) const =0;
|
||||
virtual IStack *GetEffectStack() =0;
|
||||
virtual const DeviceIndex GetIndex() const =0;
|
||||
virtual int GetHardwareIndex() const =0;
|
||||
virtual void InputUpdate() =0;
|
||||
|
||||
virtual bool ConnectStack( IStack *stack ) =0;
|
||||
virtual bool DisconnectStack( IStack *stack ) =0;
|
||||
|
||||
// This function is here for quick integration into games which already have a few custom
|
||||
// effects of their own. Taking the old ServoOp function and adding in pDevice
|
||||
virtual void SetServoLoopCallbackFunction( OldServoLoopFn old_fn, void *pParam ) =0;
|
||||
|
||||
// you should never call this unless your in a callback running on servo.
|
||||
virtual void _GetServoData(double toolpos[3], int &buttons) =0;
|
||||
|
||||
virtual __int64 GetSerialNumber() const =0;
|
||||
|
||||
virtual BoundingBox3 GetWorkspace() const =0;
|
||||
|
||||
virtual void SetEngineData(void *data) =0;
|
||||
virtual void *GetEngineData() const =0;
|
||||
|
||||
virtual bool HasRested( unsigned int msDur=1 ) const =0;
|
||||
virtual bool IsSleeping(bool justForces=false) const =0;
|
||||
virtual bool TriggerFade(unsigned int msMuteTime, unsigned int msDuration, bool forceOverride=false) =0;
|
||||
virtual void ForceSlumber() =0;
|
||||
virtual void SetForceScale(const double &scale) =0;
|
||||
virtual double GetForceScale() const =0;
|
||||
};
|
||||
|
||||
//( HapticsStack )
|
||||
class Processor;
|
||||
//EFFECT STACK
|
||||
//note one stack per device handle only.
|
||||
class HFX_PURE_INTERFACE IStack
|
||||
{
|
||||
public:
|
||||
|
||||
// Returns true if effect was created.
|
||||
// --
|
||||
// NOTE: NOT ALL EFFECTS ( SUCH AS SELF DELETING )
|
||||
// WILL ALLOW YOU TO HAVE A HANDLE TO IT.
|
||||
// CHECKING POINTER VALIDITY OF THE HANDLE IN THE
|
||||
// CREATE NEW EFFECT WILL ONLY LET YOU KNOW IF
|
||||
// ANYTHING WAS SET TO IT, NOT NECCISARILLY IF
|
||||
// THE EFFECT WAS CREATED.
|
||||
// --
|
||||
virtual bool CreateCachedEffect(IHFXEffect *&pHandle, const char *entry, const char *instancename=0 );
|
||||
|
||||
template<typename T>
|
||||
HFX_INLINE bool CreateCachedEffect(T *&pTypedHandle, const char *entry, const char *instanceName=0)
|
||||
{
|
||||
return CreateCachedEffect((IHFXEffect*&)pTypedHandle, entry, instanceName);
|
||||
}
|
||||
HFX_INLINE bool CreateCachedEffect(const char *entry){ return CreateCachedEffect(hfxNoHandle, entry); }
|
||||
|
||||
virtual bool CreateNewEffect(IHFXEffect *&ppHandle, HFXEffectID effectName, IHFXParamGroup *params, const char *instanceName=0);
|
||||
|
||||
template<typename T>
|
||||
HFX_INLINE bool CreateNewEffect(T *&pTypedHandle, HFXEffectID effectName, IHFXParamGroup *params, const char *instanceName=0)
|
||||
{
|
||||
return CreateNewEffect((IHFXEffect*&)pTypedHandle, effectName, params, instanceName);
|
||||
}
|
||||
|
||||
HFX_INLINE bool CreateNewEffect(HFXEffectID effectName, IHFXParamGroup *params){ return CreateNewEffect(hfxNoHandle, effectName, params, 0); };
|
||||
// Returns NULL if there was no effect using that name.
|
||||
// --
|
||||
// NOTE: YOU SHOULD ONLY HAVE ONE HANDLE OF A EFFECT
|
||||
// IN AS A MEMBER VARIABLE ( NON LOCAL ). OTHERWISE
|
||||
// YOU RISK INVALID POINTERS IF YOU DELETE THE EFFECT.
|
||||
// WITH A SECOND REFERENCE.
|
||||
virtual IHFXEffect *FindRunningEffect(const char *instanceName) const =0;
|
||||
// Returns true if effect was deleted
|
||||
// --
|
||||
// NOTE: THIS IS ONLY FOR EFFECTS WHICH NEED TO BE
|
||||
// DELETED MANUALLY. MANY EFFECTS WILL DELETE
|
||||
// THEMSELFS AND THOSE EFFECTS YOU SHOULD NOT
|
||||
// EVER RECEIVE HANDLES FOR.
|
||||
// --
|
||||
virtual bool DeleteRunningEffect(IHFXEffect *&effect) =0;
|
||||
|
||||
template<typename T>
|
||||
HFX_INLINE bool DeleteRunningEffect(T *&pTypedEffect)
|
||||
{
|
||||
return DeleteRunningEffect((IHFXEffect*&)pTypedEffect);
|
||||
}
|
||||
|
||||
virtual void GetLastForce(double force[3])const =0;
|
||||
|
||||
virtual void SetDeviceLock(bool state) =0;
|
||||
virtual bool IsDeviceListLocked() const =0;
|
||||
|
||||
// returns true if device was added or is already a member. if slot is -1 it will just enter the device
|
||||
// as the next available slot.
|
||||
virtual bool AddDevice(IDevice*pDevice, int slot=-1) =0;
|
||||
|
||||
// returns the device in slot
|
||||
virtual IDevice *GetDeviceInSlot(unsigned int id=0) const =0;
|
||||
|
||||
virtual void GetCalclatedForces(double force[3]) =0;
|
||||
virtual const char *Name() const =0;
|
||||
|
||||
//command support
|
||||
//HFX_VIRTUAL int RunCommand( const char *cmd ) HFX_PURE;
|
||||
|
||||
virtual void *GetUserData() const =0;
|
||||
virtual void SetUserData(void*data) =0;
|
||||
|
||||
virtual void SetVolume( const double &scale ) =0;
|
||||
virtual double GetVolume() const =0;
|
||||
|
||||
virtual unsigned int GetTargetDeviceCount() const =0;
|
||||
|
||||
virtual void SetEngineData(void *data) =0;
|
||||
virtual void *GetEngineData() const =0;
|
||||
|
||||
virtual void SetEffectUserData(IHFXEffect *pEffect, void *pData) =0;
|
||||
virtual void *GetEffectUserData(IHFXEffect *pEffect) =0;
|
||||
};
|
||||
|
||||
//( HapticsEffect )
|
||||
struct HFX_PURE_INTERFACE IRegister
|
||||
{
|
||||
public:
|
||||
virtual void AllocateEffect(IHFXEffect *&pEffectPtr) =0;
|
||||
virtual void DeallocateEffect(IHFXEffect *&pEffectPtr) =0;
|
||||
virtual void AllocateParameterGroup(IHFXParamGroup *&pEffectPtr) =0;
|
||||
virtual void DeallocateParameterGroup(IHFXParamGroup *&pEffectPtr) =0;
|
||||
virtual const char *GetTagName() const =0;
|
||||
};
|
||||
|
||||
#define HFX_PROCESSOR_PARAM_FORCESCALE 4294967293
|
||||
#define HFX_PROCESSOR_PARAM_TIMESCALE 4294967294
|
||||
|
||||
class HFX_PURE_INTERFACE IProcessor
|
||||
{
|
||||
public:
|
||||
|
||||
// call this to mute and unmute this effect. (note: effect will still be updated, just will not output force.)
|
||||
// note : this setting will not be applied untill the next sync op ( InputUpdate ) called by the application.
|
||||
virtual void SetMuted(bool mute) =0;
|
||||
virtual void SetPaused(bool pause) =0;
|
||||
|
||||
// see if the effect is muted.
|
||||
HFX_INLINE bool IsMuted() const { return ((GetEffectState() & HFXSTATE_MUTE)!=0); }
|
||||
|
||||
// see if the effect is explicitly paused.
|
||||
HFX_INLINE bool IsPaused() const { return ((GetEffectState() & HFXSTATE_PAUSE)!=0); }
|
||||
|
||||
// scale this force (NOTE: THIS IS SEPERATE FROM PARAMETER SCALE!)
|
||||
virtual void SetForceScale( double scale ) =0;
|
||||
virtual double GetForceScale( ) const =0;
|
||||
|
||||
virtual const char *GetEffectTypeName() const =0;
|
||||
|
||||
// override this function to return the number of falcons this
|
||||
// effect requires.
|
||||
HFX_INLINE unsigned int RequiredDeviceCount() const
|
||||
{
|
||||
HFXNEED needs= GetEffectNeeds();
|
||||
return HFXNEED_UTIL_COUNT_DEVICES(needs);
|
||||
}
|
||||
|
||||
// returns true if the effect is running.
|
||||
HFX_INLINE bool IsRunning() const {return ( (GetEffectState() & (HFXSTATE_RUNNING)) != 0 );}
|
||||
|
||||
// if your effect is not self deleting and requires runtime data you should override this to true.
|
||||
HFX_INLINE bool CanBeHandled() const { return (GetEffectNeeds() & HFXNEED_ENCAPSULATED)==0; }
|
||||
|
||||
// this lets the haptic effect stack know you are done with this effect and it is waiting to be deleted.
|
||||
// CANNOT BE OVERRIDDEN ( see OnFlaggedForRemoval() )
|
||||
virtual void FlagForRemoval() =0;
|
||||
|
||||
//Stack functions!
|
||||
friend class NovintHFX::Stack;
|
||||
friend int NovintHFX::Effects::ProcessCommand( IBaseEffect *pEffect, const char *argv[], const unsigned int argc );
|
||||
|
||||
// do not use.
|
||||
//HFX_VIRTUAL bool Stop() HFX_PURE;
|
||||
|
||||
// DO NOT OVERRIDE!
|
||||
HFX_INLINE bool NeedsRemoval() const
|
||||
{ return ( ( GetEffectNeeds() & HFXNEED_REMOVE ) ? ( ( ( GetEffectState() & HFXSTATE_RUNNING ) ) ? false : true ) : false ); }
|
||||
|
||||
// DO NOT OVERRIDE!
|
||||
HFX_INLINE bool WantsSyncOp() const
|
||||
{
|
||||
return (((GetEffectNeeds() & HFXNEED_SYNC)!=0) && ((GetEffectState() & HFXSTATE_WANT_SYNC)!=0));
|
||||
}
|
||||
// DO NOT OVERRIDE!
|
||||
virtual bool WantsUpdate() const {return (((GetEffectNeeds() & HFXNEED_PROCESS)!=0) && ((GetEffectState() & HFXSTATE_WANT_UPDATE)!=0) && ((GetEffectState() & HFXSTATE_RUNNING)!=0));}
|
||||
|
||||
virtual HFXSTATE GetEffectState() const =0;
|
||||
virtual const HFXNEED &GetEffectNeeds() const =0;
|
||||
|
||||
virtual void *_output() const =0;
|
||||
|
||||
virtual const double &Runtime() const =0;
|
||||
virtual const double &Frametime() const =0;
|
||||
|
||||
virtual IStack *GetStack() =0;
|
||||
virtual IHFXSystem *GetSystem() =0;
|
||||
virtual void *GetUserData() =0;
|
||||
virtual void SetUserData(void *userData) =0;
|
||||
HFX_INLINE hfxVec3 &Output() { return *(reinterpret_cast<hfxVec3*>(_output())); }
|
||||
HFX_INLINE const hfxVec3 &Output() const{return *(reinterpret_cast<const hfxVec3*>(_output()));}
|
||||
HFX_INLINE double &operator[](int i){ return (Output().m[i]); };
|
||||
HFX_INLINE const double &operator[](int i)const{ return (Output()[i]); };
|
||||
HFX_INLINE bool IsOutputValid() const { return !IsOutputNaN();}
|
||||
HFX_INLINE bool IsOutputNaN() const { const double *o=Output(); return(o[0]!=o[0]||o[1]!=o[1]||o[2]!=o[2]);}
|
||||
HFX_INLINE hfxVec3 &operator =(const hfxVec3 &vect){hfxVec3 &out = Output(); out = vect; return out;}
|
||||
};
|
||||
typedef IProcessor IHFXProcessor;
|
||||
typedef char HFX_VarType;
|
||||
|
||||
#define HFX_Double 'd'
|
||||
#define HFX_Float 'f'
|
||||
#define HFX_Int 'i'
|
||||
#define HFX_Bool 'b'
|
||||
#define HFX_Other 'o'
|
||||
#define HFX_Pointer 'p'
|
||||
#define HFX_Null 0
|
||||
|
||||
|
||||
#pragma warning( default : 4251 )
|
||||
|
||||
#ifdef HFX_MODULE_LAYER
|
||||
#include HFX_MODULE_LAYER
|
||||
#endif
|
||||
|
||||
#define ConnectNovintHFX YOU_MUST_INCLUDE_WINDOWS_PRIOR_TO_INCLUDING_INovintHFX_h
|
||||
#endif
|
||||
|
||||
// to connect windows.h must be included
|
||||
#if ( !defined(I_NOVINT_HFX_WINDOWS) && ( defined(_INC_WINDOWS) || defined(LoadLibrary) && defined(HMODULE) ) ) && !defined(STATIC_IHFX)
|
||||
#define I_NOVINT_HFX_WINDOWS
|
||||
|
||||
#ifdef ConnectNovintHFX
|
||||
#undef ConnectNovintHFX
|
||||
#endif
|
||||
|
||||
extern HMODULE dllNovintHFX_;
|
||||
extern IHapticsSystem *_hfx;
|
||||
|
||||
//quick helper class to ensure novint hfx unloads properly.
|
||||
struct NovintHFXCloseHelper
|
||||
{
|
||||
NovintHFXCloseHelper() : forceSkipQuit(false)
|
||||
{
|
||||
static bool ONE_INSTANCE_ONLY=true;
|
||||
if(!ONE_INSTANCE_ONLY)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
// look at the call stack and please remove whatever is calling this constructor.
|
||||
// there should be only one HFX_INIT_VARS.
|
||||
DebugBreak();
|
||||
#endif
|
||||
ExitProcess(100);
|
||||
}
|
||||
ONE_INSTANCE_ONLY = false;
|
||||
};
|
||||
bool forceSkipQuit;
|
||||
~NovintHFXCloseHelper()
|
||||
{
|
||||
if(!forceSkipQuit&&_hfx)
|
||||
{
|
||||
_hfx->ShutDown(true);
|
||||
}
|
||||
};
|
||||
};
|
||||
extern NovintHFXCloseHelper _hfx_close;
|
||||
|
||||
#define HFX_INIT_VARS() \
|
||||
HMODULE dllNovintHFX_=0; \
|
||||
IHapticsSystem *_hfx =0; \
|
||||
NovintHFXCloseHelper _hfx_close;
|
||||
|
||||
// if windows is included heres a inline function to get the interface!
|
||||
inline bool ConnectNovintHFX( IHapticsSystem **ppSystem, void *window, const char *cmd, void*pCursorEnableFn=0, unsigned int TargetDevices=1)
|
||||
{
|
||||
if(ppSystem==0)
|
||||
return false;
|
||||
|
||||
char szNovintDir[ MAX_PATH ];
|
||||
char szNovintDll[ MAX_PATH ];
|
||||
if ( GetEnvironmentVariableA( "NOVINT_DEVICE_SUPPORT", szNovintDir, sizeof( szNovintDir ) ) == 0 || !V_IsAbsolutePath( szNovintDir ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned int tries = 0;
|
||||
while(dllNovintHFX_==0)
|
||||
{
|
||||
const char *dllName = HFX_DYNAMIC_LIBRARY_NAME(tries);
|
||||
if(!dllName)
|
||||
break;
|
||||
V_sprintf_safe( szNovintDll, "%s\\bin\\%s", szNovintDir, dllName );
|
||||
dllNovintHFX_ = LoadLibraryA( szNovintDll );
|
||||
if(!dllNovintHFX_)
|
||||
tries++;
|
||||
}
|
||||
|
||||
NovintHFX_ExposeInterfaceFn connectFn = 0;
|
||||
if(dllNovintHFX_)
|
||||
{
|
||||
connectFn = (NovintHFX_ExposeInterfaceFn)GetProcAddress(dllNovintHFX_, HFX_CONNECT_FUNCTION_NAME());
|
||||
}
|
||||
if(!connectFn){
|
||||
// if direct load failed..
|
||||
if(dllNovintHFX_)
|
||||
{
|
||||
FreeLibrary(dllNovintHFX_);
|
||||
}
|
||||
V_sprintf_safe( szNovintDll, "%s\\bin\\%s", szNovintDir, "hfx.dll" );
|
||||
dllNovintHFX_ = LoadLibraryA( szNovintDll );
|
||||
if(dllNovintHFX_)
|
||||
{
|
||||
connectFn = (NovintHFX_ExposeInterfaceFn)GetProcAddress(dllNovintHFX_, "CreateHFX");
|
||||
}
|
||||
}
|
||||
if(connectFn&&connectFn((void **)ppSystem, window, cmd, HFX_VERSION_MAJOR, HFX_VERSION_MINOR, pCursorEnableFn, TargetDevices )==0)
|
||||
{
|
||||
_hfx = (*ppSystem);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
#ifndef HFX_STRIPPED
|
||||
inline bool ConnectNovintHFX_XML( IHapticsSystem **ppSystem, void *window, const char *xml, void*pCursorEnableFn=0, unsigned int TargetDevices=1)
|
||||
{
|
||||
if(ppSystem==0)
|
||||
return false;
|
||||
|
||||
char szNovintDir[ MAX_PATH ];
|
||||
char szNovintDll[ MAX_PATH ];
|
||||
if ( GetEnvironmentVariable( "NOVINT_DEVICE_SUPPORT", szNovintDir, sizeof( szNovintDir ) ) == 0 || !V_IsAbsolutePath( szNovintDir ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned int tries = 0;
|
||||
while(dllNovintHFX_==0)
|
||||
{
|
||||
const char *dllName = HFX_DYNAMIC_LIBRARY_NAME(tries);
|
||||
if(!dllName)
|
||||
break;
|
||||
V_sprintf_safe( szNovintDll, "%s\\bin\\%s", szNovintDir, dllName );
|
||||
dllNovintHFX_ = LoadLibraryA( szNovintDll );
|
||||
if(!dllNovintHFX_)
|
||||
tries++;
|
||||
}
|
||||
NovintHFX_ExposeInterfaceFn connectFn = 0;
|
||||
if(dllNovintHFX_)
|
||||
{
|
||||
connectFn = (NovintHFX_ExposeInterfaceFn)GetProcAddress(dllNovintHFX_, HFX_CONNECT_FUNCTION_NAME_XML());
|
||||
}
|
||||
if(!connectFn){
|
||||
if(dllNovintHFX_)
|
||||
{
|
||||
FreeLibrary(dllNovintHFX_);
|
||||
dllNovintHFX_=0;
|
||||
}
|
||||
V_sprintf_safe( szNovintDll, "%s\\bin\\%s", szNovintDir, "hfx.dll" );
|
||||
dllNovintHFX_ = LoadLibraryA( szNovintDll );
|
||||
if(dllNovintHFX_)
|
||||
{
|
||||
connectFn = (NovintHFX_ExposeInterfaceFn)GetProcAddress(dllNovintHFX_, "CreateHFX_XML");
|
||||
}
|
||||
|
||||
}
|
||||
if(connectFn&&connectFn((void **)ppSystem, window, xml, HFX_VERSION_MAJOR, HFX_VERSION_MINOR, pCursorEnableFn, TargetDevices )==0)
|
||||
{
|
||||
_hfx = (*ppSystem);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
inline bool ConnectNovintHFX( IHapticsSystem **ppSystem, HWND hwnd, const char *cmd, void*pCursorEnableFn=0, unsigned int TargetDevices=1 ){ return ConnectNovintHFX( ppSystem, (void*)hwnd, cmd, pCursorEnableFn, TargetDevices); }
|
||||
inline void DisconnectNovintHFX(IHapticsSystem **ppSystem=0)
|
||||
{
|
||||
if(dllNovintHFX_&&_hfx)
|
||||
{
|
||||
IHapticsSystem *pTemp = _hfx;
|
||||
_hfx = 0;
|
||||
_hfx_close.forceSkipQuit=true;
|
||||
if(ppSystem)
|
||||
{
|
||||
*ppSystem = 0;
|
||||
}
|
||||
pTemp->ShutDown();
|
||||
if(FreeLibrary(dllNovintHFX_))
|
||||
{
|
||||
dllNovintHFX_ = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,572 @@
|
||||
#ifndef IHFXPARAM_H_
|
||||
#define IHFXPARAM_H_
|
||||
#include ".\\HFXConfig.h"
|
||||
|
||||
class IHapticEffect;
|
||||
typedef IHapticEffect IHFXEffect;
|
||||
#ifdef HFX_64BIT
|
||||
#define HFX_NULL_HANDLE ((IHFXEffect*)(unsigned long)0x000000000000001)
|
||||
#else
|
||||
#define HFX_NULL_HANDLE ((IHFXEffect*)(unsigned long)0x00000001)
|
||||
#endif
|
||||
static IHFXEffect *hfxNoHandle=HFX_NULL_HANDLE;
|
||||
|
||||
typedef unsigned __int32 HFXParamID;
|
||||
typedef unsigned __int32 HFXEffectID;
|
||||
|
||||
// if a invalid char is added it will show up as '`'
|
||||
// if a '?' it will be the same as a '_'
|
||||
// any upper case chars will be converted to lowercase.
|
||||
|
||||
|
||||
#define HFX_PARAM_ENCODE_CHAR_LOWER(lowercase_alpha_or_underscore) \
|
||||
(lowercase_alpha_or_underscore ? ( ( lowercase_alpha_or_underscore < ('~'+1) ) ? \
|
||||
( (lowercase_alpha_or_underscore)-('^') ) : 2 ) : 0)
|
||||
|
||||
#define HFX_PARAM_ENCODE_CHAR_UPPER(upper_alpha) \
|
||||
(upper_alpha!=0 ? ( (upper_alpha>'>') ? \
|
||||
((upper_alpha)-('>')) : ( ((upper_alpha>'/')&&(upper_alpha<':')) ? \
|
||||
((upper_alpha + 32)-('>')) : (2) ) \
|
||||
) : 0)
|
||||
|
||||
#define HFX_PARAM_ENCODE_CHAR(alpha_or_underscore) \
|
||||
(alpha_or_underscore ?(alpha_or_underscore < '_') ? \
|
||||
HFX_PARAM_ENCODE_CHAR_UPPER(alpha_or_underscore) : \
|
||||
HFX_PARAM_ENCODE_CHAR_LOWER(alpha_or_underscore):0 )
|
||||
|
||||
#define HFX_PARAM_PACK_CHAR(char, index) \
|
||||
( char ? ((char) << (index * 5)) : 0 )
|
||||
|
||||
#define HFX_PARAM_ENCODE_STRING_CHAR(char) ( (char < '_') ? (HFX_PARAM_ENCODE_CHAR_UPPER(char)) : (HFX_PARAM_ENCODE_CHAR_LOWER(char)) )
|
||||
|
||||
#define HFX_PARAM_ENCODE_AND_PACK_CHAR(char, index) \
|
||||
HFX_PARAM_PACK_CHAR(HFX_PARAM_ENCODE_CHAR(char), index)
|
||||
|
||||
|
||||
#define TC unsigned int
|
||||
|
||||
#define HFX_PARAM_ENCODE_STRING(ConstCharPtr7) \
|
||||
( ConstCharPtr7 ? \
|
||||
(ConstCharPtr7[0]!=0 ? \
|
||||
((HFX_PARAM_ENCODE_STRING_CHAR((ConstCharPtr7)[0])) << 0) | \
|
||||
(ConstCharPtr7[1]!=0 ? \
|
||||
((HFX_PARAM_ENCODE_STRING_CHAR((ConstCharPtr7)[1])) << 5) | \
|
||||
(ConstCharPtr7[2]!=0 ? \
|
||||
((HFX_PARAM_ENCODE_STRING_CHAR((ConstCharPtr7)[2])) << 10) | \
|
||||
(ConstCharPtr7[3]!=0 ? \
|
||||
((HFX_PARAM_ENCODE_STRING_CHAR((ConstCharPtr7)[3])) << 15) | \
|
||||
(ConstCharPtr7[4]!=0 ? \
|
||||
((HFX_PARAM_ENCODE_STRING_CHAR((ConstCharPtr7)[4])) << 20) | \
|
||||
(ConstCharPtr7[5]!=0 ? \
|
||||
((HFX_PARAM_ENCODE_STRING_CHAR((ConstCharPtr7)[5])) << 25) \
|
||||
: (unsigned)0) \
|
||||
: (unsigned)0) \
|
||||
: (unsigned)0) \
|
||||
: (unsigned)0) \
|
||||
: (unsigned)0) \
|
||||
: (unsigned)0) \
|
||||
: (unsigned)0)
|
||||
|
||||
#define HFX_PARAM_ENCODE_6(c1,c2,c3,c4,c5,c6) \
|
||||
((HFXParamID)\
|
||||
( HFX_PARAM_ENCODE_AND_PACK_CHAR(c1,0) | HFX_PARAM_ENCODE_AND_PACK_CHAR(c2,1) | HFX_PARAM_ENCODE_AND_PACK_CHAR(c3,2) \
|
||||
| HFX_PARAM_ENCODE_AND_PACK_CHAR(c4,3) | HFX_PARAM_ENCODE_AND_PACK_CHAR(c5,4) | HFX_PARAM_ENCODE_AND_PACK_CHAR(c6,5) ))
|
||||
|
||||
#define HFX_PARAM_ENCODE_5(c1,c2,c3,c4,c5) \
|
||||
HFX_PARAM_ENCODE_6(c1,c2,c3,c4,c5,0)
|
||||
|
||||
#define HFX_PARAM_ENCODE_4(c1,c2,c3,c4) \
|
||||
HFX_PARAM_ENCODE_6(c1,c2,c3,c4,0,0)
|
||||
|
||||
#define HFX_PARAM_ENCODE_3(c1,c2,c3) \
|
||||
HFX_PARAM_ENCODE_6(c1,c2,c3,0,0,0)
|
||||
|
||||
#define HFX_PARAM_ENCODE_2(c1,c2) \
|
||||
HFX_PARAM_ENCODE_6(c1,c2,0,0,0,0)
|
||||
|
||||
#define HFX_PARAM_ENCODE_1(c1) \
|
||||
HFX_PARAM_ENCODE_6(c1,0,0,0,0,0)
|
||||
|
||||
#define HFX_PARAM_DECODE_TO(char7, hfxparamid) \
|
||||
(char7)[0] = HFX_CHAR_ID(hfxparamid, 0); \
|
||||
(char7)[1] = (char7)[0] ? HFX_CHAR_ID(hfxparamid, 1) : 0; \
|
||||
(char7)[2] = (char7)[1] ? HFX_CHAR_ID(hfxparamid, 2) : 0; \
|
||||
(char7)[3] = (char7)[2] ? HFX_CHAR_ID(hfxparamid, 3) : 0; \
|
||||
(char7)[4] = (char7)[3] ? HFX_CHAR_ID(hfxparamid, 4) : 0; \
|
||||
(char7)[5] = (char7)[4] ? HFX_CHAR_ID(hfxparamid, 5) : 0; \
|
||||
(char7)[6] = 0
|
||||
|
||||
HFX_INLINE HFXParamID HFX_PARAM_ENCODE_VA(char c1, char c2=0, char c3=0, char c4=0, char c5=0, char c6=0)
|
||||
{
|
||||
return HFX_PARAM_ENCODE_6(c1,c2,c3,c4,c5,c6);
|
||||
}
|
||||
|
||||
#if HFX_MSVC > 7
|
||||
//max of 6!
|
||||
#define HFX_PARAM_ENCODE(...) HFX_PARAM_ENCODE_VA(__VA_ARGS__)
|
||||
#else
|
||||
#define HFX_PARAM_ENCODE HFX_PARAM_ENCODE_VA
|
||||
#endif
|
||||
|
||||
|
||||
#define HFX_PARAM_ENCODE_4(c1,c2,c3,c4) HFX_PARAM_ENCODE_6(c1,c2,c3,c4,0,0)
|
||||
|
||||
#define HFX_5BIT_MASK ((1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4))
|
||||
|
||||
#define HFX_MASK_ID(paramid, index)((paramid>>(index*5)) & (HFX_5BIT_MASK))
|
||||
|
||||
#define HFX_CHAR_ID(paramid, index) \
|
||||
(HFX_MASK_ID(paramid,index)?HFX_MASK_ID(paramid,index)+'^':0)
|
||||
|
||||
// usage : char hfxParamText[] = HFX_PARAMETER_DECODE(hfxParamID);
|
||||
#define HFX_PARAM_DECODE(hfxparam) { \
|
||||
HFX_CHAR_ID(hfxparam,0), \
|
||||
HFX_CHAR_ID(hfxparam,1), \
|
||||
HFX_CHAR_ID(hfxparam,2), \
|
||||
HFX_CHAR_ID(hfxparam,3), \
|
||||
HFX_CHAR_ID(hfxparam,4), \
|
||||
HFX_CHAR_ID(hfxparam,5),0}
|
||||
|
||||
|
||||
enum HFXParamType
|
||||
{
|
||||
HFXPARAM_NULL = 0,
|
||||
HFXPARAM_INT = 'i',
|
||||
HFXPARAM_FLOAT = 'f',
|
||||
HFXPARAM_DOUBLE = 'd',
|
||||
HFXPARAM_BOOL = 'b',
|
||||
HFXPARAM_INT_ARRAY = 'I',
|
||||
HFXPARAM_FLOAT_ARRAY = 'F',
|
||||
HFXPARAM_DOUBLE_ARRAY = 'D',
|
||||
HFXPARAM_BOOL_ARRAY = 'B',
|
||||
};
|
||||
|
||||
typedef unsigned char HFXPARAM;
|
||||
|
||||
enum HFXArray
|
||||
{
|
||||
HFXARRAY_NOTARRAY=0,
|
||||
HFXARRAY_COPY=1,//
|
||||
HFXARRAY_INDEX=2,
|
||||
};
|
||||
typedef unsigned char HFXARRAY;
|
||||
typedef void *HFXVarValue;
|
||||
struct HFX_PURE_INTERFACE IHapticEffectParamGroup
|
||||
{
|
||||
|
||||
#ifndef HFX_NO_PARAMETER_CLASS_MACROS
|
||||
// declare this inside user implementated parametergroup class definitions.
|
||||
#define HFX_PARAMETER_GROUP(classname, baseclass, defaultEffect) \
|
||||
typedef classname ParameterGroup; \
|
||||
typedef baseclass SuperGroup; \
|
||||
typedef defaultEffect EffectClass; \
|
||||
using SuperGroup::SetVar; \
|
||||
using SuperGroup::GetVar; \
|
||||
using SuperGroup::SetVarFloat; \
|
||||
using SuperGroup::SetVarInt; \
|
||||
using SuperGroup::SetVarDouble; \
|
||||
using SuperGroup::GetVarBool; \
|
||||
using SuperGroup::GetVarFloat; \
|
||||
using SuperGroup::GetVarInt; \
|
||||
using SuperGroup::GetVarDouble;
|
||||
|
||||
#define HFX_PARAMETER_ID(name, type) \
|
||||
static const HFXParamID ID_##name; \
|
||||
static const char * const ID_##name##_String;
|
||||
// declare this inside user implementated parametergroup class definitions
|
||||
// for each variable you want to be accessible through
|
||||
// parameter filetypes or set/get functions. These macros will make the variable
|
||||
// you specify.
|
||||
// specify a seperate membername for readability.
|
||||
// REMEMBER: name should be no longer than 6 letters, membername can be as long as you want.
|
||||
#define HFX_PARAMETER_FLOAT(name, membername) \
|
||||
HFX_PARAMETER_ID(float_##name); \
|
||||
union{float name; float m_fl##name; float membername;}; \
|
||||
static const float ID_float_##name##_Default;
|
||||
|
||||
#define HFX_PARAMETER_DOUBLE(name, membername) \
|
||||
HFX_PARAMETER_ID(double_##name); \
|
||||
union{double name; double m_dbl##name; double membername;}; \
|
||||
static const bool ID_double_##name##_Default
|
||||
|
||||
#define HFX_PARAMETER_BOOL(name, membername) \
|
||||
HFX_PARAMETER_ID(bool_##name); \
|
||||
union{bool name:1; bool m_b##name:1; bool membername:1;}; \
|
||||
static const bool ID_bool_##name##_Default;
|
||||
|
||||
#define HFX_PARAMETER_INT(name, membername) \
|
||||
HFX_PARAMETER_ID(int_##name); \
|
||||
union{int name; int m_i##name; int membername;}; \
|
||||
static const int ID_int_##name##_Default;
|
||||
|
||||
#define HFX_PARAMETER_FLOAT_ARRAY(size, name, membername) \
|
||||
HFX_PARAMETER_ID(float##size##_##name); \
|
||||
union{float name; float m_fl##size##name; float membername;}; \
|
||||
static const float ID_float##size##_##name##_Default[size];
|
||||
|
||||
#define HFX_PARAMETER_DOUBLE_ARRAY(size, name, membername) \
|
||||
HFX_PARAMETER_ID(double##size##_##name); \
|
||||
union{double name[size]; double m_dbl##size##name[size]; double membername[size];}; \
|
||||
static const bool ID_double##size##_##name##_Default[size];
|
||||
|
||||
#define HFX_PARAMETER_BOOL_ARRAY(size, name, membername) \
|
||||
HFX_PARAMETER_ID(bool##size##_##name); \
|
||||
union{bool name[size]; bool m_b##size##name[size]; bool membername[size];}; \
|
||||
static const bool ID_bool##size##_##name##_Default[size];
|
||||
|
||||
#define HFX_PARAMETER_INT_ARRAY(size, name, membername) \
|
||||
HFX_PARAMETER_ID(int##size##_##name); \
|
||||
union{int name[size]; int m_i##name[size]; int membername[size];}; \
|
||||
static const int ID_int##size##_##name##_Default;
|
||||
#endif
|
||||
//virtual bool RunSetCommand( char *cmd ) = 0;
|
||||
//virtual HFXEffectID StandardEffectName() const = 0;
|
||||
|
||||
// ACTUAL OVERRIDES!
|
||||
virtual bool SetVar(const HFXParamID id, void *value, HFXParamType t,
|
||||
HFXARRAY settype=HFXARRAY_NOTARRAY, unsigned int indexORcount=0, bool allowMake=false) = 0;
|
||||
|
||||
virtual bool GetVar(const HFXParamID id, void *value, HFXParamType t,
|
||||
HFXARRAY gettype=HFXARRAY_NOTARRAY, unsigned int indexORcount=0 )const = 0;
|
||||
|
||||
#ifndef HFX_NO_OVERLOADED_PARAMETER
|
||||
|
||||
HFX_INLINE bool SetVarByName(const char *name, HFXVarValue value, HFXParamType t,
|
||||
bool allowMake )
|
||||
{return SetVar(HFX_PARAM_ENCODE_STRING(name), value, t, HFXARRAY_NOTARRAY, 0, allowMake);}
|
||||
|
||||
HFX_INLINE bool SetVar(const HFXParamID name, HFXVarValue value, HFXParamType t,
|
||||
bool allowMake )
|
||||
{return SetVar(name, value, t, HFXARRAY_NOTARRAY, 0, allowMake);}
|
||||
|
||||
HFX_INLINE bool SetVarByName(const char *name, HFXVarValue value, HFXParamType t,
|
||||
HFXARRAY settype, unsigned int indexORcount, bool allowMake )
|
||||
{return SetVar(HFX_PARAM_ENCODE_STRING(name), value, t, settype, indexORcount, allowMake);}
|
||||
|
||||
HFX_INLINE bool SetVarByName(const char *name, const double value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_DOUBLE, allowMake);}
|
||||
HFX_INLINE bool SetVar(const HFXParamID name, const double value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_DOUBLE, allowMake);}
|
||||
HFX_INLINE bool SetVarByName(const char *name, const bool value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_BOOL, allowMake);}
|
||||
HFX_INLINE bool SetVar(const HFXParamID name, const bool value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_BOOL, allowMake);}
|
||||
HFX_INLINE bool SetVarByName(const char *name, const float value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_FLOAT, allowMake);}
|
||||
HFX_INLINE bool SetVar(const HFXParamID name, const float value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_FLOAT, allowMake);}
|
||||
HFX_INLINE bool SetVarByName(const char *name, const int value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_INT, allowMake);}
|
||||
HFX_INLINE bool SetVar(const HFXParamID name, const int value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_INT, allowMake);}
|
||||
|
||||
HFX_INLINE bool SetVarArrayByName(const char *name, unsigned int arraySize, const double *value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
HFX_INLINE bool SetVarArray(const HFXParamID name, unsigned int arraySize, const double *value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
HFX_INLINE bool SetVarArrayByName(const char *name, unsigned int arraySize, const bool *value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
HFX_INLINE bool SetVarArray(const HFXParamID name, unsigned int arraySize, const bool *value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
HFX_INLINE bool SetVarArrayByName(const char *name, unsigned int arraySize, const float *value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
HFX_INLINE bool SetVarArray(const HFXParamID name, unsigned int arraySize, const float *value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
HFX_INLINE bool SetVarArrayByName(const char *name, unsigned int arraySize, const int *value, bool allowMake=false)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
HFX_INLINE bool SetVarArray(const HFXParamID name, unsigned int arraySize, const int *value, bool allowMake=false)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_COPY, arraySize, allowMake);}
|
||||
|
||||
template<typename T, int S>
|
||||
HFX_INLINE bool SetVarTypeArrayByName(const char *name, const T (value)[S], bool allowMake = false)
|
||||
{return SetVarArrayByName(name, S, (const T*)value, allowMake);}
|
||||
|
||||
template<typename T, int S>
|
||||
HFX_INLINE bool SetVarTypeArray(const HFXParamID name, const T (value)[S], bool allowMake = false)
|
||||
{return SetVarArray(name, S, (const T*)value, allowMake);}
|
||||
|
||||
HFX_INLINE bool SetVarElementByName(const char *name, unsigned int arrayIndex, const double value)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
HFX_INLINE bool SetVarElement(const HFXParamID name, unsigned int arrayIndex, const double value)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
HFX_INLINE bool SetVarElementByName(const char *name, unsigned int arrayIndex, const bool value)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
HFX_INLINE bool SetVarElement(const HFXParamID name, unsigned int arrayIndex, const bool value)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
HFX_INLINE bool SetVarElementByName(const char *name, unsigned int arrayIndex, const float value)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
HFX_INLINE bool SetVarElement(const HFXParamID name, unsigned int arrayIndex, const float value)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
HFX_INLINE bool SetVarElementByName(const char *name, unsigned int arrayIndex, const int value)
|
||||
{return SetVarByName(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
HFX_INLINE bool SetVarElement(const HFXParamID name, unsigned int arrayIndex, const int value)
|
||||
{return SetVar(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_INDEX, arrayIndex, false);}
|
||||
|
||||
HFX_INLINE bool GetVarByName(const char *name, void *value, HFXParamType t,
|
||||
HFXARRAY gettype=HFXARRAY_NOTARRAY, unsigned int indexORcount=0 )const
|
||||
{return GetVar(HFX_PARAM_ENCODE_STRING(name), value, t, gettype, indexORcount);}
|
||||
|
||||
HFX_INLINE bool GetVarByName(const char *name, float &value )const
|
||||
{return GetVarByName(name, (void*)&value, HFXPARAM_FLOAT);}
|
||||
HFX_INLINE bool GetVar( const HFXParamID name, float &value )const
|
||||
{return GetVar(name, (void*)&value, HFXPARAM_FLOAT);}
|
||||
HFX_INLINE bool GetVarByName(const char *name, double &value )const
|
||||
{return GetVarByName(name, (void*)&value, HFXPARAM_DOUBLE);}
|
||||
HFX_INLINE bool GetVar( const HFXParamID name, double &value )const
|
||||
{return GetVar(name, (void*)&value, HFXPARAM_DOUBLE);}
|
||||
HFX_INLINE bool GetVarByName(const char *name, int &value )const
|
||||
{return GetVarByName(name, (void*)&value, HFXPARAM_INT);}
|
||||
HFX_INLINE bool GetVar( const HFXParamID name, int &value )const
|
||||
{return GetVar(name, (void*)&value, HFXPARAM_INT);}
|
||||
HFX_INLINE bool GetVarByName(const char *name, bool &value )const
|
||||
{return GetVarByName(name, (void*)&value, HFXPARAM_BOOL);}
|
||||
HFX_INLINE bool GetVar( const HFXParamID name, bool &value )const
|
||||
{return GetVar(name, (void*)&value, HFXPARAM_BOOL);}
|
||||
|
||||
HFX_INLINE bool GetVarElementByName(const char *name, unsigned int arrayIndex, float &value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
HFX_INLINE bool GetVarElement(const HFXParamID name, unsigned int arrayIndex, float &value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
HFX_INLINE bool GetVarElementByName(const char *name, unsigned int arrayIndex, double &value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
HFX_INLINE bool GetVarElement(const HFXParamID name, unsigned int arrayIndex, double &value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
HFX_INLINE bool GetVarElementByName(const char *name, unsigned int arrayIndex, bool &value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
HFX_INLINE bool GetVarElement(const HFXParamID name, unsigned int arrayIndex, bool &value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
HFX_INLINE bool GetVarElementByName(const char *name, unsigned int arrayIndex, int &value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
HFX_INLINE bool GetVarElement(const HFXParamID name, unsigned int arrayIndex, int &value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_INDEX, arrayIndex);}
|
||||
|
||||
|
||||
HFX_INLINE bool GetVarArrayByName(const char *name, unsigned int arraySize, int *&value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
HFX_INLINE bool GetVarArrayByName(const char *name, unsigned int arraySize, float *&value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
HFX_INLINE bool GetVarArrayByName(const char *name, unsigned int arraySize, double *&value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
HFX_INLINE bool GetVarArrayByName(const char *name, unsigned int arraySize, bool *&value)const
|
||||
{return GetVarByName(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
|
||||
HFX_INLINE bool GetVarArray(const HFXParamID name, unsigned int arraySize, float *&value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_FLOAT_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
HFX_INLINE bool GetVarArray(const HFXParamID name, unsigned int arraySize, double *&value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_DOUBLE_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
HFX_INLINE bool GetVarArray(const HFXParamID name, unsigned int arraySize, bool *&value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_BOOL_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
HFX_INLINE bool GetVarArray(const HFXParamID name, unsigned int arraySize, int *&value)const
|
||||
{return GetVar(name, (HFXVarValue)&value, HFXPARAM_INT_ARRAY, HFXARRAY_COPY, arraySize);}
|
||||
|
||||
template<typename T, int S>
|
||||
HFX_INLINE bool GetVarTypeArrayByName(const char *name, T (value)[S])const
|
||||
{return GetVarArrayByName(name, S, (T*&)value);}
|
||||
|
||||
template<typename T, int S>
|
||||
HFX_INLINE bool GetVarTypeArray(const HFXParamID name, T (value)[S])const
|
||||
{return GetVarArray(name, S, (T*&)value);}
|
||||
|
||||
//strict access start. (ensures type is set) use these for typing or parsing.
|
||||
HFX_INLINE bool SetVarFloatByName(const char *name, const float value, bool allowMake=false)
|
||||
{ return SetVarByName(name, value, allowMake); }
|
||||
HFX_INLINE bool SetVarFloat(const HFXParamID name, const float value, bool allowMake=false)
|
||||
{ return SetVar(name, value, allowMake); }
|
||||
HFX_INLINE bool SetVarDoubleByName(const char *name, const double value, bool allowMake=false)
|
||||
{ return SetVarByName(name, value, allowMake); }
|
||||
HFX_INLINE bool SetVarDouble(const HFXParamID name, const double value, bool allowMake=false)
|
||||
{ return SetVar(name, value, allowMake); }
|
||||
HFX_INLINE bool SetVarIntByName(const char *name, const int value, bool allowMake=false)
|
||||
{ return SetVarByName(name, value, allowMake); }
|
||||
HFX_INLINE bool SetVarInt(const HFXParamID name, const int value, bool allowMake=false)
|
||||
{ return SetVar(name, value, allowMake); }
|
||||
HFX_INLINE bool SetVarBoolByName(const char *name, const bool value, bool allowMake=false)
|
||||
{ return SetVarByName(name, value, allowMake); }
|
||||
HFX_INLINE bool SetVarBool(const HFXParamID name, const bool value, bool allowMake=false)
|
||||
{ return SetVar(name, value, allowMake); }
|
||||
|
||||
|
||||
HFX_INLINE bool SetVarDoubleArrayByName(const char * name, unsigned int size, const double *value, bool allowMake=false)
|
||||
{ return SetVarArrayByName(name, size, value, allowMake); }
|
||||
HFX_INLINE bool SetVarDoubleArray(const HFXParamID name, unsigned int size, const double *value, bool allowMake=false)
|
||||
{ return SetVarArray(name, size, value, allowMake); }
|
||||
HFX_INLINE bool SetVarFloatArrayByName(const char * name, unsigned int size, const float *value, bool allowMake=false)
|
||||
{ return SetVarArrayByName(name, size, value, allowMake); }
|
||||
HFX_INLINE bool SetVarFloatArray(const HFXParamID name, unsigned int size, const float *value, bool allowMake=false)
|
||||
{ return SetVarArray(name, size, value, allowMake); }
|
||||
HFX_INLINE bool SetVarIntArrayByName(const char * name, unsigned int size, const int *value, bool allowMake=false)
|
||||
{ return SetVarArrayByName(name, size, value, allowMake); }
|
||||
HFX_INLINE bool SetVarIntArray(const HFXParamID name, unsigned int size, const int *value, bool allowMake=false)
|
||||
{ return SetVarArray(name, size, value, allowMake); }
|
||||
HFX_INLINE bool SetVarBoolArrayByName(const char * name, unsigned int size, const bool *value, bool allowMake=false)
|
||||
{ return SetVarArrayByName(name, size, value, allowMake); }
|
||||
HFX_INLINE bool SetVarBoolArray(const HFXParamID name, unsigned int size, const bool *value, bool allowMake=false)
|
||||
{ return SetVarArray(name, size, value, allowMake); }
|
||||
|
||||
HFX_INLINE bool SetVarFloatElementByName(const char * name, unsigned int index, const float value)
|
||||
{ return SetVarElementByName(name, index, value); }
|
||||
HFX_INLINE bool SetVarFloatElement(const HFXParamID name, unsigned int index, const float value)
|
||||
{ return SetVarElement(name, index, value); }
|
||||
HFX_INLINE bool SetVarIntElementByName(const char * name, unsigned int index, const int value)
|
||||
{ return SetVarElementByName(name, index, value); }
|
||||
HFX_INLINE bool SetVarIntElement(const HFXParamID name, unsigned int index, const int value)
|
||||
{ return SetVarElement(name, index, value); }
|
||||
HFX_INLINE bool SetVarBoolElementByName(const char * name, unsigned int index, const bool value)
|
||||
{ return SetVarElementByName(name, index, value); }
|
||||
HFX_INLINE bool SetVarBoolElement(const HFXParamID name, unsigned int index, const bool value)
|
||||
{ return SetVarElement(name, index, value); }
|
||||
HFX_INLINE bool SetVarDoubleElementByName(const char * name, unsigned int index, const double value)
|
||||
{ return SetVarElementByName(name, index, value); }
|
||||
HFX_INLINE bool SetVarDoubleElement(const HFXParamID name, unsigned int index, const double value)
|
||||
{ return SetVarElement(name, index, value); }
|
||||
|
||||
HFX_INLINE bool SetVarDoubleArrayByFloatArray(const HFXParamID name, unsigned int size, const float *value, bool allowMake=false)
|
||||
{
|
||||
double *__d_ = new double[size];
|
||||
for(unsigned int i=0;i!=size;i++)
|
||||
__d_[i]=(double)value[i];
|
||||
bool retval;
|
||||
retval = SetVarDoubleArray(name, size, __d_, allowMake);
|
||||
delete [] __d_;
|
||||
return retval;
|
||||
}
|
||||
HFX_INLINE bool SetVarDoubleArrayByFloatArrayByName(const char *name, unsigned int size, const float *value, bool allowMake=false)
|
||||
{ return SetVarDoubleArrayByFloatArray(HFX_PARAM_ENCODE_STRING(name),size,value,allowMake); }
|
||||
|
||||
HFX_INLINE bool GetVarFloatByName(const char *name, float &value)const
|
||||
{ return GetVarByName(name, value); }
|
||||
HFX_INLINE bool GetVarDoubleByName(const char *name, double &value)const
|
||||
{ return GetVarByName(name, value); }
|
||||
HFX_INLINE bool GetVarIntByName(const char *name, int &value)const
|
||||
{ return GetVarByName(name, value); }
|
||||
HFX_INLINE bool GetVarBoolByName(const char *name, bool &value)const
|
||||
{ return GetVarByName(name, value); }
|
||||
|
||||
HFX_INLINE bool GetVarFloatElementByName(const char *name, unsigned int index, float &value)const
|
||||
{ return GetVarElementByName(name, index, value); }
|
||||
HFX_INLINE bool GetVarDoubleElementByName(const char *name, unsigned int index, double &value)const
|
||||
{ return GetVarElementByName(name, index, value); }
|
||||
HFX_INLINE bool GetVarIntElementByName(const char *name, unsigned int index, int &value)const
|
||||
{ return GetVarElementByName(name, index, value); }
|
||||
HFX_INLINE bool GetVarBoolElementByName(const char *name, unsigned int index, bool &value)const
|
||||
{ return GetVarElementByName(name, index, value); }
|
||||
|
||||
HFX_INLINE bool GetVarFloatArrayByName(const char *name, unsigned int size, float *&value)const
|
||||
{ return GetVarArrayByName(name, size, value); }
|
||||
HFX_INLINE bool GetVarDoubleArrayByName(const char *name, unsigned int size, double *&value)const
|
||||
{ return GetVarArrayByName(name, size, value); }
|
||||
HFX_INLINE bool GetVarIntArrayByName(const char *name, unsigned int size, int *&value)const
|
||||
{ return GetVarArrayByName(name, size, value); }
|
||||
HFX_INLINE bool GetVarBoolArrayByName(const char *name, unsigned int size, bool *&value)const
|
||||
{ return GetVarArrayByName(name, size, value); }
|
||||
|
||||
HFX_INLINE bool GetVarFloat(const HFXParamID name, float &value)const
|
||||
{ return GetVar(name, value); }
|
||||
HFX_INLINE bool GetVarDouble(const HFXParamID name, double &value)const
|
||||
{ return GetVar(name, value); }
|
||||
HFX_INLINE bool GetVarInt(const HFXParamID name, int &value)const
|
||||
{ return GetVar(name, value); }
|
||||
HFX_INLINE bool GetVarBool(const HFXParamID name, bool &value)const
|
||||
{ return GetVar(name, value); }
|
||||
|
||||
HFX_INLINE bool GetVarFloatElement(const HFXParamID name, unsigned int index, float &value)const
|
||||
{ return GetVarElement(name, index, value); }
|
||||
HFX_INLINE bool GetVarDoubleElement(const HFXParamID name, unsigned int index, double &value)const
|
||||
{ return GetVarElement(name, index, value); }
|
||||
HFX_INLINE bool GetVarIntElement(const HFXParamID name, unsigned int index, int &value)const
|
||||
{ return GetVarElement(name, index, value); }
|
||||
HFX_INLINE bool GetVarBoolElement(const HFXParamID name, unsigned int index, bool &value)const
|
||||
{ return GetVarElement(name, index, value); }
|
||||
|
||||
HFX_INLINE bool GetVarFloatArray(const HFXParamID name, unsigned int size, float *&value)const
|
||||
{ return GetVarArray(name, size, value); }
|
||||
HFX_INLINE bool GetVarDoubleArray(const HFXParamID name, unsigned int size, double *&value)const
|
||||
{ return GetVarArray(name, size, value); }
|
||||
HFX_INLINE bool GetVarIntArray(const HFXParamID name, unsigned int size, int *&value)const
|
||||
{ return GetVarArray(name, size, value); }
|
||||
HFX_INLINE bool GetVarBoolArray(const HFXParamID name, unsigned int size, bool *&value)const
|
||||
{ return GetVarArray(name, size, value); }
|
||||
|
||||
HFX_INLINE bool GetVarDoubleArrayByFloatArray(const HFXParamID name, unsigned int size, float *&value) const
|
||||
{
|
||||
double *__d_ = new double[size];
|
||||
for(unsigned int i=0;i!=size;i++)
|
||||
__d_[i]=(double)value[i];
|
||||
bool retval;
|
||||
if(retval = GetVarDoubleArray(name, size, __d_))
|
||||
for(unsigned int i = 0;i!=size;i++)
|
||||
value[i]=(float)__d_[i];
|
||||
delete [] __d_;
|
||||
return retval;
|
||||
}
|
||||
HFX_INLINE bool GetVarDoubleArrayByFloatArrayByName(const char *name, unsigned int size, float *&value) const
|
||||
{ return GetVarDoubleArrayByFloatArray(HFX_PARAM_ENCODE_STRING(name),size,value); }
|
||||
|
||||
// util helpers
|
||||
// Vec3 and Vec3f
|
||||
HFX_INLINE bool SetVarVec3ByName(const char *name, const double *hfxVect3, bool bAllowMake=false)
|
||||
{return SetVarDoubleArrayByName(name, 3, hfxVect3, bAllowMake);}
|
||||
HFX_INLINE bool SetVarVec3(const HFXParamID name, const double *hfxVect3, bool bAllowMake=false)
|
||||
{return SetVarDoubleArray(name, 3, hfxVect3, bAllowMake);}
|
||||
HFX_INLINE bool GetVarVec3ByName(const char *name, double *&hfxVect3) const
|
||||
{return GetVarDoubleArrayByName(name, 3, hfxVect3);}
|
||||
HFX_INLINE bool GetVarVec3(const HFXParamID name, double *&hfxVect3) const
|
||||
{return GetVarDoubleArray(name, 3, hfxVect3);}
|
||||
|
||||
HFX_INLINE bool SetVarVec3fByName(const char *name, const float *hfxVect3f, bool bAllowMake=false)
|
||||
{return SetVarFloatArrayByName(name, 3, hfxVect3f, bAllowMake);}
|
||||
HFX_INLINE bool SetVarVec3f(const HFXParamID name, const float *hfxVect3f, bool bAllowMake=false)
|
||||
{return SetVarFloatArray(name, 3, hfxVect3f, bAllowMake);}
|
||||
HFX_INLINE bool GetVarVec3fByName(const char *name, float *&hfxVect3f) const
|
||||
{return GetVarFloatArrayByName(name, 3, hfxVect3f);}
|
||||
HFX_INLINE bool GetVarVec3f(const HFXParamID name, float *&hfxVect3f) const
|
||||
{return GetVarFloatArray(name, 3, hfxVect3f);}
|
||||
//strict access end.
|
||||
#endif
|
||||
/*
|
||||
virtual bool SetVar(HFXParamID id, const char *value, HFXParamType t,
|
||||
HFXARRAY settype=HFXARRAY_NOTARRAY, unsigned int indexORcount=0) = 0;
|
||||
|
||||
virtual bool GetVar(HFXParamID id, const char *value, HFXParamType t,
|
||||
HFXARRAY gettype=HFXARRAY_NOTARRAY, unsigned int indexORcount=0 )const = 0;
|
||||
*/
|
||||
virtual class IStack *GetDefaultStack() const=0;
|
||||
virtual void SetDefaultStack(class IStack *stack)=0;
|
||||
|
||||
virtual bool Copy(IHapticEffectParamGroup *&group) const=0;
|
||||
|
||||
virtual HFXEffectID StandardEffectID() const=0;
|
||||
virtual void ChangeStandardEffectID(const HFXEffectID type)=0;
|
||||
// creation
|
||||
virtual bool CreateStandardEffect( IHFXEffect *&pHandle, class IStack *createOnStack=0, const char *customName=0 )=0;
|
||||
HFX_INLINE bool CreateStandardEffect( IStack *createOnStack )
|
||||
{
|
||||
return CreateStandardEffect(hfxNoHandle, createOnStack, 0);
|
||||
}
|
||||
template<typename T>
|
||||
HFX_INLINE bool CreateStandardEffect( T *&pHandle, class IStack *createOnStack=0, const char *customName=0)
|
||||
{
|
||||
return CreateStandardEffect((IHFXEffect *&)pHandle, createOnStack, customName);
|
||||
}
|
||||
HFX_INLINE HFXParamType GetVarTypeByName(const char *param, unsigned int *arraysize=0) const{ return GetVarType(HFX_PARAM_ENCODE_STRING(param), arraysize); }
|
||||
virtual HFXParamType GetVarType(const HFXParamID param, unsigned int *arraysize=0) const=0;
|
||||
|
||||
};
|
||||
typedef IHapticEffectParamGroup IHFXParamGroup;
|
||||
|
||||
#define HFX_PARAMETER_INIT(classname, type, name, defaultvalue) \
|
||||
const char * const classname::ID_##type##name##_String = #name; \
|
||||
const HFXParamID classname::ID_##type##name = HFX_PARAM_ENCODE_STRING(classname::ID_##type##name##_String); \
|
||||
const type classname::ID_##type##name##_Default = defaultvalue;
|
||||
|
||||
typedef void (*HFXPGCreate_t)(IHFXParamGroup*&ptr);
|
||||
typedef void (*HFXPGDestroy_t)(IHFXParamGroup*&ptr);
|
||||
|
||||
template<typename T>
|
||||
void HFXDefaultAllocateParameterGroup(IHFXParamGroup *&ptr){ptr = new T;};
|
||||
|
||||
template<typename T>
|
||||
void HFXDefaultDeallocateParameterGroup(IHFXParamGroup *&ptr){if(!ptr)return; delete ((T*)ptr); ptr=0;};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,327 @@
|
||||
|
||||
#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 ©) : 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
|
||||
|
||||
@@ -0,0 +1,306 @@
|
||||
|
||||
|
||||
#ifndef HFX_INTERNAL
|
||||
struct HFX_vect3Base32
|
||||
{
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
};
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
} axis;
|
||||
struct
|
||||
{
|
||||
float right;
|
||||
float up;
|
||||
float backward;
|
||||
} direction;
|
||||
struct
|
||||
{
|
||||
float pitch;
|
||||
float yaw;
|
||||
float roll;
|
||||
} rotation;
|
||||
struct
|
||||
{
|
||||
float wide;
|
||||
float tall;
|
||||
float deep;
|
||||
} dimension;
|
||||
float m[3];
|
||||
};
|
||||
};
|
||||
// 192 == 3 * 64 == 3 doubles
|
||||
struct HFX_vect3Base64
|
||||
{
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
double x;
|
||||
double y;
|
||||
double z;
|
||||
};
|
||||
struct
|
||||
{
|
||||
double x;
|
||||
double y;
|
||||
double z;
|
||||
} axis;
|
||||
struct
|
||||
{
|
||||
double right;
|
||||
double up;
|
||||
double backward;
|
||||
} direction;
|
||||
struct
|
||||
{
|
||||
double pitch;
|
||||
double yaw;
|
||||
double roll;
|
||||
} rotation;
|
||||
struct
|
||||
{
|
||||
double wide;
|
||||
double tall;
|
||||
double deep;
|
||||
} dimension;
|
||||
double m[3];
|
||||
};
|
||||
};
|
||||
#endif
|
||||
#ifdef HFX_INTERNAL
|
||||
struct hfxVec3internal
|
||||
#endif
|
||||
#ifndef HFX_INTERNAL
|
||||
struct hfxVec3
|
||||
#endif
|
||||
: public HFX_vect3Base64
|
||||
{
|
||||
#ifndef HFX_INTERNAL
|
||||
HFX_INLINE HFX_EXPLICIT hfxVec3(const double &_x, const double &_y, const double &_z);
|
||||
HFX_INLINE HFX_EXPLICIT hfxVec3(const double array_d[3] );
|
||||
HFX_INLINE hfxVec3(const hfxVec3 &_copy);
|
||||
#ifdef HFX_ZERO_INIT
|
||||
HFX_INLINE HFX_EXPLICIT hfxVec3();
|
||||
#endif HFX_ZERO_INIT
|
||||
HFX_INLINE hfxVec3();
|
||||
#endif
|
||||
|
||||
HFX_INLINE double &operator [](int i);
|
||||
HFX_INLINE const double &operator[](int i) const;
|
||||
|
||||
HFX_INLINE operator double *();
|
||||
HFX_INLINE operator const double *() const;
|
||||
|
||||
HFX_INLINE hfxVec3 operator -() const;
|
||||
|
||||
HFX_INLINE hfxVec3 operator -(const hfxVec3 &vect) const;
|
||||
HFX_INLINE hfxVec3 &operator -=(const hfxVec3 &vect);
|
||||
|
||||
HFX_INLINE hfxVec3 operator +(const hfxVec3 &vect) const;
|
||||
HFX_INLINE hfxVec3 &operator +=(const hfxVec3 &vect);
|
||||
|
||||
HFX_INLINE hfxVec3 operator *(const hfxVec3 &vect) const;
|
||||
HFX_INLINE hfxVec3 operator *(const double &df) const;
|
||||
//HFX_INLINE hfxVec3 operator *(const float f) const;
|
||||
//HFX_INLINE hfxVec3 operator *(const int i){return ((*this)*((double)i));};
|
||||
|
||||
HFX_INLINE hfxVec3 operator /(const hfxVec3 &vect) const;
|
||||
HFX_INLINE hfxVec3 operator /(const double &df) const;
|
||||
//HFX_INLINE hfxVec3 operator /(const float f) const;
|
||||
//HFX_INLINE hfxVec3 operator /(const int i){return ((*this)/((double)i));};
|
||||
|
||||
HFX_INLINE hfxVec3 &operator /=(const hfxVec3 &vect);
|
||||
HFX_INLINE hfxVec3 &operator /=(const double &df);
|
||||
//HFX_INLINE hfxVec3 &operator /=(const float f);
|
||||
//HFX_INLINE hfxVec3 &operator /=(const int i){return ((*this)/=((double)i));};
|
||||
|
||||
HFX_INLINE hfxVec3 &operator *=(const hfxVec3 &vect);
|
||||
HFX_INLINE hfxVec3 &operator *=(const double &df);
|
||||
//HFX_INLINE hfxVec3 &operator *=(const float f);
|
||||
//HFX_INLINE hfxVec3 &operator *=(const int i){return ((*this)*=((double)i));};
|
||||
HFX_INLINE hfxVec3 &operator =(const hfxVec3 &vect);
|
||||
HFX_INLINE hfxVec3 &operator =(const double &all);
|
||||
//HFX_INLINE hfxVec3 &operator =(const float all);
|
||||
//HFX_INLINE hfxVec3 &operator =(const int i){return ((*this)=((double)i));}
|
||||
|
||||
HFX_INLINE const double *operator *()const;
|
||||
HFX_INLINE double *operator *();
|
||||
|
||||
HFX_INLINE hfxVec3 Cross(const hfxVec3 &vect) const;
|
||||
HFX_INLINE double Dot( const hfxVec3 &vect ) const;
|
||||
HFX_INLINE double Magnitude() const;
|
||||
// get normalize
|
||||
HFX_INLINE hfxVec3 Normalized() const;
|
||||
// normalize in place
|
||||
HFX_INLINE hfxVec3 &Normalize();
|
||||
HFX_INLINE bool IsValid() const;
|
||||
HFX_INLINE bool IsNaN() const;
|
||||
#ifdef HFX_INTERNAL
|
||||
HFX_INLINE hfxVec3internal *GetVec3Pointer(){ return (this); };
|
||||
HFX_INLINE const hfxVec3internal *GetVec3Pointer()const{ return (this); };
|
||||
HFX_INLINE operator hfxVec3 &(){ return *(reinterpret_cast<hfxVec3*>(this)); }
|
||||
HFX_INLINE operator const hfxVec3 &()const { return *(reinterpret_cast<const hfxVec3*>(this)); }
|
||||
#endif
|
||||
#ifndef HFX_PAT_DOESNT_KNOW
|
||||
HFX_INLINE double Length() const;
|
||||
HFX_INLINE hfxVec3 Normal() const;
|
||||
#endif
|
||||
};
|
||||
#ifndef HFX_INTERNAL
|
||||
#ifndef HFX_NO_TYPEDEFS
|
||||
typedef hfxVec3 Vect3;
|
||||
#endif
|
||||
struct hfxVec3F : public HFX_vect3Base32
|
||||
{
|
||||
HFX_INLINE hfxVec3F(const float _x, const float _y, const float _z);
|
||||
HFX_INLINE hfxVec3F(const float array_f[3] );
|
||||
HFX_INLINE hfxVec3F(const hfxVec3F &_copy);
|
||||
HFX_INLINE hfxVec3F();
|
||||
|
||||
HFX_INLINE float &operator [](int i);
|
||||
HFX_INLINE const float &operator[](int i) const;
|
||||
|
||||
HFX_INLINE operator float *();
|
||||
HFX_INLINE operator const float *() const;
|
||||
|
||||
HFX_INLINE hfxVec3F operator -() const;
|
||||
|
||||
HFX_INLINE hfxVec3F operator -(const hfxVec3F &vect) const;
|
||||
HFX_INLINE hfxVec3F &operator -=(const hfxVec3F &vect);
|
||||
|
||||
HFX_INLINE hfxVec3F operator +(const hfxVec3F &vect) const;
|
||||
HFX_INLINE hfxVec3F &operator +=(const hfxVec3F &vect);
|
||||
|
||||
HFX_INLINE hfxVec3F operator *(const hfxVec3F &vect) const;
|
||||
HFX_INLINE hfxVec3F operator *(const float f) const;
|
||||
//HFX_INLINE hfxVec3F operator *(const double &df) const;
|
||||
//HFX_INLINE hfxVec3F operator *(const int i){return ((*this)*(double)i);};
|
||||
|
||||
HFX_INLINE hfxVec3F operator /(const hfxVec3F &vect) const;
|
||||
HFX_INLINE hfxVec3F operator /(const float f) const;
|
||||
//HFX_INLINE hfxVec3F operator /(const double &df) const;
|
||||
//HFX_INLINE hfxVec3F operator /(const int i){return ((*this)/(double)i);};
|
||||
|
||||
HFX_INLINE hfxVec3F &operator /=(const hfxVec3F &vect);
|
||||
HFX_INLINE hfxVec3F &operator /=(const float f);
|
||||
//HFX_INLINE hfxVec3F &operator /=(const double &df);
|
||||
//HFX_INLINE hfxVec3F &operator /=(const int i){return ((*this)/=(double)i);};
|
||||
|
||||
HFX_INLINE hfxVec3F &operator *=(const hfxVec3F &vect);
|
||||
HFX_INLINE hfxVec3F &operator *=(const float f);
|
||||
//HFX_INLINE hfxVec3F &operator *=(const double &df);
|
||||
//HFX_INLINE hfxVec3F &operator *=(const int i){return ((*this)*=(double)i);};
|
||||
|
||||
HFX_INLINE hfxVec3F &operator =(const hfxVec3F &vect);
|
||||
HFX_INLINE hfxVec3F &operator =(const float all);
|
||||
//HFX_INLINE hfxVec3F &operator =(const double &all);
|
||||
//HFX_INLINE hfxVec3F &operator =(const int i){return ((*this)=(double)i);}
|
||||
|
||||
HFX_INLINE const float *operator *()const;
|
||||
HFX_INLINE float *operator *();
|
||||
|
||||
HFX_INLINE hfxVec3F Cross(const hfxVec3F &vect) const;
|
||||
HFX_INLINE float Dot( const hfxVec3F &vect ) const;
|
||||
HFX_INLINE float Magnitude() const;
|
||||
// get normalize
|
||||
HFX_INLINE hfxVec3F Normalized() const;
|
||||
// normalize in place
|
||||
HFX_INLINE hfxVec3F &Normalize();
|
||||
HFX_INLINE bool IsValid() const;
|
||||
HFX_INLINE bool IsNaN() const;
|
||||
#ifndef HFX_PAT_DOESNT_KNOW
|
||||
HFX_INLINE float Length() const;
|
||||
HFX_INLINE hfxVec3F Normal() const;
|
||||
#endif
|
||||
};
|
||||
|
||||
struct _box3Base
|
||||
{
|
||||
union
|
||||
{
|
||||
struct{
|
||||
HFX_vect3Base64 bound_min;
|
||||
HFX_vect3Base64 bound_max;
|
||||
}box;
|
||||
HFX_vect3Base64 min_max[2];
|
||||
struct
|
||||
{
|
||||
double left;
|
||||
double down;
|
||||
double forward;
|
||||
double right;
|
||||
double up;
|
||||
double backward;
|
||||
}side;
|
||||
double m[6];
|
||||
};
|
||||
};
|
||||
struct BoundingBox3 : public _box3Base
|
||||
{
|
||||
inline BoundingBox3(const double &left=0, const double &down=0, const double &forward=0,
|
||||
const double &right=0, const double &up=0, const double &backward=0)
|
||||
{
|
||||
side.left = left;
|
||||
side.down = down;
|
||||
side.forward = forward;
|
||||
side.right = right;
|
||||
side.up = up;
|
||||
side.backward = backward;
|
||||
}
|
||||
inline BoundingBox3(const hfxVec3 &bMin, const hfxVec3 &bMax)
|
||||
{
|
||||
BoxMin() = bMin;
|
||||
BoxMax() = bMax;
|
||||
}
|
||||
inline hfxVec3 &BoxMin(){return (hfxVec3&)box.bound_min;};
|
||||
inline const hfxVec3 &BoxMin() const {return (const hfxVec3&)box.bound_min;};
|
||||
inline hfxVec3 &BoxMax(){return (hfxVec3&)box.bound_max;};
|
||||
inline const hfxVec3 &BoxMax() const {return (const hfxVec3&)box.bound_max;};
|
||||
inline hfxVec3 Center() const { return (BoxMin() + BoxMax())/(double)2.0; };
|
||||
inline hfxVec3 Dimensions() const { return BoxMax() - BoxMin();};
|
||||
inline hfxVec3 SpaceBetweenCentered(const BoundingBox3 &other) const {return other.Dimensions() - Dimensions();};
|
||||
inline BoundingBox3 SpaceBetween(const BoundingBox3 &other) const {return other - *this;}
|
||||
inline BoundingBox3 &SetDimensions(const hfxVec3 &dimm) { hfxVec3 cent = Center(); hfxVec3 dim = dimm/2.0; BoxMin() = cent - dim; BoxMax() = cent + dim; return *this; }
|
||||
inline BoundingBox3 &SetCenter(const hfxVec3 ¢) { hfxVec3 dim = Dimensions(); BoxMin() = cent - dim; BoxMax() = cent + dim; return *this; }
|
||||
inline operator hfxVec3 *(){return (hfxVec3*)min_max;};
|
||||
inline operator const hfxVec3 *() const {return (const hfxVec3*)min_max;};
|
||||
inline operator double *() {return m;};
|
||||
inline operator const double *() const {return m;};
|
||||
inline BoundingBox3 operator -(const hfxVec3 &vect) const { return BoundingBox3( BoxMin() - vect, BoxMax() - vect ); }
|
||||
inline BoundingBox3 operator +(const hfxVec3 &vect) const { return BoundingBox3( BoxMin() + vect, BoxMax() + vect ); }
|
||||
inline BoundingBox3 operator *(const hfxVec3 &vect) const { return BoundingBox3( BoxMin() * vect, BoxMax() * vect ); }
|
||||
inline BoundingBox3 operator /(const hfxVec3 &vect) const { return BoundingBox3( BoxMin() / vect, BoxMax() / vect ); }
|
||||
inline BoundingBox3 operator *(const double &df) const{ return BoundingBox3( BoxMin() * df, BoxMax() * df ); }
|
||||
inline BoundingBox3 operator /(const double &df) const{ return BoundingBox3( BoxMin() / df, BoxMax() / df ); }
|
||||
inline BoundingBox3 operator -(const BoundingBox3 &bbox) const { return BoundingBox3( BoxMin() - bbox.BoxMin(), BoxMax() - bbox.BoxMax() ); }
|
||||
inline BoundingBox3 operator +(const BoundingBox3 &bbox) const { return BoundingBox3( BoxMin() + bbox.BoxMin(), BoxMax() + bbox.BoxMax() ); }
|
||||
inline BoundingBox3 operator *(const BoundingBox3 &bbox) const { return BoundingBox3( BoxMin() * bbox.BoxMin(), BoxMax() * bbox.BoxMax() ); }
|
||||
inline BoundingBox3 operator /(const BoundingBox3 &bbox) const { return BoundingBox3( BoxMin() / bbox.BoxMin(), BoxMax() / bbox.BoxMax() ); }
|
||||
inline BoundingBox3 &operator =(const BoundingBox3 &bbox) { BoxMin() = bbox.BoxMin(); BoxMax() = bbox.BoxMax(); return *this; }
|
||||
inline BoundingBox3 &operator -=(const hfxVec3 &vect){ BoxMin()-=vect; BoxMax()-=vect; return *this; }
|
||||
inline BoundingBox3 &operator +=(const hfxVec3 &vect){ BoxMin()+=vect; BoxMax()+=vect; return *this; }
|
||||
inline BoundingBox3 &operator *=(const hfxVec3 &vect){ BoxMin()*=vect; BoxMax()*=vect; return *this; }
|
||||
inline BoundingBox3 &operator /=(const hfxVec3 &vect){ BoxMin()/=vect; BoxMax()/=vect; return *this; }
|
||||
inline BoundingBox3 &operator *=(const double &df){ BoxMin()*=df; BoxMax()*=df; return *this; }
|
||||
inline BoundingBox3 &operator /=(const double &df){ BoxMin()/=df; BoxMax()/=df; return *this; }
|
||||
inline BoundingBox3 &operator -=(const BoundingBox3 &bbox){ BoxMin()-=bbox.BoxMin(); BoxMax()-=bbox.BoxMax(); return *this; }
|
||||
inline BoundingBox3 &operator +=(const BoundingBox3 &bbox){ BoxMin()+=bbox.BoxMin(); BoxMax()+=bbox.BoxMax(); return *this; }
|
||||
inline BoundingBox3 &operator *=(const BoundingBox3 &bbox){ BoxMin()*=bbox.BoxMin(); BoxMax()*=bbox.BoxMax(); return *this; }
|
||||
inline BoundingBox3 &operator /=(const BoundingBox3 &bbox){ BoxMin()/=bbox.BoxMin(); BoxMax()/=bbox.BoxMax(); return *this; }
|
||||
};
|
||||
#endif
|
||||
#include "inl_hfxMath.h"
|
||||
#ifdef HFX_INTERNAL
|
||||
typedef ::hfxVec3 hfxVec3;
|
||||
//VECTOR CLASS
|
||||
#endif
|
||||
@@ -0,0 +1,141 @@
|
||||
#ifndef _INC_MATH
|
||||
#include HFX_NO_MERGE(math.h)
|
||||
#endif
|
||||
#define HFXVEC3(other,oper)return HFXVEC3T(x##oper##other.x,y##oper##other.y,z##oper##other.z)
|
||||
#define HFXVEC3F(other,oper) return HFXVEC3T(x##oper##other,y##oper##other,z##oper##other)
|
||||
#ifndef HFX_INTERNAL
|
||||
#define HFXVEC3SELF(other,oper)x##oper##other.x;y##oper##other.y;z##oper##other.z;return(*this)
|
||||
#define HFXVEC3FSELF(other,oper) x##oper##other;y##oper##other;z##oper##other;return(*this)
|
||||
#endif
|
||||
#ifdef HFX_INTERNAL
|
||||
#define HFXVEC3SELF(other,oper)x##oper##other.x;y##oper##other.y;z##oper##other.z;return *(reinterpret_cast<hfxVec3*>(this))
|
||||
#define HFXVEC3FSELF(other,oper) x##oper##other;y##oper##other;z##oper##other;return *(reinterpret_cast<hfxVec3*>(this))
|
||||
#endif
|
||||
// 192 bit vect3
|
||||
#define HFXVEC3T hfxVec3
|
||||
#ifdef HFX_INTERNAL
|
||||
#define HFXVEC3_DEFTYPE hfxVec3internal
|
||||
#endif
|
||||
#ifndef HFX_INTERNAL
|
||||
#define HFXVEC3_DEFTYPE hfxVec3
|
||||
#ifdef HFX_ZERO_INIT
|
||||
HFX_INLINE HFX_EXPLICIT hfxVec3::hfxVec3()
|
||||
{
|
||||
HFX_MEMSET(m,0,sizeof(double)*3);
|
||||
}
|
||||
#endif
|
||||
HFX_INLINE hfxVec3::hfxVec3()
|
||||
{
|
||||
__assume(0);
|
||||
}
|
||||
HFX_INLINE hfxVec3::hfxVec3(const double &_x, const double &_y, const double &_z){x=_x;y=_y;z=_z;};
|
||||
HFX_INLINE hfxVec3::hfxVec3(const hfxVec3 &_copy){HFX_MEMCPY(m,_copy.m,sizeof(double)*3);};
|
||||
HFX_INLINE hfxVec3::hfxVec3(const double *array_d){HFX_MEMCPY(m,array_d,sizeof(double)*3);}
|
||||
#endif
|
||||
|
||||
HFX_INLINE bool HFXVEC3_DEFTYPE::IsValid()const{return(!IsNaN());}
|
||||
HFX_INLINE bool HFXVEC3_DEFTYPE::IsNaN()const{return (x!=x||y!=y||z!=z);}
|
||||
|
||||
HFX_INLINE double HFXVEC3_DEFTYPE::Magnitude()const{return(sqrt(x*x+y*y+z*z));}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::Normalized()const{hfxVec3 copy(m);return(copy.Normalize());}
|
||||
#ifndef HFX_INTERNAL
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::Normalize(){double l=Magnitude();x/=l;y/=l;z/=l;return(*this);}
|
||||
#endif
|
||||
#ifdef HFX_INTERNAL
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::Normalize(){double l=Magnitude();x/=l;y/=l;z/=l;return(*(reinterpret_cast<hfxVec3*>(this)));}
|
||||
#endif
|
||||
#ifndef HFX_PAT_DOESNT_KNOW
|
||||
HFX_INLINE double HFXVEC3_DEFTYPE::Length()const{return(Magnitude());};
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::Normal()const{return Normalized();};
|
||||
#endif
|
||||
HFX_INLINE double HFXVEC3_DEFTYPE::Dot( const hfxVec3 &v )const{return(x*v.x+y*v.y+z*v.z);}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::Cross(const hfxVec3 &v)const{return hfxVec3(x*v.z-z*v.y,z*v.x-x*v.z,x*v.y-y*v.x);}
|
||||
|
||||
HFX_INLINE const double &HFXVEC3_DEFTYPE::operator [](int i)const{return(m[i]);};
|
||||
HFX_INLINE double &HFXVEC3_DEFTYPE::operator [](int i){return(m[i]);};
|
||||
HFX_INLINE HFXVEC3_DEFTYPE::operator const double *() const{return(m);}
|
||||
HFX_INLINE HFXVEC3_DEFTYPE::operator double *(){return(m);}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::operator -()const{return(hfxVec3(-x,-y,-z));}
|
||||
HFX_INLINE double *HFXVEC3_DEFTYPE::operator *(){return(m);};
|
||||
HFX_INLINE const double *HFXVEC3_DEFTYPE::operator *()const{return(m);};
|
||||
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::operator *(const hfxVec3 &v)const{HFXVEC3(v,*);}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::operator +(const hfxVec3 &v)const{HFXVEC3(v,+);}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::operator -(const hfxVec3 &v)const{HFXVEC3(v,-);}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::operator /(const hfxVec3 &v)const{HFXVEC3(v,/);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator =(const hfxVec3 &v){HFXVEC3SELF(v,=);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator *=(const hfxVec3 &v){HFXVEC3SELF(v,*=);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator +=(const hfxVec3 &v){HFXVEC3SELF(v,+=);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator -=(const hfxVec3 &v){HFXVEC3SELF(v,-=);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator /=(const hfxVec3 &v){HFXVEC3SELF(v,/=);}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::operator *(const double &d)const{HFXVEC3F(d,*);}
|
||||
HFX_INLINE hfxVec3 HFXVEC3_DEFTYPE::operator /(const double &d)const{HFXVEC3F(d,/);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator *=(const double &d){HFXVEC3FSELF(d,*=);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator /=(const double &d){HFXVEC3FSELF(d,/=);}
|
||||
//HFX_INLINE hfxVec3 hfxVec3::operator *(const float f)const{HFXVEC3F((double)f,*);}
|
||||
//HFX_INLINE hfxVec3 hfxVec3::operator /(const float f)const{HFXVEC3F((double)f,/);}
|
||||
//HFX_INLINE hfxVec3 &hfxVec3::operator *=(const float f){HFXVEC3FSELF((double)f,*=);}
|
||||
//HFX_INLINE hfxVec3 &hfxVec3::operator /=(const float f){HFXVEC3FSELF((double)f,/=);}
|
||||
HFX_INLINE hfxVec3 &HFXVEC3_DEFTYPE::operator =(const double &d){x=y=z=d;return(*this);}
|
||||
//HFX_INLINE hfxVec3 &hfxVec3::operator =(const float f){x=y=z=(double)f;return(*this);}
|
||||
#undef HFXVEC3T
|
||||
#undef HFXVEC3_DEFTYPE
|
||||
#ifndef HFX_INTERNAL
|
||||
// 96 bit vect3
|
||||
#define HFXVEC3T hfxVec3F
|
||||
HFX_INLINE hfxVec3F::hfxVec3F()
|
||||
{
|
||||
#ifdef HFX_ZERO_INIT
|
||||
HFX_MEMSET(m,0,sizeof(float)*3);
|
||||
#endif
|
||||
}
|
||||
HFX_INLINE hfxVec3F::hfxVec3F(const float _x, const float _y, const float _z){x=_x;y=_y;z=_z;};
|
||||
HFX_INLINE hfxVec3F::hfxVec3F(const hfxVec3F &_copy){HFX_MEMCPY(m,_copy.m,sizeof(float)*3);};
|
||||
HFX_INLINE hfxVec3F::hfxVec3F(const float *array_d){HFX_MEMCPY(m,array_d,sizeof(float)*3);}
|
||||
|
||||
HFX_INLINE bool hfxVec3F::IsValid()const{return(!IsNaN());}
|
||||
HFX_INLINE bool hfxVec3F::IsNaN()const{return (x!=x||y!=y||z!=z);}
|
||||
|
||||
HFX_INLINE float hfxVec3F::Magnitude()const{return(sqrt(x*x+y*y+z*z));}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::Normalized()const{float l=Magnitude();return(hfxVec3F(x/l,y/l,z/l));}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::Normalize(){float l=Magnitude();x/=l;y/=l;z/=l;return(*this);}
|
||||
#ifndef HFX_PAT_DOESNT_KNOW
|
||||
HFX_INLINE float hfxVec3F::Length()const{return(Magnitude());};
|
||||
HFX_INLINE hfxVec3F hfxVec3F::Normal()const{return Normalized();};
|
||||
#endif
|
||||
HFX_INLINE float hfxVec3F::Dot( const hfxVec3F &v )const{return(x*v.x+y*v.y+z*v.z);}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::Cross(const hfxVec3F &v)const{return hfxVec3F(x*v.z-z*v.y,z*v.x-x*v.z,x*v.y-y*v.x);}
|
||||
|
||||
HFX_INLINE const float &hfxVec3F::operator [](int i)const{return(m[i]);};
|
||||
HFX_INLINE float &hfxVec3F::operator [](int i){return(m[i]);};
|
||||
HFX_INLINE hfxVec3F::operator const float *() const{return(m);}
|
||||
HFX_INLINE hfxVec3F::operator float *(){return(m);}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::operator -()const{return(hfxVec3F(-x,-y,-z));}
|
||||
HFX_INLINE float *hfxVec3F::operator *(){return(m);};
|
||||
HFX_INLINE const float *hfxVec3F::operator *()const{return(m);};
|
||||
|
||||
HFX_INLINE hfxVec3F hfxVec3F::operator *(const hfxVec3F &v)const{HFXVEC3(v,*);}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::operator +(const hfxVec3F &v)const{HFXVEC3(v,+);}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::operator -(const hfxVec3F &v)const{HFXVEC3(v,-);}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::operator /(const hfxVec3F &v)const{HFXVEC3(v,/);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator =(const hfxVec3F &v){HFXVEC3SELF(v,=);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator *=(const hfxVec3F &v){HFXVEC3SELF(v,*=);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator +=(const hfxVec3F &v){HFXVEC3SELF(v,+=);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator -=(const hfxVec3F &v){HFXVEC3SELF(v,-=);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator /=(const hfxVec3F &v){HFXVEC3SELF(v,/=);}
|
||||
//HFX_INLINE hfxVec3F hfxVec3F::operator *(const double &d)const{HFXVEC3F((float)d,*);}
|
||||
//HFX_INLINE hfxVec3F hfxVec3F::operator /(const double &d)const{HFXVEC3F((float)d,/);}
|
||||
//HFX_INLINE hfxVec3F &hfxVec3F::operator *=(const double &d){HFXVEC3FSELF((float)d,*=);}
|
||||
//HFX_INLINE hfxVec3F &hfxVec3F::operator /=(const double &d){HFXVEC3FSELF((float)d,/=);}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::operator *(const float f)const{HFXVEC3F(f,*);}
|
||||
HFX_INLINE hfxVec3F hfxVec3F::operator /(const float f)const{HFXVEC3F(f,/);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator *=(const float f){HFXVEC3FSELF(f,*=);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator /=(const float f){HFXVEC3FSELF(f,/=);}
|
||||
//HFX_INLINE hfxVec3F &hfxVec3F::operator =(const double &d){x=y=z=(float)d;return(*this);}
|
||||
HFX_INLINE hfxVec3F &hfxVec3F::operator =(const float f){x=y=z=f;return(*this);}
|
||||
#endif
|
||||
#undef HFXVEC3T
|
||||
#undef HFXVEC3
|
||||
#undef HFXVEC3SELF
|
||||
#undef HFXVEC3F
|
||||
#undef HFXVEC3FSELF
|
||||
@@ -0,0 +1,54 @@
|
||||
|
||||
typedef int (*NovintHFX_ExposeInterfaceFn)(void **ppInterface, void *hwnd, const char *cmd, unsigned int versionMaj, unsigned int versionMin, void *pMouseEnableFN, unsigned int TargetDevices);
|
||||
inline const char *HFX_GetVersionMajorString(){
|
||||
return HFX_VERSION_MAJOR_SZ;
|
||||
}
|
||||
inline const char *HFX_GetVersionMinorString(){
|
||||
return HFX_VERSION_MINOR_SZ;
|
||||
}
|
||||
inline const char *HFX_CONNECT_FUNCTION_NAME(){
|
||||
return "_export_ExposeInterfaceHFX_" HFX_VERSION_MAJOR_SZ "_" HFX_VERSION_MINOR_SZ "_";
|
||||
}
|
||||
inline const char *HFX_CONNECT_FUNCTION_NAME_XML(){
|
||||
return "_export_ExposeInterfaceHFX_XML_" HFX_VERSION_MAJOR_SZ "_" HFX_VERSION_MINOR_SZ "_";
|
||||
}
|
||||
inline const char *HFX_DYNAMIC_LIBRARY_NAME(const unsigned int tries = 0){
|
||||
switch(tries)
|
||||
{
|
||||
default:
|
||||
return 0;
|
||||
break;
|
||||
|
||||
#ifdef HFX_DLL_CUSTOM_NAME
|
||||
case 0:
|
||||
return HFX_DLL_CUSTOM_NAME;
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifndef HFX_DLL_CUSTOM_NAME
|
||||
case 0:
|
||||
#else
|
||||
case 1:
|
||||
#endif
|
||||
return "NovintHFX_" HFX_VERSION_MAJOR_SZ "." HFX_VERSION_MINOR_SZ ".dll";
|
||||
break;
|
||||
|
||||
#ifndef HFX_DLL_CUSTOM_NAME
|
||||
case 1:
|
||||
#else
|
||||
case 2:
|
||||
#endif
|
||||
return "NovintHFX.dll";
|
||||
break;
|
||||
|
||||
};
|
||||
}
|
||||
inline unsigned int HFX_GetVersionMajor(){
|
||||
return HFX_VERSION_MAJOR;
|
||||
}
|
||||
inline unsigned int HFX_GetVersionMinor(){
|
||||
return HFX_VERSION_MINOR;
|
||||
}
|
||||
inline double HFX_GetVersion(){
|
||||
return HFX_VERSION_FLOAT;
|
||||
}
|
||||
Reference in New Issue
Block a user