32     int batchCost = bodies + 8 * manifolds + 4 * constraints;
   109         bodyArray.push_back( other.
bodyArray[ i ] );
   149     int lastCapacity = 0;
   150     bool isSorted = 
true;
   155         if ( cap > lastCapacity )
   185     if ( island == NULL )
   205     int allocSize = numBodies;
   229     if ( freeIslands.
size() > 0 )
   232         int iFound = freeIslands.
size();
   234         for ( 
int i = freeIslands.
size() - 1; i >= 0; --i )
   236             if ( freeIslands[ i ]->bodyArray.
capacity() >= allocSize )
   239                 island = freeIslands[ i ];
   248             int iSrc = iDest + 1;
   249             while ( iSrc < freeIslands.
size() )
   251                 freeIslands[ iDest++ ] = freeIslands[ iSrc++ ];
   256     if ( island == NULL )
   287         int endIslandIndex=1;
   288         int startIslandIndex;
   291         for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
   294                 for (endIslandIndex = startIslandIndex+1;(endIslandIndex<numElem) && (
getUnionFind().
getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
   300                 bool allSleeping = 
true;
   303                 for (idx=startIslandIndex;idx<endIslandIndex;idx++)
   330                         for (idx=startIslandIndex;idx<endIslandIndex;idx++)
   350                         for (idx=startIslandIndex;idx<endIslandIndex;idx++)
   379     int endIslandIndex = 1;
   380     int startIslandIndex;
   384     for ( startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex )
   389         for ( endIslandIndex = startIslandIndex; ( endIslandIndex < numElem ) && ( 
getUnionFind().
getElement( endIslandIndex ).m_id == islandId ); endIslandIndex++ )
   393         bool islandSleeping = 
true;
   394         for ( 
int iElem = startIslandIndex; iElem < endIslandIndex; iElem++ )
   400                 islandSleeping = 
false;
   403         if ( !islandSleeping )
   406             int numBodies = endIslandIndex - startIslandIndex;
   411             for ( 
int iElem = startIslandIndex; iElem < endIslandIndex; iElem++ )
   427     for ( 
int i = 0; i < maxNumManifolds; i++ )
   458                     island->manifoldArray.push_back( manifold );
   469     for ( 
int i = 0; i < constraints.
size(); i++ )
   479                 island->constraintArray.push_back( constraint );
   505     while ( destIslandIndex < lastIndex )
   512         int firstIndex = lastIndex;
   520             int batchCost = 
calcBatchCost( numBodies, numManifolds, numConstraints );
   525             if ( firstIndex - 1 == destIslandIndex )
   536         for ( 
int i = firstIndex; i <= lastIndex; ++i )
   542         lastIndex = firstIndex - 1;
   552     for ( 
int i = 0; i < islands.
size(); ++i )
   554         Island* island = islands[ i ];
   586         for ( 
int i = 0; i < maxNumManifolds; i++ )
   613                                  collisionObjects.
size(),
 
virtual Island * allocateIsland(int id, int numBodies)
virtual void initIslandPools()
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
void push_back(const T &_Val)
void sortIslands()
this is a special operation, destroying the content of btUnionFind. 
Island * getIsland(int id)
int getIslandId(const btPersistentManifold *lhs)
btAlignedObjectArray< btPersistentManifold * > manifoldArray
btAlignedObjectArray< Island * > m_freeIslands
void append(const Island &other)
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
btAlignedObjectArray< Island * > m_lookupIslandFromId
virtual btPersistentManifold * getManifoldByIndexInternal(int index)=0
virtual void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, btAlignedObjectArray< btTypedConstraint *> &constraints, IslandCallback *callback)
static void getElement(int arrayLen, const char *cur, const char *old, char *oldPtr, char *curData)
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, btTypedConstraint **constraints, int numConstraints, int islandId)=0
const btRigidBody & getRigidBodyA() const
bool btIsBodyInIsland(const btSimulationIslandManagerMt::Island &island, const btCollisionObject *obj)
btElement & getElement(int index)
btCollisionObjectArray & getCollisionObjectArray()
virtual void addBodiesToIslands(btCollisionWorld *collisionWorld)
bool isKinematicObject() const
#define SIMD_FORCE_INLINE
int getActivationState() const
virtual ~btSimulationIslandManagerMt()
const btRigidBody & getRigidBodyB() const
function object that routes calls to operator< 
static void defaultIslandDispatch(btAlignedObjectArray< Island *> *islands, IslandCallback *callback)
btAlignedObjectArray< Island * > m_activeIslands
void activate(bool forceActivation=false) const
int m_minimumSolverBatchSize
btAlignedObjectArray< Island * > m_allocatedIslands
const btCollisionObject * getBody0() const
int btGetConstraintIslandId(const btTypedConstraint *lhs)
btCollisionObject can be used to manage collision detection objects. 
int capacity() const
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
bool hasContactResponse() const
int m_batchIslandMinBodyCount
btAlignedObjectArray< btTypedConstraint * > constraintArray
void setDeactivationTime(btScalar time)
virtual btPersistentManifold ** getInternalManifoldPointer()=0
int size() const
return the number of elements in the array 
virtual int getNumManifolds() const =0
CollisionWorld is interface and container for the collision detection. 
virtual void mergeIslands()
btSimulationIslandManagerMt()
#define WANTS_DEACTIVATION
virtual void addConstraintsToIslands(btAlignedObjectArray< btTypedConstraint *> &constraints)
TypedConstraint is the baseclass for Bullet constraints and vehicles. 
void resize(int newsize, const T &fillData=T())
int calcBatchCost(int bodies, int manifolds, int constraints)
const btCollisionObject * getBody1() const
int getNumElements() const
virtual void buildIslands(btDispatcher *dispatcher, btCollisionWorld *colWorld)
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
#define DISABLE_DEACTIVATION
btAlignedObjectArray< btCollisionObject * > bodyArray
btUnionFind & getUnionFind()
IslandDispatchFunc m_islandDispatch
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
virtual void addManifoldsToIslands(btDispatcher *dispatcher)
void setActivationState(int newState) const
void quickSort(const L &CompareFunc)