53             if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
    54                 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
    64                 for (i=0;i< numConstraints ; i++ )
    72                                 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
    73                                         ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
    92                                 if (((cur) && (!(cur)->isStaticOrKinematicObject())) &&
    93                                         ((prev) && (!(prev)->isStaticOrKinematicObject())))
   113                         if (tagA>=0 && tagB>=0)
   126         BT_PROFILE(
"btMultiBodyDynamicsWorld::updateActivationState");
   192                         int rIslandId0,lIslandId0;
   195                         return lIslandId0 < rIslandId0;
   207         islandId= islandTagA>=0?islandTagA:islandTagB;
   219                         int rIslandId0,lIslandId0;
   222                         return lIslandId0 < rIslandId0;
   248                 m_multiBodySortedConstraints(NULL),
   251                 m_dispatcher(dispatcher)
   266                 m_solverInfo = solverInfo;
   268                 m_multiBodySortedConstraints = sortedMultiBodyConstraints;
   269                 m_numMultiBodyConstraints = numMultiBodyConstraints;
   270                 m_sortedConstraints = sortedConstraints;
   271                 m_numConstraints = numConstraints;
   273                 m_debugDrawer = debugDrawer;
   277                 m_multiBodyConstraints.
resize(0);
   286                         m_solver->
solveMultiBodyGroup( bodies,numBodies,manifolds, numManifolds,m_sortedConstraints, m_numConstraints, &m_multiBodySortedConstraints[0],m_numConstraints,*m_solverInfo,m_debugDrawer,m_dispatcher);
   293                         int numCurConstraints = 0;
   294                         int numCurMultiBodyConstraints = 0;
   300                         for (i=0;i<m_numConstraints;i++)
   304                                         startConstraint = &m_sortedConstraints[i];
   309                         for (;i<m_numConstraints;i++)
   317                         for (i=0;i<m_numMultiBodyConstraints;i++)
   322                                         startMultiBodyConstraint = &m_multiBodySortedConstraints[i];
   327                         for (;i<m_numMultiBodyConstraints;i++)
   331                                         numCurMultiBodyConstraints++;
   337                                 m_solver->
solveGroup( bodies,numBodies,manifolds, numManifolds,startConstraint,numCurConstraints,*m_solverInfo,m_debugDrawer,m_dispatcher);
   341                                 for (i=0;i<numBodies;i++)
   343                                 for (i=0;i<numManifolds;i++)
   345                                 for (i=0;i<numCurConstraints;i++)
   346                                         m_constraints.
push_back(startConstraint[i]);
   348                                 for (i=0;i<numCurMultiBodyConstraints;i++)
   349                                         m_multiBodyConstraints.
push_back(startMultiBodyConstraint[i]);
   353                                         processConstraints();
   371                 m_solver->
solveMultiBodyGroup( bodies,m_bodies.
size(),manifold, m_manifolds.
size(),constraints, m_constraints.
size() ,multiBodyConstraints, m_multiBodyConstraints.
size(), *
m_solverInfo,
m_debugDrawer,m_dispatcher);
   375                 m_multiBodyConstraints.
resize(0);
   444 #ifndef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY   451                         bool isSleeping = 
false;
   479 #endif //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY   488                         bool isSleeping = 
false;
   506                                 bool doNotUpdatePos = 
