| Bullet Collision Detection & Physics Library
    | 
 
 
 
Go to the documentation of this file.
   45                 if (numOverlappingPairs)
 
   49                         for (
int i = 0; i < numOverlappingPairs; i++)
 
   55                                 if (((colObj0) && ((colObj0)->mergesSimulationIslands())) &&
 
   56                                         ((colObj1) && ((colObj1)->mergesSimulationIslands())))
 
   59                                                                           (colObj1)->getIslandTag());
 
   66 #ifdef STATIC_SIMULATION_ISLAND_OPTIMIZATION 
  118 #else  //STATIC_SIMULATION_ISLAND_OPTIMIZATION 
  165 #endif  //STATIC_SIMULATION_ISLAND_OPTIMIZATION 
  210         int endIslandIndex = 1;
 
  211         int startIslandIndex;
 
  214         for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex)
 
  217                 for (endIslandIndex = startIslandIndex + 1; (endIslandIndex < numElem) && (
getUnionFind().
getElement(endIslandIndex).m_id == islandId); endIslandIndex++)
 
  223                 bool allSleeping = 
true;
 
  226                 for (idx = startIslandIndex; idx < endIslandIndex; idx++)
 
  251                         for (idx = startIslandIndex; idx < endIslandIndex; idx++)
 
  271                         for (idx = startIslandIndex; idx < endIslandIndex; idx++)
 
  303         for (i = 0; i < maxNumManifolds; i++)
 
  325                         if (colObj1->isKinematicObject() && colObj1->getActivationState() != 
ISLAND_SLEEPING)
 
  327                                 if (colObj1->hasContactResponse())
 
  347         int endIslandIndex = 1;
 
  348         int startIslandIndex;
 
  357                 callback->
processIsland(&collisionObjects[0], collisionObjects.
size(), manifold, maxNumManifolds, -1);
 
  384                 int startManifoldIndex = 0;
 
  385                 int endManifoldIndex = 1;
 
  392                 for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex)
 
  396                         bool islandSleeping = 
true;
 
  398                         for (endIslandIndex = startIslandIndex; (endIslandIndex < numElem) && (
getUnionFind().
getElement(endIslandIndex).m_id == islandId); endIslandIndex++)
 
  404                                         islandSleeping = 
false;
 
  408                         int numIslandManifolds = 0;
 
  411                         if (startManifoldIndex < numManifolds)
 
  414                                 if (curIslandId == islandId)
 
  418                                         for (endManifoldIndex = startManifoldIndex + 1; (endManifoldIndex < numManifolds) && (islandId == 
getIslandId(
m_islandmanifold[endManifoldIndex])); endManifoldIndex++)
 
  422                                         numIslandManifolds = endManifoldIndex - startManifoldIndex;
 
  432                         if (numIslandManifolds)
 
  434                                 startManifoldIndex = endManifoldIndex;
 
  
static void getElement(int arrayLen, const char *cur, const char *old, char *oldPtr, char *curData)
btCollisionObject can be used to manage collision detection objects.
virtual void storeIslandActivationState(btCollisionWorld *world)
#define DISABLE_DEACTIVATION
void findUnions(btDispatcher *dispatcher, btCollisionWorld *colWorld)
virtual btPersistentManifold ** getInternalManifoldPointer()=0
void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
int getIslandId(const btPersistentManifold *lhs)
void quickSort(const L &CompareFunc)
void buildIslands(btDispatcher *dispatcher, btCollisionWorld *colWorld)
const btCollisionObject * getBody0() const
virtual int getNumManifolds() const =0
virtual int getNumOverlappingPairs() const =0
function object that routes calls to operator<
void sortIslands()
this is a special operation, destroying the content of btUnionFind.
int getNumContacts() const
int getActivationState() const
btElement & getElement(int index)
void setHitFraction(btScalar hitFraction)
bool isKinematicObject() const
bool isStaticOrKinematicObject() const
void activate(bool forceActivation=false) const
btAlignedObjectArray< btCollisionObject * > m_islandBodies
void resize(int newsize, const T &fillData=T())
btAlignedObjectArray< btPersistentManifold * > m_islandmanifold
btBroadphaseProxy * m_pProxy1
btOverlappingPairCache * getPairCache()
void initUnionFind(int n)
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
btBroadphaseProxy * getBroadphaseHandle()
bool operator()(const btPersistentManifold *lhs, const btPersistentManifold *rhs) const
virtual btBroadphasePair * getOverlappingPairArrayPtr()=0
void setCompanionId(int id)
void setDeactivationTime(btScalar time)
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
int getNumElements() const
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
btBroadphaseProxy * m_pProxy0
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
bool hasContactResponse() const
bool m_deterministicOverlappingPairs
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
#define SIMD_FORCE_INLINE
bool operator()(const btPersistentManifold *lhs, const btPersistentManifold *rhs) const
virtual ~btSimulationIslandManager()
void setIslandTag(int tag)
btSimulationIslandManager()
#define WANTS_DEACTIVATION
virtual void processIsland(btCollisionObject **bodies, int numBodies, class btPersistentManifold **manifolds, int numManifolds, int islandId)=0
CollisionWorld is interface and container for the collision detection.
const btCollisionObject * getBody1() const
btCollisionObjectArray & getCollisionObjectArray()
btUnionFind & getUnionFind()
void push_back(const T &_Val)
btDispatcherInfo & getDispatchInfo()
The btBroadphasePair class contains a pair of aabb-overlapping objects.
void setActivationState(int newState) const
int size() const
return the number of elements in the array
virtual btPersistentManifold * getManifoldByIndexInternal(int index)=0