| 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