Back to index

supertuxkart  0.5+dfsg1
Defines | Typedefs | Functions | Variables
btPersistentManifold.h File Reference
#include "LinearMath/btVector3.h"
#include "LinearMath/btTransform.h"
#include "btManifoldPoint.h"
#include "LinearMath/btAlignedAllocator.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define MANIFOLD_CACHE_SIZE   4
#define MAINTAIN_PERSISTENCY   1

Typedefs

typedef bool(* ContactDestroyedCallback )(void *userPersistentData)
typedef bool(* ContactProcessedCallback )(btManifoldPoint &cp, void *body0, void *body1)

Functions

 ATTRIBUTE_ALIGNED16 (class) btPersistentManifold
 btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase. Those contact points are created by the collision narrow phase. The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time. updates/refreshes old contact points, and throw them away if necessary (distance becomes too large) reduces the cache to 4 points, when more then 4 points are added, using following rules: the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points note that some pairs of objects might have more then one contact manifold.

Variables

btScalar gContactBreakingThreshold
 contact breaking and merging threshold
ContactDestroyedCallback gContactDestroyedCallback

Define Documentation

#define MAINTAIN_PERSISTENCY   1
#define MANIFOLD_CACHE_SIZE   4

Definition at line 37 of file btPersistentManifold.h.


Typedef Documentation

typedef bool(* ContactDestroyedCallback)(void *userPersistentData)

Definition at line 30 of file btPersistentManifold.h.

typedef bool(* ContactProcessedCallback)(btManifoldPoint &cp, void *body0, void *body1)

Definition at line 31 of file btPersistentManifold.h.


Function Documentation

ATTRIBUTE_ALIGNED16 ( class  )

btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase. Those contact points are created by the collision narrow phase. The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time. updates/refreshes old contact points, and throw them away if necessary (distance becomes too large) reduces the cache to 4 points, when more then 4 points are added, using following rules: the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points note that some pairs of objects might have more then one contact manifold.

this two body pointers can point to the physics rigidbody class. void* will allow any rigidbody class

sort cached points so most isolated points come first

todo: get this margin from the current physics / collision environment

calculated new worldspace coordinates and depth, and reject points that exceed the collision margin

Definition at line 46 of file btPersistentManifold.h.

{

       btManifoldPoint m_pointCache[MANIFOLD_CACHE_SIZE];

       void* m_body0;
       void* m_body1;
       int    m_cachedPoints;

       
       int    sortCachedPoints(const btManifoldPoint& pt);

       int           findContactPoint(const btManifoldPoint* unUsed, int numUnused,const btManifoldPoint& pt);

public:

       BT_DECLARE_ALIGNED_ALLOCATOR();

       int m_index1a;

       btPersistentManifold();

       btPersistentManifold(void* body0,void* body1,int bla)
              : m_body0(body0),m_body1(body1),m_cachedPoints(0)
       {
              (void)bla;
       }

       SIMD_FORCE_INLINE void* getBody0() { return m_body0;}
       SIMD_FORCE_INLINE void* getBody1() { return m_body1;}

       SIMD_FORCE_INLINE const void* getBody0() const { return m_body0;}
       SIMD_FORCE_INLINE const void* getBody1() const { return m_body1;}

       void   setBodies(void* body0,void* body1)
       {
              m_body0 = body0;
              m_body1 = body1;
       }

       void clearUserCache(btManifoldPoint& pt);

#ifdef DEBUG_PERSISTENCY
       void   DebugPersistency();
#endif //
       
       SIMD_FORCE_INLINE int       getNumContacts() const { return m_cachedPoints;}

       SIMD_FORCE_INLINE const btManifoldPoint& getContactPoint(int index) const
       {
              btAssert(index < m_cachedPoints);
              return m_pointCache[index];
       }

       SIMD_FORCE_INLINE btManifoldPoint& getContactPoint(int index)
       {
              btAssert(index < m_cachedPoints);
              return m_pointCache[index];
       }

       btScalar      getContactBreakingThreshold() const;
       
       int getCacheEntry(const btManifoldPoint& newPoint) const;

       void AddManifoldPoint( const btManifoldPoint& newPoint);

       void removeContactPoint (int index)
       {
              clearUserCache(m_pointCache[index]);

              int lastUsedIndex = getNumContacts() - 1;
//            m_pointCache[index] = m_pointCache[lastUsedIndex];
              if(index != lastUsedIndex) 
              {
                     m_pointCache[index] = m_pointCache[lastUsedIndex]; 
                     //get rid of duplicated userPersistentData pointer
                     m_pointCache[lastUsedIndex].m_userPersistentData = 0;
                     m_pointCache[lastUsedIndex].m_appliedImpulse = 0.f;
                     m_pointCache[lastUsedIndex].m_lifeTime = 0;
              }

              btAssert(m_pointCache[lastUsedIndex].m_userPersistentData==0);
              m_cachedPoints--;
       }
       void replaceContactPoint(const btManifoldPoint& newPoint,int insertIndex)
       {
              btAssert(validContactDistance(newPoint));

#define MAINTAIN_PERSISTENCY 1
#ifdef MAINTAIN_PERSISTENCY
              int    lifeTime = m_pointCache[insertIndex].getLifeTime();
              btScalar      appliedImpulse = 0.f;//m_pointCache[insertIndex].m_appliedImpulse;
              btAssert(lifeTime>=0);
              void* cache = m_pointCache[insertIndex].m_userPersistentData;
              
              m_pointCache[insertIndex] = newPoint;

              m_pointCache[insertIndex].m_userPersistentData = cache;
              m_pointCache[insertIndex].m_appliedImpulse = appliedImpulse;
              m_pointCache[insertIndex].m_lifeTime = lifeTime;
#else
              clearUserCache(m_pointCache[insertIndex]);
              m_pointCache[insertIndex] = newPoint;
       
#endif
       }

       bool validContactDistance(const btManifoldPoint& pt) const
       {
              return pt.m_distance1 <= getContactBreakingThreshold();
       }
       void   refreshContactPoints(  const btTransform& trA,const btTransform& trB);

       
       SIMD_FORCE_INLINE    void   clearManifold()
       {
              int i;
              for (i=0;i<m_cachedPoints;i++)
              {
                     clearUserCache(m_pointCache[i]);
              }
              m_cachedPoints = 0;
       }



}

Here is the call graph for this function:


Variable Documentation

contact breaking and merging threshold

Definition at line 21 of file btPersistentManifold.cpp.

Definition at line 22 of file btPersistentManifold.cpp.