Bullet Collision Detection & Physics Library
|
Go to the documentation of this file.
32 int batchCost = bodies + 8 * manifolds + 4 * constraints;
140 int lastCapacity = 0;
141 bool isSorted =
true;
146 if (cap > lastCapacity)
194 int allocSize = numBodies;
218 if (freeIslands.
size() > 0)
221 int iFound = freeIslands.
size();
223 for (
int i = freeIslands.
size() - 1; i >= 0; --i)
225 if (freeIslands[i]->bodyArray.
capacity() >= allocSize)
228 island = freeIslands[i];
237 int iSrc = iDest + 1;
238 while (iSrc < freeIslands.
size())
240 freeIslands[iDest++] = freeIslands[iSrc++];
274 int endIslandIndex = 1;
275 int startIslandIndex;
278 for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex)
281 for (endIslandIndex = startIslandIndex + 1; (endIslandIndex < numElem) && (
getUnionFind().
getElement(endIslandIndex).m_id == islandId); endIslandIndex++)
287 bool allSleeping =
true;
290 for (idx = startIslandIndex; idx < endIslandIndex; idx++)
315 for (idx = startIslandIndex; idx < endIslandIndex; idx++)
335 for (idx = startIslandIndex; idx < endIslandIndex; idx++)
363 int endIslandIndex = 1;
364 int startIslandIndex;
368 for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex)
373 for (endIslandIndex = startIslandIndex; (endIslandIndex < numElem) && (
getUnionFind().
getElement(endIslandIndex).m_id == islandId); endIslandIndex++)
377 bool islandSleeping =
true;
378 for (
int iElem = startIslandIndex; iElem < endIslandIndex; iElem++)
384 islandSleeping =
false;
390 int numBodies = endIslandIndex - startIslandIndex;
395 for (
int iElem = startIslandIndex; iElem < endIslandIndex; iElem++)
409 for (
int i = 0; i < maxNumManifolds; i++)
426 if (colObj1->isKinematicObject() && colObj1->getActivationState() !=
ISLAND_SLEEPING)
428 if (colObj1->hasContactResponse())
439 island->manifoldArray.push_back(manifold);
449 for (
int i = 0; i < constraints.
size(); i++)
459 island->constraintArray.push_back(constraint);
484 while (destIslandIndex < lastIndex)
491 int firstIndex = lastIndex;
499 int batchCost =
calcBatchCost(numBodies, numManifolds, numConstraints);
504 if (firstIndex - 1 == destIslandIndex)
515 for (
int i = firstIndex; i <= lastIndex; ++i)
521 lastIndex = firstIndex - 1;
547 for (
int i = 0; i < islands.
size(); ++i)
559 : m_islandsPtr(islandsPtr), m_solverParams(solverParams)
566 for (
int i = iBegin; i < iEnd; ++i)
605 while (iBegin < islandsPtr->
size())
638 for (
int i = 0; i < maxNumManifolds; i++)
655 if (colObj1->isKinematicObject() && colObj1->getActivationState() !=
ISLAND_SLEEPING)
657 if (colObj1->hasContactResponse())
665 collisionObjects.
size(),
static void parallelIslandDispatch(btAlignedObjectArray< Island * > *islandsPtr, const SolverParams &solverParams)
static void getElement(int arrayLen, const char *cur, const char *old, char *oldPtr, char *curData)
TypedConstraint is the baseclass for Bullet constraints and vehicles.
btCollisionObject can be used to manage collision detection objects.
btAlignedObjectArray< Island * > m_freeIslands
virtual void addManifoldsToIslands(btDispatcher *dispatcher)
#define DISABLE_DEACTIVATION
virtual btPersistentManifold ** getInternalManifoldPointer()=0
virtual void initIslandPools()
function object that routes calls to operator<
int calcBatchCost(int bodies, int manifolds, int constraints)
const btRigidBody & getRigidBodyA() const
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
virtual ~btSimulationIslandManagerMt()
btDispatcher * m_dispatcher
void quickSort(const L &CompareFunc)
bool operator()(const btSimulationIslandManagerMt::Island *lhs, const btSimulationIslandManagerMt::Island *rhs) const
const btCollisionObject * getBody0() const
btAlignedObjectArray< btCollisionObject * > bodyArray
virtual int getNumManifolds() const =0
void sortIslands()
this is a special operation, destroying the content of btUnionFind.
int getActivationState() const
btIDebugDraw * m_debugDrawer
btElement & getElement(int index)
int m_minimumSolverBatchSize
bool isKinematicObject() const
btAlignedObjectArray< btSimulationIslandManagerMt::Island * > & m_islandsPtr
void append(const Island &other)
static void solveIsland(btConstraintSolver *solver, Island &island, const SolverParams &solverParams)
btContactSolverInfo * m_solverInfo
const btRigidBody & getRigidBodyB() const
const btSimulationIslandManagerMt::SolverParams & m_solverParams
btSimulationIslandManagerMt()
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
virtual void buildIslands(btDispatcher *dispatcher, btCollisionWorld *colWorld)
bool btIsBodyInIsland(const btSimulationIslandManagerMt::Island &island, const btCollisionObject *obj)
void activate(bool forceActivation=false) const
btAlignedObjectArray< Island * > m_lookupIslandFromId
void resize(int newsize, const T &fillData=T())
virtual void addConstraintsToIslands(btAlignedObjectArray< btTypedConstraint * > &constraints)
bool operator()(const btSimulationIslandManagerMt::Island *lhs, const btSimulationIslandManagerMt::Island *rhs) const
void setDeactivationTime(btScalar time)
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
virtual void mergeIslands()
int getNumElements() const
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
bool hasContactResponse() const
btConstraintSolver * m_solverPool
btConstraintSolver * m_solverMt
btAlignedObjectArray< btPersistentManifold * > manifoldArray
#define SIMD_FORCE_INLINE
int btGetConstraintIslandId(const btTypedConstraint *lhs)
void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody &body)
virtual void addBodiesToIslands(btCollisionWorld *collisionWorld)
int capacity() const
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
btAlignedObjectArray< Island * > m_allocatedIslands
UpdateIslandDispatcher(btAlignedObjectArray< btSimulationIslandManagerMt::Island * > &islandsPtr, const btSimulationIslandManagerMt::SolverParams &solverParams)
virtual void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, btAlignedObjectArray< btTypedConstraint * > &constraints, const SolverParams &solverParams)
#define WANTS_DEACTIVATION
CollisionWorld is interface and container for the collision detection.
int m_batchIslandMinBodyCount
const btCollisionObject * getBody1() const
btCollisionObjectArray & getCollisionObjectArray()
int getIslandId(const btPersistentManifold *lhs)
btUnionFind & getUnionFind()
btAlignedObjectArray< Island * > m_activeIslands
void push_back(const T &_Val)
virtual Island * allocateIsland(int id, int numBodies)
btAlignedObjectArray< btTypedConstraint * > constraintArray
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
static int s_minimumContactManifoldsForBatching
Island * getIsland(int id)
static void serialIslandDispatch(btAlignedObjectArray< Island * > *islandsPtr, const SolverParams &solverParams)
IslandDispatchFunc m_islandDispatch
void setActivationState(int newState) const
int size() const
return the number of elements in the array
void forLoop(int iBegin, int iEnd) const BT_OVERRIDE
virtual btPersistentManifold * getManifoldByIndexInternal(int index)=0