| Bullet Collision Detection & Physics Library
    | 
 
 
 
Go to the documentation of this file.
   51                         if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
 
   52                                 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
 
   62                 for (i = 0; i < numConstraints; i++)
 
   70                                 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
 
   71                                         ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
 
   90                                 if (((cur) && (!(cur)->isStaticOrKinematicObject())) &&
 
   91                                         ((prev) && (!(prev)->isStaticOrKinematicObject())))
 
  110                         if (tagA >= 0 && tagB >= 0)
 
  121         BT_PROFILE(
"btMultiBodyDynamicsWorld::updateActivationState");
 
  181                 int rIslandId0, lIslandId0;
 
  184                 return lIslandId0 < rIslandId0;
 
  194         islandId = islandTagA >= 0 ? islandTagA : islandTagB;
 
  203                 int rIslandId0, lIslandId0;
 
  206                 return lIslandId0 < rIslandId0;
 
  272                         m_solver->
solveMultiBodyGroup(bodies, numBodies, manifolds, numManifolds, 
m_sortedConstraints, 
m_numConstraints, &
m_multiBodySortedConstraints[0], 
m_numConstraints, *
m_solverInfo, 
m_debugDrawer, 
m_dispatcher);
 
  280                         int numCurConstraints = 0;
 
  281                         int numCurMultiBodyConstraints = 0;
 
  317                                         numCurMultiBodyConstraints++;
 
  326                                 for (i = 0; i < numBodies; i++)
 
  328                                 for (i = 0; i < numManifolds; i++)
 
  330                                 for (i = 0; i < numCurConstraints; i++)
 
  333                                 for (i = 0; i < numCurMultiBodyConstraints; i++)
 
  356                 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);
 
  366           m_multiBodyConstraintSolver(constraintSolver)
 
  432 #ifndef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY 
  439                         bool isSleeping = 
false;
 
  467 #endif  //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY 
  475                         bool isSleeping = 
false;
 
  493                                 bool doNotUpdatePos = 
false;
 
  494                 bool isConstraintPass = 
false;
 
  509                                                 scratch_r2.
resize(2 * numPosVars + 8 * numDofs);
 
  532                                                 btAssert((pMem - (2 * numPosVars + 8 * numDofs)) == &scratch_r2[0]);
 
  544                                                 for (
int link = 0; link < bod->
getNumLinks(); ++link)
 
  550                                                 for (
int dof = 0; dof < numDofs; ++dof)
 
  561                                                                         scratch_qx[dof] = scratch_q0[dof];
 
  563                                                 } pResetQx = {bod, scratch_qx, scratch_q0};
 
  569                                                                 for (
int i = 0; i < 
size; ++i)
 
  570                                                                         pVal[i] = pCurVal[i] + dt * pDer[i];
 
  581                                                                 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 &m_scratch_r[bod->getNumDofs()] 
  600                                                 isConstraintPass,
getSolverInfo().m_jointFeedbackInWorldSpace,
 
  602                                                 pCopy(
output, scratch_qdd0, 0, numDofs);
 
  607                                                 pEulerIntegrate(
btScalar(.5) * h, scratch_qdd0, scratch_qd0, scratch_qd1, numDofs);
 
  610                                                 pCopyToVelocityVector(bod, scratch_qd1);
 
  612                                                 isConstraintPass,
getSolverInfo().m_jointFeedbackInWorldSpace,
 
  614                                                 pCopy(
output, scratch_qdd1, 0, numDofs);
 
  619                                                 pEulerIntegrate(
btScalar(.5) * h, scratch_qdd1, scratch_qd0, scratch_qd2, numDofs);
 
  622                                                 pCopyToVelocityVector(bod, scratch_qd2);
 
  624                                                 isConstraintPass,
getSolverInfo().m_jointFeedbackInWorldSpace,
 
  626                                                 pCopy(
output, scratch_qdd2, 0, numDofs);
 
  631                                                 pEulerIntegrate(h, scratch_qdd2, scratch_qd0, scratch_qd3, numDofs);
 
  634                                                 pCopyToVelocityVector(bod, scratch_qd3);
 
  636                                                 isConstraintPass,
getSolverInfo().m_jointFeedbackInWorldSpace,
 
  638                                                 pCopy(
output, scratch_qdd3, 0, numDofs);
 
  647                                                 for (
int i = 0; i < numDofs; ++i)
 
  649                                                         delta_q[i] = h / 
btScalar(6.) * (scratch_qd0[i] + 2 * scratch_qd1[i] + 2 * scratch_qd2[i] + scratch_qd3[i]);
 
  650                                                         delta_qd[i] = h / 
