btManifoldResult.h

Go to the documentation of this file.
00001 /*
00002 Bullet Continuous Collision Detection and Physics Library
00003 Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
00004 
00005 This software is provided 'as-is', without any express or implied warranty.
00006 In no event will the authors be held liable for any damages arising from the use of this software.
00007 Permission is granted to anyone to use this software for any purpose, 
00008 including commercial applications, and to alter it and redistribute it freely, 
00009 subject to the following restrictions:
00010 
00011 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
00012 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
00013 3. This notice may not be removed or altered from any source distribution.
00014 */
00015 
00016 
00017 #ifndef BT_MANIFOLD_RESULT_H
00018 #define BT_MANIFOLD_RESULT_H
00019 
00020 class btCollisionObject;
00021 struct btCollisionObjectWrapper;
00022 
00023 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
00024 class btManifoldPoint;
00025 
00026 #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
00027 
00028 #include "LinearMath/btTransform.h"
00029 #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
00030 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
00031 
00032 typedef bool (*ContactAddedCallback)(btManifoldPoint& cp,       const btCollisionObjectWrapper* colObj0Wrap,int partId0,int index0,const btCollisionObjectWrapper* colObj1Wrap,int partId1,int index1);
00033 extern ContactAddedCallback             gContactAddedCallback;
00034 
00035 //#define DEBUG_PART_INDEX 1
00036 
00037 
00039 class btManifoldResult : public btDiscreteCollisionDetectorInterface::Result
00040 {
00041 protected:
00042 
00043         btPersistentManifold* m_manifoldPtr;
00044 
00045         const btCollisionObjectWrapper* m_body0Wrap;
00046         const btCollisionObjectWrapper* m_body1Wrap;
00047         int     m_partId0;
00048         int m_partId1;
00049         int m_index0;
00050         int m_index1;
00051         
00052 
00053 public:
00054 
00055         btManifoldResult()
00056 #ifdef DEBUG_PART_INDEX
00057                 :
00058         m_partId0(-1),
00059         m_partId1(-1),
00060         m_index0(-1),
00061         m_index1(-1)
00062 #endif //DEBUG_PART_INDEX
00063         {
00064         }
00065 
00066         btManifoldResult(const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap);
00067 
00068         virtual ~btManifoldResult() {};
00069 
00070         void    setPersistentManifold(btPersistentManifold* manifoldPtr)
00071         {
00072                 m_manifoldPtr = manifoldPtr;
00073         }
00074 
00075         const btPersistentManifold*     getPersistentManifold() const
00076         {
00077                 return m_manifoldPtr;
00078         }
00079         btPersistentManifold*   getPersistentManifold()
00080         {
00081                 return m_manifoldPtr;
00082         }
00083 
00084         virtual void setShapeIdentifiersA(int partId0,int index0)
00085         {
00086                 m_partId0=partId0;
00087                 m_index0=index0;
00088         }
00089 
00090         virtual void setShapeIdentifiersB(      int partId1,int index1)
00091         {
00092                 m_partId1=partId1;
00093                 m_index1=index1;
00094         }
00095 
00096 
00097         virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth);
00098 
00099         SIMD_FORCE_INLINE       void refreshContactPoints()
00100         {
00101                 btAssert(m_manifoldPtr);
00102                 if (!m_manifoldPtr->getNumContacts())
00103                         return;
00104 
00105                 bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
00106 
00107                 if (isSwapped)
00108                 {
00109                         m_manifoldPtr->refreshContactPoints(m_body1Wrap->getCollisionObject()->getWorldTransform(),m_body0Wrap->getCollisionObject()->getWorldTransform());
00110                 } else
00111                 {
00112                         m_manifoldPtr->refreshContactPoints(m_body0Wrap->getCollisionObject()->getWorldTransform(),m_body1Wrap->getCollisionObject()->getWorldTransform());
00113                 }
00114         }
00115 
00116         const btCollisionObjectWrapper* getBody0Wrap() const
00117         {
00118                 return m_body0Wrap;
00119         }
00120         const btCollisionObjectWrapper* getBody1Wrap() const
00121         {
00122                 return m_body1Wrap;
00123         }
00124 
00125         void setBody0Wrap(const btCollisionObjectWrapper* obj0Wrap)
00126         {
00127                 m_body0Wrap = obj0Wrap;
00128         }
00129 
00130         void setBody1Wrap(const btCollisionObjectWrapper* obj1Wrap)
00131         {
00132                 m_body1Wrap = obj1Wrap;
00133         }
00134 
00135         const btCollisionObject* getBody0Internal() const
00136         {
00137                 return m_body0Wrap->getCollisionObject();
00138         }
00139 
00140         const btCollisionObject* getBody1Internal() const
00141         {
00142                 return m_body1Wrap->getCollisionObject();
00143         }
00144 
00146         static btScalar calculateCombinedRestitution(const btCollisionObject* body0,const btCollisionObject* body1);
00147         static btScalar calculateCombinedFriction(const btCollisionObject* body0,const btCollisionObject* body1);
00148 };
00149 
00150 #endif //BT_MANIFOLD_RESULT_H