33 int batchCost = bodies + 8 * manifolds + 4 * constraints;
110 bodyArray.push_back( other.
bodyArray[ i ] );
150 int lastCapacity = 0;
151 bool isSorted =
true;
156 if ( cap > lastCapacity )
186 if ( island == NULL )
206 int allocSize = numBodies;
230 if ( freeIslands.
size() > 0 )
233 int iFound = freeIslands.
size();
235 for (
int i = freeIslands.
size() - 1; i >= 0; --i )
237 if ( freeIslands[ i ]->bodyArray.
capacity() >= allocSize )
240 island = freeIslands[ i ];
249 int iSrc = iDest + 1;
250 while ( iSrc < freeIslands.
size() )
252 freeIslands[ iDest++ ] = freeIslands[ iSrc++ ];
257 if ( island == NULL )
288 int endIslandIndex=1;
289 int startIslandIndex;
292 for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
295 for (endIslandIndex = startIslandIndex+1;(endIslandIndex<numElem) && (
getUnionFind().
getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
301 bool allSleeping =
true;
304 for (idx=startIslandIndex;idx<endIslandIndex;idx++)
331 for (idx=startIslandIndex;idx<endIslandIndex;idx++)
351 for (idx=startIslandIndex;idx<endIslandIndex;idx++)
380 int endIslandIndex = 1;
381 int startIslandIndex;
385 for ( startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex )
390 for ( endIslandIndex = startIslandIndex; ( endIslandIndex < numElem ) && (
getUnionFind().
getElement( endIslandIndex ).m_id == islandId ); endIslandIndex++ )
394 bool islandSleeping =
true;
395 for (
int iElem = startIslandIndex; iElem < endIslandIndex; iElem++ )
401 islandSleeping =
false;
404 if ( !islandSleeping )
407 int numBodies = endIslandIndex - startIslandIndex;
412 for (
int iElem = startIslandIndex; iElem < endIslandIndex; iElem++ )
428 for (
int i = 0; i < maxNumManifolds; i++ )
459 island->manifoldArray.push_back( manifold );
470 for (
int i = 0; i < constraints.
size(); i++ )
480 island->constraintArray.push_back( constraint );
506 while ( destIslandIndex < lastIndex )
513 int firstIndex = lastIndex;
521 int batchCost =
calcBatchCost( numBodies, numManifolds, numConstraints );
526 if ( firstIndex - 1 == destIslandIndex )
537 for (
int i = firstIndex; i <= lastIndex; ++i )
543 lastIndex = firstIndex - 1;
554 for (
int i = 0; i < islands.
size(); ++i )
556 Island* island = islands[ i ];
577 for (
int i = iBegin; i < iEnd; ++i )
623 for (
int i = 0; i < maxNumManifolds; i++ )
650 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...
static void serialIslandDispatch(btAlignedObjectArray< Island *> *islandsPtr, IslandCallback *callback)
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<
btAlignedObjectArray< btSimulationIslandManagerMt::Island * > * islandsPtr
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
static void parallelIslandDispatch(btAlignedObjectArray< Island *> *islandsPtr, IslandCallback *callback)
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()
btSimulationIslandManagerMt::IslandCallback * callback
void forLoop(int iBegin, int iEnd) const BT_OVERRIDE
void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody &body)
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)