00001 //---------------------------------------------------------------------------------
00002 // File Name: Physics.h
00003 // Description:
00006 //
00007 // Copyright (C) 2004 - 2006 True Axis Pty Ltd, Australia. 
00008 // All Rights Reserved.
00009 //
00010 // History:
00011 //      Created File.
00012 //---------------------------------------------------------------------------------
00013 
00014 #ifndef TA_PHYSICS_H
00015 #define TA_PHYSICS_H
00016 
00017 #ifndef TA_DEBUG_H
00018 #include "../Common/Debug.h"
00019 #endif // TA_DEBUG_H
00020 
00021 #ifndef TA_LIST_H
00022 #include "../Common/List.h"
00023 #endif // TA_LIST_H
00024 
00025 #ifndef TA_POOL_H
00026 #include "../Common/Pool.h"
00027 #endif // TA_POOL_H
00028 
00029 #ifndef TA_VECTOR_H
00030 #include "../Common/Vector.h"
00031 #endif // TA_VECTOR_H
00032 
00033 #ifndef TA_PHYSICSCOMMON_H
00034 #include "PhysicsCommon.h"
00035 #endif // TA_PHYSICSCOMMON_H
00036 
00037 #ifndef TA_DYNAMICOBJECT_H
00038 #include "DynamicObject.h"
00039 #endif // TA_DYNAMICOBJECT_H
00040 
00041 #ifndef TA_STATICOBJECT_H
00042 #include "StaticObject.h"
00043 #endif // TA_STATICOBJECT_H
00044 
00045 #ifndef TA_SURFACEATTRIBUTE_H
00046 #include "SurfaceAttribute.h"
00047 #endif // TA_SURFACEATTRIBUTE_H
00048 
00049 TA_OBFUSCATION_SKIP_PASS_2
00050 
00051 namespace TA
00052 {
00053 
00054 class Collision;
00055 class SpaceDivision;
00056 class SpaceDivisionObject;
00057 class CollisionObjectCachedPolyData;
00058 class PhysicsSolver;
00059 class SurfaceAttribute;
00060 class CollisionGroupMgr;
00061 class CollisionGroup;
00062 struct DynamicObjectPair;
00063 struct Globals;
00064 
00065 class TAPHYSICS_CLASS Physics
00066 {
00067 public:
00068     //pl.BeginExportClass(Physics)
00069     TA_OBFUSCATION_RESERVED_ON
00070 
00071     enum Flags
00072     {
00073         FLAG_DYNAMIC_OBJECTS =          0x1,
00074         FLAG_STATIC_OBJECTS =           0x2,
00075 
00076         FLAG_ALL_OBJECTS = FLAG_DYNAMIC_OBJECTS | FLAG_STATIC_OBJECTS, //pl. pascal($1 + $2;)
00077         FLAG_ALL_NON_DYNAMIC_OBJECTS = FLAG_STATIC_OBJECTS, //pl. pascal($2;)
00078 
00079         FLAG_GHOST_OBJECTS =            0x8,
00080         FLAG_RENDER_COLLISIONS =        0x10,
00081 
00082         FLAG_SPACIAL_DIVISION_MASK =    0x20 + 0x40 + 0x80, 
00083         FLAG_XY_COLLISION_GRID =        0x20,
00084         FLAG_XZ_COLLISION_GRID =        0x40,
00085         FLAG_YZ_COLLISION_GRID =        0x60,
00086         FLAG_DYNAMIC_OCTREE =           0x80,
00087     };
00088 
00089     enum SpacialDivisionType
00090     {
00091         SPACIAL_DIVISION_TYPE_DYNAMIC_OCTREE = 0,
00092         SPACIAL_DIVISION_TYPE_XY_COLLISION_GRID = 1,
00093         SPACIAL_DIVISION_TYPE_XZ_COLLISION_GRID = 2,
00094         SPACIAL_DIVISION_TYPE_YZ_COLLISION_GRID = 3,
00095     };
00096     
00097 #ifndef TA_WRAPPER  
00098     typedef bool (TA_CALL_BACK *DynamicVsDynamicCollisionTestCallBack)(DynamicObject& objectA, DynamicObject& objectB);
00099     typedef bool (TA_CALL_BACK *PreProcessCollisionCallBack)(PreCollision& collision);
00100     typedef void (TA_CALL_BACK *PostProcessCollisionCallBack)(PostCollision& collision);
00101     typedef void (TA_CALL_BACK *OnBrokenJointCallBack)(PhysicsJoint& joint);
00102     typedef bool (TA_CALL_BACK *CollisionCallBack)(const Collision& collision, void* pUserData);
00103 #endif // TA_WRAPPER
00104 
00106 
00107     static void TAC_CALL CreateInstance();
00108     static void TAC_CALL DestroyInstance();
00109     static Physics& TAC_CALL GetInstance();
00110     void SetupSimulation();
00112 
00114 
00115     
00116     void Update(float fDt);
00117     void Render();
00119 
00120     // todo: make a static object class
00121     
00123 
00124     void AddStaticObject(StaticObject* pStaticObject);
00125     void RemoveStaticObject(StaticObject* pStaticObject);
00127 
00129 
00130     int AddSurfaceAttribute(SurfaceAttribute* pSurfaceAttribute);
00131     int AddSurfaceAttribute();
00132     void RemoveSurfaceAttribute(int nIndex);
00133     SurfaceAttribute& GetSurfaceAttribute(int nIndex);
00134     int GetNumSurfaceAttributes();
00135     void SetDefaultSurfaceAttribute(SurfaceAttribute* pSurfaceAttribute);
00136     const SurfaceAttribute& GetDefaultSurfaceAttribute();
00138 
00140 
00141     void AddDynamicObject(DynamicObject* pDynamicObject, bool bInitiallyMoving = true);
00142     void RemoveDynamicObject(DynamicObject* pDynamicObject);
00143 
00144     void SetDynamicObjectIsMoving(DynamicObject* pDynamicObject);
00145     void SetDynamicObjectAtRest(DynamicObject* pDynamicObject);
00147 
00149 
00150     void TestLineForCollision(
00151         const Vec3& v3Start,
00152         const Vec3& v3Normal,
00153         float fLength,
00154         Collision& collision,
00155         u32 nFlags);
00156 
00157     void TestLineForCollision(
00158         const Vec3& v3Start,
00159         const Vec3& v3End,
00160         Collision& collision,
00161         u32 nFlags = FLAG_ALL_OBJECTS);
00162 
00163 #ifndef TA_WRAPPER  
00164     Collision TestLineForCollision(
00165         const Vec3& v3Start,
00166         const Vec3& v3Normal,
00167         float fLength,
00168         u32 nFlags);
00169 
00170     Collision TestLineForCollision(
00171         const Vec3& v3Start,
00172         const Vec3& v3End,
00173         u32 nFlags = FLAG_ALL_OBJECTS);
00174 #endif // TA_WRAPPER
00175 
00176 
00178 
00179     const Vec3& GetGravity() const;
00180     void SetGravity(const Vec3& v3Gravity);
00181     void SetRenderCollisionsEnabled(bool bValue);
00183 
00185 
00186     void SetWorldDimensions(const AABB& worldAABB); 
00187     const AABB& GetWorldDimensions();   
00188     void SetMaxNumCollisions(int nMaxNumCollisions);
00189     int GetMaxNumCollisions();
00190     void SetMaxNumMovingObjects(int nMaxNumMovingObjects);
00191     int GetMaxNumMovingObjects();
00192     void SetSlowSolverMaxNumCollisions(int nSlowSolverMaxNumCollisions);
00193     int GetSlowSolverMaxNumCollisions();
00194     void SetSlowSolverMaxNumObjects(int nSlowSolverMaxNumObjects);
00195     int GetSlowSolverMaxNumObjects();
00196     void SetMaxNumObjectPairs(int nMaxNumObjectPairs);
00197     int GetMaxNumObjectPairs();
00198 #ifdef TA_WRAPPER   
00199     void SetSpacialDivisionType(int eSpacialDivisionType);
00200     int GetSpacialDivisionType();
00201 #endif
00202 #ifndef TA_WRAPPER  
00203     void SetSpacialDivisionType(SpacialDivisionType eSpacialDivisionType);
00204     SpacialDivisionType GetSpacialDivisionType();
00205 #ifndef DOXYGEN
00206     void SetSpacialDivisionType(int nSpacialDivisionType);
00207 #endif
00208 #endif
00209     void SetSpacialDivisionMinSize(float fSpacialDivisionMinSize);
00210     float GetSpacialDivisionMinSize();
00211     void SetSpacialDivisionMaxMemory(int nSpacialDivisionMaxMemory);
00212     int GetSpacialDivisionMaxMemory();
00214 
00216 
00217     DynamicVsDynamicCollisionTestCallBack GetDynamicVsDynamicCollisionTestCallBack() const;
00218     void SetDynamicVsDynamicCollisionTestCallBack(DynamicVsDynamicCollisionTestCallBack pFnDynamicVsDynamicCollisionTest);
00219     PreProcessCollisionCallBack GetPreProcessCollisionCallBack() const;
00220     void SetPreProcessCollisionCallBack(PreProcessCollisionCallBack pFnPreProcessCollision);
00221     PostProcessCollisionCallBack GetPostProcessCollisionCallBack() const;
00222     void SetPostProcessCollisionCallBack(PostProcessCollisionCallBack pFnPostProcessCollision);
00224 
00226 
00227 #ifndef TA_WRAPPER  
00228     OnBrokenJointCallBack GetOnBrokenJointCallBack() const;
00229     void SetOnBrokenJointCallBack(OnBrokenJointCallBack pFnOnBrokenJoint);
00230 #endif // TA_WRAPPER
00231 
00232 
00233 #ifdef TA_PHYSICS_INTERNAL  
00234     TA_OBFUSCATION_RESERVED_OFF
00235     void AddDynamicObjectToMovingList(DynamicObject* pDynamicObject);
00236     CollisionObjectCachedPolyData& GetCachedPolyData() { TA_ASSERT(m_pCachedPolyData); return *m_pCachedPolyData; }
00237     void UpdateCollisionGridLocation(DynamicObject* pDynamicObject);
00238     CollisionGroupMgr& GetCollisionGroupMgr() { TA_ASSERT(m_pCollisionGroupMgr); return *m_pCollisionGroupMgr; }
00239     CollisionGroupMgr* GetCollisionGroupMgrPtr() { return m_pCollisionGroupMgr; }
00240     Globals& GetGlobals() { TA_ASSERT(m_pGlobals); return *m_pGlobals; }
00241     bool CheckThatParametersAreUpdated();
00242     TA_OBFUSCATION_RESERVED_ON
00243 #endif // TA_PHYSICS_INTERNAL
00244 
00245 #ifndef TA_REMOVE_DEPRECATED
00246 
00247 
00248     static void TAC_CALL CreateInstance(
00249         const AABB& worldAABB,
00250         const Vec3& v3Gravity = Vec3(0.0f, -9.81f, 0.0f),
00251         u32 nFlags = FLAG_XZ_COLLISION_GRID,
00252         float fMinSpacialDivision = 10.0f,
00253         int nSpacialDivisionMemory = 0x40000);
00255 #endif // TA_REMOVE_DEPRECATED
00256 
00257     //pl.EndExportClass(DynamicObject)
00258 
00259 
00260     TA_OBFUSCATION_RESERVED_OFF
00261 private:    
00262     enum InternalFlags
00263     {
00264         FLAG_MEMORY_MGR_LOCKED =            0x10000,
00265         FLAG_DELAY_ADD_TO_MOVING_LIST =     0x20000,
00266         FLAG_SIMULATION_INITIALISED =       0x40000,
00267         FLAG_SETUP_PROPERTIES_CHANGED =     0x80000,
00268         FLAG_SIMULATION_SETUP =             0x100000,
00269     };
00270     struct HeapSortItem;
00271 
00272     struct SetupProperties
00273     {
00274         AABB worldAABB;
00275         int nMaxNumMovingObjects;
00276         int nMaxNumCollisions;
00277         int nSlowSolverMaxNumObjects;
00278         int nSlowSolverMaxNumCollisions;
00279         int nMaxNumObjectPairs;
00280         SpacialDivisionType eSpacialDivisionType;
00281         float fSpacialDivisionMinSize;
00282         int nSpacialDivisionMaxMemory;
00283     };
00284 
00285     typedef List<StaticObject*>::Iterator StaticObjectIterator;
00286     typedef List<DynamicObject*>::Iterator DynamicObjectIterator;
00287     typedef Pool<DynamicObject*>::ActiveListHeadAndTail::Iterator MovingObjectIterator;
00288 
00289     Vec3 m_v3Gravity;
00290     float m_fGravityMagnitude;  
00291     float m_fPhysicsSolverMassMult;
00292     u32 m_nFlags;
00293     u32 m_nFrameCounter;
00294 
00295     Globals* m_pGlobals;
00296     PhysicsSolver* m_pPhysicsSolver;
00297     SpaceDivision* m_pSpaceDivision;
00298     CollisionGroupMgr* m_pCollisionGroupMgr;
00299     DynamicObject* m_pWorldDynamicObject;
00300     List<DynamicObject*> m_physicsObjectList;
00301     List<StaticObject*> m_staticObjectList;
00302     Pool<DynamicObject*> m_movingObjectPool;
00303     Pool<DynamicObject*>::ActiveListHeadAndTail m_movingObjectActiveList;
00304     Pool<DynamicObject*>::ActiveListHeadAndTail m_newlyAddedToMovingList;
00305     CollisionObjectCachedPolyData* m_pCachedPolyData;
00306     SurfaceAttribute m_surfaceAttribute;
00307     Array<SurfaceAttribute> m_surfaceAttributeArray;
00308     DynamicVsDynamicCollisionTestCallBack m_pFnDynamicVsDynamicCollisionTest;
00309     PreProcessCollisionCallBack m_pFnPreProcessCollision;
00310     PostProcessCollisionCallBack m_pFnPostProcessCollision;
00311     OnBrokenJointCallBack m_pFnOnBrokenJoint;
00312     SetupProperties m_setupProperties;
00313     SetupProperties m_oldProperties;
00314     
00315     void (TAC_CALL *m_pfnDoCollision)(float fSeparatingSpeed, Collision& collision);
00316     void (TAC_CALL *m_pfnDoCollisionPropagated)(float fSeparatingSpeed, float fScale, float fFrictionScale, Collision& collision);
00317     bool (TAC_CALL *m_pfnDoFriction)(float fImpulse, Collision& collision);
00318     void (TAC_CALL *m_pfnDoFrictionPropagated)(float fSeparatingSpeed, float fScale, Collision& collision);
00319     float (TAC_CALL *m_pfnCalculateSeparatingSpeed)(float fDt, Collision& collision);
00320 
00321     static Physics* s_pPhysics;
00322     
00323     Physics();
00324     ~Physics();
00325 
00326     void Initialise();
00327     void Initialise(
00328         const AABB& worldAABB,
00329         const Vec3& v3Gravity,
00330         u32 nFlags,
00331         float fMinSpacialDivision,
00332         int nSpacialDivisionMemory);
00333     void Finalise();
00334 
00335     void SetupPropertiesChanged();
00336 
00337     void PreUpdateObjects(float fDt);
00338     void FindCollisions(float fDt, int nPass);
00339     void DoJointCollisions(DynamicObject& physicsObject);
00340     void DoJointCollision(PhysicsJoint& joint);
00341     void BuildMatrix(CollisionGroup& collisionGroup);
00342     void PreCalculateSeparatingSpeed(float fDt, Collision& collision);
00343     void CalculateSeparatingSpeeds(float fDt, CollisionGroup& collisionGroup, int nPass);
00344     float CalculateSeparatingSpeed(float fDt, Collision& collision) { TA_ASSERT(m_pfnCalculateSeparatingSpeed); return m_pfnCalculateSeparatingSpeed(fDt, collision); }
00345     bool SolveMatrix();
00346     void ReuseMatrix();
00347     void ApplySeparatingImpulses(CollisionGroup& collisionGroup);
00348     void FudgeFriction(CollisionGroup& collisionGroup);
00349     void CheckRestConditions(float fDt, CollisionGroup& collisionGroup);
00350     void PostUpdateGroupedObjects(float fDt, bool bUpdateNextFrame, CollisionGroup& collisionGroup);
00351     void PostConstrainJoint(PhysicsJoint& physicsJoint, bool bPropagateForward, float fInterpolation);
00352     void PostUpdateUnGroupedObjects(float fDt, bool bUpdateNextFrame);
00353 
00354     void InitialiseSortedList(CollisionGroup&, HeapSortItem*, int);
00355     void CreatePropagationLists(CollisionGroup&, DynamicObject**, int&, int, Collision**, int&, int);
00356     void PropagateCollisionsUsingPropagationList(DynamicObject**, int, Collision**,int);
00357     void PropagateSolidCollisionsUsingPropagationList(CollisionGroup&, DynamicObject**, int, Collision**, int); 
00358     void PropagateCollisionsBySortedList(HeapSortItem*, int, int, const Vec3&);
00359     void PropagateSolidCollisionsBySortedList(HeapSortItem*, int, int, const Vec3&);
00360     void PropagateFriction(CollisionGroup&, DynamicObject**, int, Collision**, int);    
00361     void PropagateJoints(HeapSortItem*, int, int, const Vec3&);
00362     void PostProcessCollisions();
00363     
00364     void DoCollision(float fSeparatingSpeed, Collision& collision) { TA_ASSERT(m_pfnDoCollision); m_pfnDoCollision(fSeparatingSpeed, collision); }
00365     void TAC_CALL DoCollisionPropagated(float fSeparatingSpeed, float fScale, float fFrictionScale, Collision& collision) { TA_ASSERT(m_pfnDoCollisionPropagated); m_pfnDoCollisionPropagated(fSeparatingSpeed, fScale, fFrictionScale, collision); }
00366     bool TAC_CALL DoFriction(float fImpulse, Collision& collision) { TA_ASSERT(m_pfnDoFriction); return m_pfnDoFriction(fImpulse, collision); }
00367     void TAC_CALL DoFrictionPropagated(float fSeparatingSpeed, float fScale, Collision& collision) { TA_ASSERT(m_pfnDoFrictionPropagated); m_pfnDoFrictionPropagated(fSeparatingSpeed, fScale, collision); }
00368 
00369     bool CanAddToMovingList(DynamicObject* pDynamicObject);
00370 
00371     void OnFrameCounterWrapped();
00372     
00373     static bool TAC_CALL NewCollision(Collision& collisionResult, void* pData);
00374     static void TAC_CALL OnPotentialObjectObjectCollision(SpaceDivisionObject& object, void* pData);
00375     void OnPairObjectObjectCollision(DynamicObjectPair& pair);
00376     static void TAC_CALL OnPotentialTestLineCollision(SpaceDivisionObject& object, void* pData);
00377 };
00378 
00379 inline Physics& TAC_CALL Physics::GetInstance() { TA_ASSERT_MSG(s_pPhysics, "Physics::GetInstance. Instance not created."); return *s_pPhysics; }
00380 inline const Vec3& Physics::GetGravity() const { return m_v3Gravity; }
00381 inline void Physics::SetRenderCollisionsEnabled(bool bValue) { if (bValue) m_nFlags |= FLAG_RENDER_COLLISIONS; else m_nFlags &= ~FLAG_RENDER_COLLISIONS; }
00382 inline Physics::DynamicVsDynamicCollisionTestCallBack Physics::GetDynamicVsDynamicCollisionTestCallBack() const { return m_pFnDynamicVsDynamicCollisionTest; }
00383 inline void Physics::SetDynamicVsDynamicCollisionTestCallBack(DynamicVsDynamicCollisionTestCallBack pFnDynamicVsDynamicCollisionTest) { m_pFnDynamicVsDynamicCollisionTest= pFnDynamicVsDynamicCollisionTest; }
00384 inline Physics::PreProcessCollisionCallBack Physics::GetPreProcessCollisionCallBack() const { return m_pFnPreProcessCollision; }
00385 inline void Physics::SetPreProcessCollisionCallBack(PreProcessCollisionCallBack pFnPreProcessCollision) { m_pFnPreProcessCollision = pFnPreProcessCollision; }
00386 inline Physics::PostProcessCollisionCallBack Physics::GetPostProcessCollisionCallBack() const { return m_pFnPostProcessCollision; }
00387 inline void Physics::SetPostProcessCollisionCallBack(PostProcessCollisionCallBack pFnPostProcessCollision) { m_pFnPostProcessCollision = pFnPostProcessCollision; }
00388 inline Physics::OnBrokenJointCallBack Physics::GetOnBrokenJointCallBack() const { return m_pFnOnBrokenJoint; }
00389 inline void Physics::SetOnBrokenJointCallBack(OnBrokenJointCallBack pFnOnBrokenJoint) { m_pFnOnBrokenJoint = pFnOnBrokenJoint; }
00390 inline void Physics::SetSpacialDivisionType(int nSpacialDivisionType) { SetSpacialDivisionType((SpacialDivisionType)nSpacialDivisionType); }
00391 
00392 void TAC_CALL Physics_CreateInstance(
00393     const AABB& worldAABB,
00394     const Vec3& v3Gravity = Vec3(0.0f, -9.81f, 0.0f),
00395     u32 nFlags = Physics::FLAG_XZ_COLLISION_GRID,
00396     float fMinSpacialDivision = 10.0f,
00397     int nSpacialDivisionMemory = 0x40000);
00398 
00399 }
00400 
00401 #endif // TA_PHYSICS_H