false;
   521                                                 btScalar *scratch_q0 = pMem; pMem += numPosVars;
   522                                                 btScalar *scratch_qx = pMem; pMem += numPosVars;
   523                                                 btScalar *scratch_qd0 = pMem; pMem += numDofs;
   524                                                 btScalar *scratch_qd1 = pMem; pMem += numDofs;
   525                                                 btScalar *scratch_qd2 = pMem; pMem += numDofs;
   526                                                 btScalar *scratch_qd3 = pMem; pMem += numDofs;
   527                                                 btScalar *scratch_qdd0 = pMem; pMem += numDofs;
   528                                                 btScalar *scratch_qdd1 = pMem; pMem += numDofs;
   529                                                 btScalar *scratch_qdd2 = pMem; pMem += numDofs;
   530                                                 btScalar *scratch_qdd3 = pMem; pMem += numDofs;
   531                                                 btAssert((pMem - (2*numPosVars + 8*numDofs)) == &scratch_r2[0]);
   543                                                 for(
int link = 0; link < bod->
getNumLinks(); ++link)
   549                                                 for(
int dof = 0; dof < numDofs; ++dof)                                                          
   560                                     scratch_qx[dof] = scratch_q0[dof];
   562                                                 } pResetQx = {bod, scratch_qx, scratch_q0};
   568                                                         for(
int i = 0; i < 
size; ++i)
   569                                     pVal[i] = pCurVal[i] + dt * pDer[i];
   580                                 for(
int i = 0; i < pBody->
getNumDofs() + 6; ++i)
   584                         } pCopyToVelocityVector;
   590                                                         for(
int i = 0; i < 
size; ++i)
   591                                     pDst[i] = pSrc[start + i];
   597                                                 #define output &scratch_r[bod->getNumDofs()]   600                                                 pCopy(
output, scratch_qdd0, 0, numDofs);
   605                                                 pEulerIntegrate(
btScalar(.5)*h, scratch_qdd0, scratch_qd0, scratch_qd1, numDofs);
   608                                                 pCopyToVelocityVector(bod, scratch_qd1);
   610                                                 pCopy(
output, scratch_qdd1, 0, numDofs);
   615                                                 pEulerIntegrate(
btScalar(.5)*h, scratch_qdd1, scratch_qd0, scratch_qd2, numDofs);
   618                                                 pCopyToVelocityVector(bod, scratch_qd2);
   620                                                 pCopy(
output, scratch_qdd2, 0, numDofs);
   625                                                 pEulerIntegrate(h, scratch_qdd2, scratch_qd0, scratch_qd3, numDofs);
   628                                                 pCopyToVelocityVector(bod, scratch_qd3);
   630                                                 pCopy(
output, scratch_qdd3, 0, numDofs);
   637                                                 for(
int i = 0; i < numDofs; ++i)
   639                                                         delta_q[i] = h/
btScalar(6.)*(scratch_qd0[i] + 2*scratch_qd1[i] + 2*scratch_qd2[i] + scratch_qd3[i]);
   640                                                         delta_qd[i] = h/
btScalar(6.)*(scratch_qdd0[i] + 2*scratch_qdd1[i] + 2*scratch_qdd2[i] + scratch_qdd3[i]);                                                       
   645                                                 pCopyToVelocityVector(bod, scratch_qd0);
   653                                                         for(
int i = 0; i < numDofs; ++i)
   654                                                                 pRealBuf[i] = delta_q[i];
   662                                                         for(
int link = 0; link < bod->
getNumLinks(); ++link)
   670 #ifndef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY   672 #endif //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY   689                         bool isSleeping = 
false;
   712                                                                         bool isConstraintPass = 
true;
   741                         bool isSleeping = 
false;
   773                                 world_to_local.
resize(nLinks+1);
   774                                 local_origin.
resize(nLinks+1);
   806         BT_PROFILE(
"btMultiBodyDynamicsWorld debugDrawWorld");
   808         bool drawConstraints = 
false;
   814                         drawConstraints = 
true;
   887 #ifdef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY   893                 bool isSleeping = 
false;
   915 #endif //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY   934                         bool isSleeping = 
false;
   959 #ifdef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY MultiBodyInplaceSolverIslandCallback & operator=(MultiBodyInplaceSolverIslandCallback &other)