btScalar(6.) * (scratch_qdd0[i] + 2 * scratch_qdd1[i] + 2 * scratch_qdd2[i] + scratch_qdd3[i]);
 
  655                                                 pCopyToVelocityVector(bod, scratch_qd0);
 
  663                                                         for (
int i = 0; i < numDofs; ++i)
 
  664                                                                 pRealBuf[i] = delta_q[i];
 
  672                                                         for (
int link = 0; link < bod->
getNumLinks(); ++link)
 
  675                                                         isConstraintPass,
getSolverInfo().m_jointFeedbackInWorldSpace,
 
  681 #ifndef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY 
  683 #endif         //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY 
  701                         bool isSleeping = 
false;
 
  723                                                 bool isConstraintPass = 
true;
 
  751                         bool isSleeping = 
false;
 
  811         BT_PROFILE(
"btMultiBodyDynamicsWorld debugDrawWorld");
 
  815         bool drawConstraints = 
false;
 
  821                         drawConstraints = 
true;
 
  888 #ifdef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY 
  894                 bool isSleeping = 
false;
 
  916 #endif  //BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY 
  935                         bool isSleeping = 
false;
 
  959 #ifdef BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY 
  
btIDebugDraw * m_debugDrawer
btAlignedObjectArray< btTypedConstraint * > m_constraints
virtual void setMultiBodyConstraintSolver(btMultiBodyConstraintSolver *solver)
TypedConstraint is the baseclass for Bullet constraints and vehicles.
btCollisionObject can be used to manage collision detection objects.
virtual void setConstraintSolver(btConstraintSolver *solver)
btSpatialMotionVector m_axes[6]
virtual void storeIslandActivationState(btCollisionWorld *world)
The btRigidBody is the main class for rigid body objects.
btAlignedObjectArray< btMultiBodyConstraint * > m_multiBodyConstraints
const btScalar & y() const
Return the y value.
#define DISABLE_DEACTIVATION
virtual void calculateSimulationIslands()
virtual void addMultiBodyConstraint(btMultiBodyConstraint *constraint)
btAlignedObjectArray< btQuaternion > m_scratch_world_to_local
virtual btIDebugDraw * getDebugDrawer()
void processDeltaVeeMultiDof2()
void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
btAlignedObjectArray< btVector3 > m_scratch_local_origin1
btMultiBodyConstraint ** m_multiBodySortedConstraints
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
const btRigidBody & getRigidBodyA() const
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
btSimulationIslandManager * m_islandManager
bool operator()(const btTypedConstraint *lhs, const btTypedConstraint *rhs) const
virtual void clearMultiBodyConstraintForces()
bool operator()(const btMultiBodyConstraint *lhs, const btMultiBodyConstraint *rhs) const
void setMultiBodyConstraintSolver(btMultiBodyConstraintSolver *solver)
void quickSort(const L &CompareFunc)
const btQuaternion & getWorldToBaseRot() const
const btCollisionObject * getBody0() const
void clearConstraintForces()
virtual int getIslandIdB() const =0
bool isPosUpdated() const
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
virtual int getDebugMode() const =0
virtual void drawTransform(const btTransform &transform, btScalar orthoLen)
virtual void debugDraw(class btIDebugDraw *drawer)=0
btContactSolverInfo & getSolverInfo()
MultiBodyInplaceSolverIslandCallback * m_solverMultiBodyIslandCallback
int getActivationState() const
void updateCollisionObjectWorldTransforms(btAlignedObjectArray< btQuaternion > &scratch_q, btAlignedObjectArray< btVector3 > &scratch_m)
virtual int calculateSerializeBufferSize() const
MultiBodyInplaceSolverIslandCallback(btMultiBodyConstraintSolver *solver, btDispatcher *dispatcher)
void serializeContactManifolds(btSerializer *serializer)
#define BT_MULTIBODY_CODE
const btScalar & w() const
Return the w value.
btSimulationIslandManager * getSimulationIslandManager()
#define BT_MB_LINKCOLLIDER_CODE
btTransform getBaseWorldTransform() const
bool isUsingRK4Integration() const
void stepPositionsMultiDof(btScalar dt, btScalar *pq=0, btScalar *pqd=0)
virtual void solveConstraints(btContactSolverInfo &solverInfo)
btTransform m_cachedWorldTransform
const btScalar & y() const
Return the y value.
const btRigidBody & getRigidBodyB() const
bool isStaticOrKinematicObject() const
void applyDeltaVeeMultiDof(const btScalar *delta_vee, btScalar multiplier)
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
btAlignedObjectArray< btScalar > m_scratch_r
virtual btConstraintSolverType getSolverType() const =0
btAlignedObjectArray< btPersistentManifold * > m_manifolds
void clearForcesAndTorques()
void addLinkForce(int i, const btVector3 &f)
btCollisionWorld * getCollisionWorld()
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
virtual void debugDrawWorld()
void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btMultiBodyConstraint **sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw *debugDrawer)
int btGetConstraintIslandId2(const btTypedConstraint *lhs)
virtual void integrateTransforms(btScalar timeStep)
void checkMotionAndSleepIfRequired(btScalar timestep)
btAlignedObjectArray< btMultiBody * > m_multiBodies
void resize(int newsize, const T &fillData=T())
virtual void debugDrawWorld()
btIDebugDraw * m_debugDrawer
void addBaseForce(const btVector3 &f)
btAlignedObjectArray< btCollisionObject * > m_bodies
btAlignedObjectArray< btVector3 > m_scratch_local_origin
btScalar getBaseMass() const
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
int getNumCollisionObjects() const
virtual int calculateSerializeBufferSize() const
void setDeactivationTime(btScalar time)
virtual int getIslandIdA() const =0
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
void forwardKinematics(btAlignedObjectArray< btQuaternion > &scratch_q, btAlignedObjectArray< btVector3 > &scratch_m)
btMultiBodyConstraintSolver * m_multiBodyConstraintSolver
const btMultibodyLink & getLink(int index) const
btVector3 can be used to represent 3D points and vectors.
btAlignedObjectArray< btMultiBodyConstraint * > m_sortedMultiBodyConstraints
virtual void removeMultiBodyConstraint(btMultiBodyConstraint *constraint)
btAlignedObjectArray< btPersistentManifold * > m_predictiveManifolds
int getNumPosVars() const
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
btDispatcher * m_dispatcher
virtual void applyGravity()
apply gravity, call this once per timestep
btAlignedObjectArray< btVector3 > m_scratch_v
virtual void finishSerialization()=0
virtual void startSerialization()=0
class btMultiBodyLinkCollider * m_collider
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
const btScalar & x() const
Return the x value.
virtual void applyGravity()
apply gravity, call this once per timestep
MultiBodyInplaceSolverIslandCallback & operator=(MultiBodyInplaceSolverIslandCallback &other)
btTypedConstraint ** m_sortedConstraints
btScalar getLinkMass(int i) const
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, int islandId)
#define SIMD_FORCE_INLINE
void computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar dt, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v, btAlignedObjectArray< btMatrix3x3 > &scratch_m, bool isConstraintPass, bool jointFeedbackInWorldSpace, bool jointFeedbackInJointFrame)
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
virtual void integrateTransforms(btScalar timeStep)
void setPosUpdated(bool updated)
btAlignedObjectArray< btMatrix3x3 > m_scratch_m
const btScalar & x() const
Return the x value.
virtual ~btMultiBodyDynamicsWorld()
btAlignedObjectArray< btTypedConstraint * > m_constraints
eFeatherstoneJointType m_jointType
btMultiBodyDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btMultiBodyConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration)
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
void updateCacheMultiDof(btScalar *pq=0)
virtual void setConstraintSolver(btConstraintSolver *solver)
const btScalar * getVelocityVector() const
int getInternalType() const
reserved for Bullet internal usage
btConstraintSolver * m_constraintSolver
btAlignedObjectArray< btMultiBodyConstraint * > m_multiBodyConstraints
virtual int getNumConstraints() const
#define WANTS_DEACTIVATION
void serializeRigidBodies(btSerializer *serializer)
virtual void clearMultiBodyForces()
btDispatcher * getDispatcher()
void serializeCollisionObjects(btSerializer *serializer)
const btCollisionObject * getBody1() const
btUnionFind & getUnionFind()
btDiscreteDynamicsWorld provides discrete rigid body simulation those classes replace the obsolete Cc...
virtual void updateActivationState(btScalar timeStep)
virtual void debugDrawMultiBodyConstraint(btMultiBodyConstraint *constraint)
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see B...
void push_back(const T &_Val)
btMultiBodyConstraintSolver * m_solver
const btScalar & z() const
Return the z value.
virtual void prepareSolve(int, int)
virtual void serializeMultiBodies(btSerializer *serializer)
const btVector3 & getBasePos() const
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
virtual void updateActivationState(btScalar timeStep)
void remove(const T &key)
int btGetMultiBodyConstraintIslandId(const btMultiBodyConstraint *lhs)
int m_numMultiBodyConstraints
virtual void removeMultiBody(btMultiBody *body)
const btMultiBodyLinkCollider * getBaseCollider() const
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
btAlignedObjectArray< btQuaternion > m_scratch_world_to_local1
virtual btChunk * allocate(size_t size, int numElements)=0
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)
void serializeDynamicsWorldInfo(btSerializer *serializer)
btContactSolverInfo * m_solverInfo
void processConstraints()
const btScalar & z() const
Return the z value.
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
void setActivationState(int newState) const
int size() const
return the number of elements in the array
virtual void addMultiBody(btMultiBody *body, int group=btBroadphaseProxy::DefaultFilter, int mask=btBroadphaseProxy::AllFilter)
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)