00001 //---------------------------------------------------------------------------------
00002 // File Name: Collision.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_COLLISION_H
00015 #define TA_COLLISION_H
00016 
00017 #ifndef TA_MFRAME_H
00018 #include "../Common/MFrame.h"
00019 #endif // TA_MFRAME_H
00020 
00021 TA_OBFUSCATION_SKIP_PASS_2
00022 
00023 namespace TA
00024 {
00025 
00026 class DynamicObject;
00027 class StaticObject;
00028 class CollisionObject;
00029 class PhysicsJoint;
00030     
00031 //---------------------------------------------------------------------------------
00032 //---------------------------------------------------------------------------------
00033 class Collision
00034 {
00035 public:
00036 #ifndef DOXYGEN
00037     enum Type
00038     {
00039         TYPE_NORMAL =                            0x100000,
00040         TYPE_JOINT =                             0x200000,
00041         TYPE_JOINT_LIMIT =                       0x300000,
00042         TYPE_ROTATION_CONSTRAINT =               0x400000,
00043         TYPE_ROTATION_CONSTRAINT_BOTH_WAYS =     0x500000,
00044         TYPE_LINE_INTERSECTION =                 0x600000,
00045         TYPE_NONE =                              0x700000,
00046         TYPE_MASK =                              0x700000,
00047     };
00048 #endif // DOXYGEN
00049 
00050     TA_OBFUSCATION_RESERVED_ON
00051     //pl.BeginExportClass(Collision)
00052 
00053     enum Flag
00054     {
00055         FLAG_CONSTRAIN_IN_BOTH_DIRECTIONS =     0x1,
00056         FLAG_FRICTION =                         0x2,
00057         FLAG_FRICTION_GENERATING_IMPULSE =      0x4,
00058         FLAG_NO_FRICTION =                      0x8,
00059         FLAG_JOINT =                            0x10,
00060         FLAG_JOINT_LIMIT =                      0x20,
00061         FLAG_COLLISION_OCCURRED =               0x40,
00062         FLAG_DISABLE_PUSHOUT =                  0x80,
00063         FLAG_MARKED =                           0x200,
00064         FLAG_RESTITUTION_CALCULATED =           0x400,
00065         FLAG_OBJECTA_SOLID =                    0x1000,
00066         FLAG_OBJECTB_SOLID =                    0x2000,
00067         FLAG_NEW_COLLISION =                    0x4000,
00068         FLAG_ROTATION_CONSTRAINT =              0x8000,
00069         FLAG_OBJECTB_INFINITE_MASS =            0x10000,
00070         FLAG_DEPTH_CALCULATED_FROM_TIME =       0x20000,
00071         FLAG_USE_PUSH_OUT_MODIFIER =            0x40000,
00072     };
00073 
00074 #ifndef TA_WRAPPER  
00075     Collision();
00076 #endif // TA_WRAPPER    
00077     void Clear();
00078     void Initialise(
00079         DynamicObject* pNewObjectA,
00080         DynamicObject* pNewObjectB,
00081         float fNewTime,
00082         float fNewIntersectingDepth,
00083         const Vec3& v3NewPosition,
00084         const Vec3& v3NewNormal);
00085     
00086 #ifndef DOXYGEN
00087 #ifndef TA_WRAPPER
00088     inline void Initialise(
00089         Type eNewType,
00090         float fNewTime,
00091         float fNewIntersectingDepth,
00092         const Vec3& v3NewPosition,
00093         const Vec3& v3NewNormal,
00094         PhysicsJoint* pJoint = 0);
00095 #endif // TA_WRAPPER
00096 #endif // DOXYGEN
00097 
00098     const Vec3& GetPosition() const;
00099     void SetPosition(const Vec3& v3Position);
00100     const Vec3& GetNormal() const;
00101     void SetNormal(const Vec3& v3Normal);
00102     
00103     DynamicObject* GetObjectA() const;
00104     DynamicObject* GetObjectB() const;
00105     void SetObjectA(DynamicObject* pDynamicObject);
00106     void SetObjectB(DynamicObject* pDynamicObject);
00107 
00108     CollisionObject* GetCollisionObjectA();
00109     CollisionObject* GetCollisionObjectB();
00110     const CollisionObject* GetCollisionObjectA() const;
00111     const CollisionObject* GetCollisionObjectB() const;
00112     void SetCollisionObjectA(CollisionObject* pCollisionObjectA);
00113     void SetCollisionObjectB(CollisionObject* pCollisionObjectB);
00114 
00115     int GetFlags() const;
00116     void SetFlags(u32 nFlags);
00117     u32& Flags();
00118     float GetRestitution() const;
00119     void SetRestitution(float fRestitution);
00120     float GetImpulse() const;
00121     void SetImpulse(float fImpulse);
00122     float GetFrictionCoefficient() const;
00123     void SetFrictionCoefficient(float fFrictionCoefficient);
00124     float GetTime() const;
00125     void SetTime(float fTime);
00126     float GetIntersectingDepth() const;
00127     void SetIntersectingDepth(float fIntersectingDepth);
00128     u32 GetCollisionIdA() const;
00129     void SetCollisionIdA(u32 nCollisionIdA);
00130     u32 GetCollisionIdB() const;
00131     void SetCollisionIdB(u32 nCollisionIdB);
00132     u32 GetAttributeA() const;
00133     void SetAttributeA(u32 nAttributeA);
00134     u32 GetAttributeB() const;
00135     void SetAttributeB(u32 nAttributeB);
00136 
00137     
00138     PhysicsJoint* GetJoint();
00139     const PhysicsJoint* GetJoint() const;
00140 
00141     bool CollisionOccurred() const;
00142     Collision* GetNext();
00143 
00144     //pl.EndExportClass(Collision)
00145     TA_OBFUSCATION_RESERVED_OFF
00146     
00147 
00148 #ifdef TA_PHYSICS_INTERNAL
00149 
00150     void SetNext(Collision* pNewNext) { pNext = pNewNext; }
00151 
00152     u32 GetType() { return nFlags & TYPE_MASK; }
00153     void SetType(u32 nType) { nFlags &= ~TYPE_MASK; nFlags |= (nType & TYPE_MASK); }
00154 
00155     //---------------------------------------------------------------------------------
00156     //---------------------------------------------------------------------------------
00157     DynamicObject* Collision::GetObjectBForSolve() 
00158     { 
00159         if ((nFlags & (FLAG_OBJECTB_SOLID | FLAG_OBJECTB_INFINITE_MASS)) == 0)
00160             return pObjectB;
00161         else
00162             return 0;
00163     }
00164 
00165     //---------------------------------------------------------------------------------
00166     //---------------------------------------------------------------------------------
00167     inline void Collision::SwapObjects()
00168     {
00169         TA_ASSERT(GetObjectBForSolve());
00170         Swap(pObjectA, pObjectB);
00171         v3Normal = -v3Normal;
00172         Swap(nAttributeA, nAttributeB);
00173         Swap(pCollisionObjectA, pCollisionObjectB);
00174 
00175     #ifdef _DEBUG
00176         int nOldFlags = nFlags;
00177     #endif
00178         TA_ASSERT((FLAG_OBJECTB_SOLID >> 1) == FLAG_OBJECTA_SOLID);
00179         const int nMask = (FLAG_OBJECTA_SOLID | FLAG_OBJECTB_SOLID);
00180         int nFlagSwap = nFlags & nMask;
00181         nFlagSwap = (((nFlagSwap << 2) + nFlagSwap) >> 1) & nMask;
00182         nFlags &= ~nMask;
00183         nFlags |= nFlagSwap;
00184     #ifdef _DEBUG
00185         TA_ASSERT(
00186             ((nOldFlags & FLAG_OBJECTB_SOLID) && (nFlags & FLAG_OBJECTA_SOLID)) ||
00187             ((!(nOldFlags & FLAG_OBJECTB_SOLID)) && (!(nFlags & FLAG_OBJECTA_SOLID))));
00188         TA_ASSERT(
00189             ((nOldFlags & FLAG_OBJECTB_SOLID) && (nFlags & FLAG_OBJECTA_SOLID)) ||
00190             ((!(nOldFlags & FLAG_OBJECTB_SOLID)) && (!(nFlags & FLAG_OBJECTA_SOLID))));
00191     #endif
00192     }
00193 #endif // TA_PHYSICS_INTERNAL
00194 
00195 
00196 
00197     TA_OBFUSCATION_RESERVED_OFF
00198     friend void CollisionGroupMgr_Collision_SetNext(Collision* pThis, Collision* pNext);
00199 
00200 #ifndef TA_COLLISION_FRIEND
00201 private:
00202 #endif // TA_COLLISION_FRIEND
00203 
00204     friend class PreCollision;
00205     friend class PostCollision;
00206 
00207     Vec3 v3Position;
00208     Vec3 v3Normal;
00209 
00210     u32 nFlags;
00211     DynamicObject* pObjectA;
00212     DynamicObject* pObjectB;
00213     Collision* pNext;
00214 
00215     float fRestitution;
00216     float fInertiaAtPoint; // working variable for solver
00217     float fSeparatingSpeedModifier;
00218     float fImpulse;
00219 
00220     float fFrictionCoefficient;
00221     float fTime;
00222     float fIntersectingDepth;
00223     u16 nCollisionIdA;
00224     u16 nCollisionIdB;
00225     
00226     Vec3 v3TmpA;
00227     Vec3 v3TmpB;
00228     
00229     CollisionObject* pCollisionObjectA;
00230     CollisionObject* pCollisionObjectB;
00231 
00232     u32 nAttributeA;
00233     u32 nAttributeB;
00234 
00235     Collision* UnConst() const { return (Collision*)this; }
00236 };
00237 
00238 #ifndef DOXYGEN
00239 typedef bool (TAC_CALL *OnCollisionCallback)(Collision& collisionResult, void* pData);
00240 //---------------------------------------------------------------------------------
00241 //---------------------------------------------------------------------------------
00242 struct CollisionCallData
00243 {
00244     //OnCollisionCallback pFnOnCollisionCallback;
00245     //void* pCallBackData;
00246     OnCollisionCallback pFnOnCollisionCallback2;
00247     void* pCallBackData2;
00248     bool bDoSweep;
00249     bool bReversed;
00250     u32 nTemporalData;
00251     CollisionObject* pCollisionObjectA;
00252     CollisionObject* pCollisionObjectB;
00253     MFrame frame;
00254 };
00255 #endif // DOXYGEN
00256 
00257 #define TA_DEFINE_SIMPLE_VS_SIMPLE_COLLISION(FunctionName)          \
00258     void TAC_CALL FunctionName(                                     \
00259         const MFrame& startFrameA,                                  \
00260         const MFrame& endFrameA,                                    \
00261         CollisionCallData* pCollisionCallData);
00262 
00263 #define TA_DEFINE_FRIEND_SIMPLE_VS_SIMPLE_COLLISION(FunctionName)   \
00264     friend TA_DEFINE_SIMPLE_VS_SIMPLE_COLLISION(FunctionName)
00265 
00266 #define TA_DEFINE_SIMPLE_VS_COMPLEX_COLLISION(FunctionName)         \
00267     void TAC_CALL FunctionName(                                     \
00268         const MFrame& startFrameA,                                  \
00269         const MFrame& endFrameA,                                    \
00270         CollisionCallData* pCollisionCallData);
00271 
00272 #define TA_DEFINE_FRIEND_SIMPLE_VS_COMPLEX_COLLISION(FunctionName)  \
00273     friend TA_DEFINE_SIMPLE_VS_SIMPLE_COLLISION(FunctionName)
00274 
00275 //---------------------------------------------------------------------------------
00276 //---------------------------------------------------------------------------------
00277 TA_OBFUSCATION_RESERVED_ON
00278 class PreCollision
00279 {
00280 public:
00281     const DynamicObject* GetObjectA() const;
00282     const DynamicObject* GetObjectB() const;
00283     const CollisionObject* GetCollisionObjectA() const;
00284     const CollisionObject* GetCollisionObjectB() const;
00285     const PhysicsJoint* GetJoint() const;
00286 
00287     PreCollision* GetNext();
00288 
00289     const Vec3& GetPosition() const;
00290     void SetPosition(const Vec3& v3Position);
00291     const Vec3& GetNormal() const;
00292     void SetNormal(const Vec3& v3Normal);
00293 
00294     u32 GetFlags() const;
00295     void SetFlags(u32 nFlags);
00296     
00297     float GetRestitution() const;
00298     void SetRestitution(float fRestitution);
00299     float GetFrictionCoefficient() const;
00300     void SetFrictionCoefficient(float fFrictionCoefficient);
00301 
00302     float GetTime() const;
00303     void SetTime(float fTime);
00304     float GetIntersectingDepth() const;
00305     void SetIntersectingDepth(float fIntersectingDepth);
00306 
00307     u32 GetAttributeA() const;
00308     u32 GetAttributeB() const;
00309 
00310     u32 GetCollisionIdA() const;
00311     u32 GetCollisionIdB() const;
00312 
00313     TA_OBFUSCATION_RESERVED_OFF
00314 private:
00315     friend class Physics;
00316     Collision m_collision;
00317     PreCollision() {};
00318     PreCollision(const PreCollision&) {};
00319 };
00320 
00321 //---------------------------------------------------------------------------------
00322 //---------------------------------------------------------------------------------
00323 TA_OBFUSCATION_RESERVED_ON
00324 class PostCollision
00325 {
00326 public:
00327     DynamicObject* GetObjectA();
00328     DynamicObject* GetObjectB();
00329     CollisionObject* GetCollisionObjectA();
00330     CollisionObject* GetCollisionObjectB();
00331     PhysicsJoint* GetJoint();
00332 
00333 
00334     PostCollision* GetNext();
00335 
00336     const Vec3& GetPosition() const;
00337     const Vec3& GetNormal() const;
00338 
00339     u32 GetFlags() const;
00340 
00341     float GetImpulse() const;
00342     float GetTime() const;
00343     float GetIntersectingDepth() const;
00344 
00345     u32 GetAttributeA() const;
00346     u32 GetAttributeB() const;
00347 
00348     u32 GetCollisionIdA() const;
00349     u32 GetCollisionIdB() const;
00350 
00351     TA_OBFUSCATION_RESERVED_OFF
00352 
00353 private:
00354     friend class Physics;
00355     Collision m_collision;
00356     PostCollision() {};
00357     PostCollision(const PostCollision&) {};
00358 
00359 };
00360 
00361 }
00362 
00363 #include "Collision.inl"
00364 
00365 #endif // TA_COLLISION_H