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)