virtual void finishSerialization()=0
void serializeDynamicsWorldInfo(btSerializer *serializer)
btAlignedObjectArray< btTypedConstraint * > m_constraints
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep...
void serializeCollisionObjects(btSerializer *serializer)
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
virtual void updateActivationState(btScalar timeStep)
virtual void debugDrawMultiBodyConstraint(btMultiBodyConstraint *constraint)
void clearConstraintForces()
void push_back(const T &_Val)
const btMultibodyLink & getLink(int index) const 
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see B...
btSimulationIslandManager * m_islandManager
#define BT_MULTIBODY_CODE
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep...
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
void stepPositionsMultiDof(btScalar dt, btScalar *pq=0, btScalar *pqd=0)
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
eFeatherstoneJointType m_jointType
virtual void startSerialization()=0
const btScalar & z() const 
Return the z value. 
class btMultiBodyLinkCollider * m_collider
btTransform getBaseWorldTransform() const 
void updateCacheMultiDof(btScalar *pq=0)
btIDebugDraw * m_debugDrawer
btDiscreteDynamicsWorld provides discrete rigid body simulation those classes replace the obsolete Cc...
void computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar dt, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v, btAlignedObjectArray< btMatrix3x3 > &scratch_m, bool isConstraintPass=false)
virtual int calculateSerializeBufferSize() const 
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
btScalar getBaseMass() const 
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
virtual void debugDrawWorld()
btSimulationIslandManager * getSimulationIslandManager()
#define SIMD_FORCE_INLINE
int getNumCollisionObjects() const 
void addLinkForce(int i, const btVector3 &f)
const btCollisionObject * getBody0() const 
const btScalar & y() const 
Return the y value. 
btMultiBodyConstraintSolver * m_solver
virtual void integrateTransforms(btScalar timeStep)
bool isPosUpdated() const 
int btGetMultiBodyConstraintIslandId(const btMultiBodyConstraint *lhs)
void updateCollisionObjectWorldTransforms(btAlignedObjectArray< btQuaternion > &scratch_q, btAlignedObjectArray< btVector3 > &scratch_m)
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
virtual void debugDraw(class btIDebugDraw *drawer)=0
void applyDeltaVeeMultiDof(const btScalar *delta_vee, btScalar multiplier)
const btScalar & w() const 
Return the w value. 
btContactSolverInfo m_solverInfo
btMultiBodyConstraintSolver * m_multiBodyConstraintSolver
void clearForcesAndTorques()
const btScalar & x() const 
Return the x value. 
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
btDispatcher * m_dispatcher
virtual btScalar solveGroup(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifold, int numManifolds, btTypedConstraint **constraints, int numConstraints, const btContactSolverInfo &info, btIDebugDraw *debugDrawer, btDispatcher *dispatcher)
this method should not be called, it was just used during porting/integration of Featherstone btMulti...
virtual int getIslandIdB() const =0
MultiBodyInplaceSolverIslandCallback * m_solverMultiBodyIslandCallback
btCollisionWorld * getCollisionWorld()
int getNumPosVars() const 
void forwardKinematics(btAlignedObjectArray< btQuaternion > &scratch_q, btAlignedObjectArray< btVector3 > &scratch_m)
btContactSolverInfo * m_solverInfo
btAlignedObjectArray< btCollisionObject * > m_bodies
void setActivationState(int newState) const 
virtual void clearMultiBodyConstraintForces()
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, int islandId)
int size() const 
return the number of elements in the array 
virtual void solveMultiBodyGroup(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifold, int numManifolds, btTypedConstraint **constraints, int numConstraints, btMultiBodyConstraint **multiBodyConstraints, int numMultiBodyConstraints, const btContactSolverInfo &info, btIDebugDraw *debugDrawer, btDispatcher *dispatcher)
btIDebugDraw * m_debugDrawer
virtual btIDebugDraw * getDebugDrawer()
virtual ~btMultiBodyDynamicsWorld()
virtual void debugDrawWorld()
virtual void removeMultiBodyConstraint(btMultiBodyConstraint *constraint)
btSpatialMotionVector m_axes[6]
btAlignedObjectArray< btPersistentManifold * > m_manifolds
bool isStaticOrKinematicObject() const 
btCollisionObject can be used to manage collision detection objects. 
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
btAlignedObjectArray< btMultiBodyConstraint * > m_multiBodyConstraints
btAlignedObjectArray< btPersistentManifold * > m_predictiveManifolds
The btRigidBody is the main class for rigid body objects. 
virtual void applyGravity()
apply gravity, call this once per timestep 
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
void setDeactivationTime(btScalar time)
btDispatcher * getDispatcher()
virtual void solveConstraints(btContactSolverInfo &solverInfo)
MultiBodyInplaceSolverIslandCallback(btMultiBodyConstraintSolver *solver, btDispatcher *dispatcher)
const btScalar & y() const 
Return the y value. 
void checkMotionAndSleepIfRequired(btScalar timestep)
virtual void applyGravity()
apply gravity, call this once per timestep 
btAlignedObjectArray< btMultiBody * > m_multiBodies
virtual int getIslandIdA() const =0
int m_numMultiBodyConstraints
btVector3 can be used to represent 3D points and vectors. 
btMultiBodyConstraint ** m_multiBodySortedConstraints
btAlignedObjectArray< btMultiBodyConstraint * > m_multiBodyConstraints
btMultiBodyDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btMultiBodyConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration)
btScalar getLinkMass(int i) const 
virtual void serializeMultiBodies(btSerializer *serializer)
void addBaseForce(const btVector3 &f)
virtual int getNumConstraints() const 
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
btAlignedObjectArray< btMultiBodyConstraint * > m_sortedMultiBodyConstraints
virtual void prepareSolve(int, int)
#define WANTS_DEACTIVATION
void remove(const T &key)
virtual void drawTransform(const btTransform &transform, btScalar orthoLen)
virtual void addMultiBody(btMultiBody *body, short group=btBroadphaseProxy::DefaultFilter, short mask=btBroadphaseProxy::AllFilter)
TypedConstraint is the baseclass for Bullet constraints and vehicles. 
void resize(int newsize, const T &fillData=T())
virtual void integrateTransforms(btScalar timeStep)
const btRigidBody & getRigidBodyA() const 
virtual void clearMultiBodyForces()
virtual int getDebugMode() const =0
void setPosUpdated(bool updated)
void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btMultiBodyConstraint **sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw *debugDrawer)
virtual void storeIslandActivationState(btCollisionWorld *world)
#define DISABLE_DEACTIVATION
virtual void removeMultiBody(btMultiBody *body)
btUnionFind & getUnionFind()
bool isUsingRK4Integration() const 
btTransform m_cachedWorldTransform
const btScalar & x() const 
Return the x value. 
btConstraintSolver * m_constraintSolver
const btMultiBodyLinkCollider * getBaseCollider() const 
void serializeRigidBodies(btSerializer *serializer)
const btQuaternion & getWorldToBaseRot() const 
virtual void updateActivationState(btScalar timeStep)
void processConstraints()
btTypedConstraint ** m_sortedConstraints
const btVector3 & getBasePos() const 
virtual void addMultiBodyConstraint(btMultiBodyConstraint *constraint)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
int getActivationState() const 
btContactSolverInfo & getSolverInfo()
const btRigidBody & getRigidBodyB() const 
const btCollisionObject * getBody1() const 
virtual btChunk * allocate(size_t size, int numElements)=0
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const 
fills the dataBuffer and returns the struct name (and 0 on failure) 
const btScalar * getVelocityVector() const 
void processDeltaVeeMultiDof2()
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
void quickSort(const L &CompareFunc)
int btGetConstraintIslandId2(const btTypedConstraint *lhs)
virtual void calculateSimulationIslands()
const btScalar & z() const 
Return the z value. 
btAlignedObjectArray< btTypedConstraint * > m_constraints