34 int batchCost = bodies + 8 * manifolds + 4 * constraints;
111 bodyArray.push_back( other.
bodyArray[ i ] );
151 int lastCapacity = 0;
152 bool isSorted =
true;
157 if ( cap > lastCapacity )
187 if ( island == NULL )
207 int allocSize = numBodies;
231 if ( freeIslands.
size() > 0 )
234 int iFound = freeIslands.
size();
236 for (
int i = freeIslands.
size() - 1; i >= 0; --i )
238 if ( freeIslands[ i ]->bodyArray.
capacity() >= allocSize )
241 island = freeIslands[ i ];
250 int iSrc = iDest + 1;
251 while ( iSrc < freeIslands.
size() )
253 freeIslands[ iDest++ ] = freeIslands[ iSrc++ ];
258 if ( island == NULL )
289 int endIslandIndex=1;
290 int startIslandIndex;
293 for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
296 for (endIslandIndex = startIslandIndex+1;(endIslandIndex<numElem) && (
getUnionFind().
getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
302 bool allSleeping =
true;
305 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;
571 for (
int i = 0; i < islands.
size(); ++i )
584 : m_islandsPtr(islandsPtr), m_solverParams(solverParams)
590 for (
int i = iBegin; i < iEnd; ++i )
630 while ( iBegin < islandsPtr->
size() )
665 for (
int i = 0; i < maxNumManifolds; i++ )
693 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)
btConstraintSolver * m_solverMt
void sortIslands()
this is a special operation, destroying the content of btUnionFind.
Island * getIsland(int id)
static void serialIslandDispatch(btAlignedObjectArray< Island * > *islandsPtr, const SolverParams &solverParams)
btConstraintSolver * m_solverPool
int getIslandId(const btPersistentManifold *lhs)
btAlignedObjectArray< btPersistentManifold * > manifoldArray
btAlignedObjectArray< Island * > m_freeIslands
void append(const Island &other)
static void parallelIslandDispatch(btAlignedObjectArray< Island * > *islandsPtr, const SolverParams &solverParams)
btAlignedObjectArray< Island * > m_lookupIslandFromId
virtual btPersistentManifold * getManifoldByIndexInternal(int index)=0
static void getElement(int arrayLen, const char *cur, const char *old, char *oldPtr, char *curData)
btContactSolverInfo * m_solverInfo
bool btIsBodyInIsland(const btSimulationIslandManagerMt::Island &island, const btCollisionObject *obj)
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
btElement & getElement(int index)
btDispatcher * m_dispatcher
btCollisionObjectArray & getCollisionObjectArray()
virtual void addBodiesToIslands(btCollisionWorld *collisionWorld)
virtual btScalar solveGroup(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifold, int numManifolds, btTypedConstraint **constraints, int numConstraints, const btContactSolverInfo &info, class btIDebugDraw *debugDrawer, btDispatcher *dispatcher)=0
solve a group of constraints
#define SIMD_FORCE_INLINE
const btCollisionObject * getBody0() const
virtual ~btSimulationIslandManagerMt()
function object that routes calls to operator<
const btSimulationIslandManagerMt::SolverParams & m_solverParams
bool hasContactResponse() const
btAlignedObjectArray< Island * > m_activeIslands
static int s_minimumContactManifoldsForBatching
int m_minimumSolverBatchSize
void setActivationState(int newState) const
int size() const
return the number of elements in the array
btAlignedObjectArray< Island * > m_allocatedIslands
bool isKinematicObject() const
btAlignedObjectArray< btSimulationIslandManagerMt::Island * > & m_islandsPtr
int btGetConstraintIslandId(const btTypedConstraint *lhs)
virtual void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, btAlignedObjectArray< btTypedConstraint * > &constraints, const SolverParams &solverParams)
btCollisionObject can be used to manage collision detection objects.
int m_batchIslandMinBodyCount
btAlignedObjectArray< btTypedConstraint * > constraintArray
void setDeactivationTime(btScalar time)
UpdateIslandDispatcher(btAlignedObjectArray< btSimulationIslandManagerMt::Island * > &islandsPtr, const btSimulationIslandManagerMt::SolverParams &solverParams)
int capacity() const
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
virtual btPersistentManifold ** getInternalManifoldPointer()=0
void activate(bool forceActivation=false) const
virtual void addConstraintsToIslands(btAlignedObjectArray< btTypedConstraint * > &constraints)
virtual int getNumManifolds() const =0
static void solveIsland(btConstraintSolver *solver, Island &island, const SolverParams &solverParams)
btIDebugDraw * m_debugDrawer
CollisionWorld is interface and container for the collision detection.
virtual void mergeIslands()
btSimulationIslandManagerMt()
#define WANTS_DEACTIVATION
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 btRigidBody & getRigidBodyA() 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()
void forLoop(int iBegin, int iEnd) const BT_OVERRIDE
void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody &body)
int getNumElements() const
IslandDispatchFunc m_islandDispatch
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
int getActivationState() const
const btRigidBody & getRigidBodyB() const
virtual void addManifoldsToIslands(btDispatcher *dispatcher)
const btCollisionObject * getBody1() const
void quickSort(const L &CompareFunc)