56 int firstHit=startHit;
    77                         int rIslandId0,lIslandId0;
    80                         return lIslandId0 < rIslandId0;
   104                 m_sortedConstraints(NULL),
   107                 m_dispatcher(dispatcher)
   122                 m_solverInfo = solverInfo;
   123                 m_sortedConstraints = sortedConstraints;
   124                 m_numConstraints = numConstraints;
   125                 m_debugDrawer = debugDrawer;
   137                         m_solver->
solveGroup( bodies,numBodies,manifolds, numManifolds,&m_sortedConstraints[0],m_numConstraints,*m_solverInfo,m_debugDrawer,m_dispatcher);
   142                         int numCurConstraints = 0;
   146                         for (i=0;i<m_numConstraints;i++)
   150                                         startConstraint = &m_sortedConstraints[i];
   155                         for (;i<m_numConstraints;i++)
   165                                 m_solver->
solveGroup( bodies,numBodies,manifolds, numManifolds,startConstraint,numCurConstraints,*m_solverInfo,m_debugDrawer,m_dispatcher);
   169                                 for (i=0;i<numBodies;i++)
   171                                 for (i=0;i<numManifolds;i++)
   173                                 for (i=0;i<numCurConstraints;i++)
   174                                         m_constraints.
push_back(startConstraint[i]);
   177                                         processConstraints();
   192                 m_solver->
solveGroup( bodies,m_bodies.
size(),manifold, m_manifolds.
size(),constraints, m_constraints.
size() ,*m_solverInfo,m_debugDrawer,m_dispatcher);
   205 m_sortedConstraints     (),
   206 m_solverIslandCallback ( NULL ),
   207 m_constraintSolver(constraintSolver),
   211 m_synchronizeAllMotionStates(false),
   212 m_applySpeculativeContactRestitution(false),
   214 m_latencyMotionStateInterpolation(true)
   289         bool drawConstraints = 
false;
   295                         drawConstraints = 
true;
   368                                 interpolatedTransform);
   407         int numSimulationSubSteps = 0;
   416                         numSimulationSubSteps = int( 
m_localTime / fixedTimeStep);
   417                         m_localTime -= numSimulationSubSteps * fixedTimeStep;
   422                 fixedTimeStep = timeStep;
   427                         numSimulationSubSteps = 0;
   431                         numSimulationSubSteps = 1;
   442         if (numSimulationSubSteps)
   446                 int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps)? maxSubSteps : numSimulationSubSteps;
   454                 for (
int i=0;i<clampedSimulationSteps;i++)
   467 #ifndef BT_NO_PROFILE   469 #endif //BT_NO_PROFILE   471         return numSimulationSubSteps;
   480                 (*m_internalPreTickCallback)(
this, timeStep);
   520                 (*m_internalTickCallback)(
this, timeStep);
   616                 m_actions[i]->updateAction( 
this, timeStep);
   663         if (disableCollisionsBetweenLinkedBodies)
   757             if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
   758                 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
   768                 for (i=0;i< numConstraints ; i++ )
   776                                 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
   777                                         ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
   807                 m_allowedPenetration(0.0f),
   808                 m_pairCache(pairCache),
   809                 m_dispatcher(dispatcher)
   823                 linVelA = m_convexToWorld-m_convexFromWorld;
   826                 btVector3 relativeVelocity = (linVelA-linVelB);
   859                                         for (
int j=0;j<manifoldArray.
size();j++)
   884         for ( 
int i=0;i<numBodies;i++)
   902 #ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY   931                                         btTransform modifiedPredictedTrans = predictedTrans;
   935                                         if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
   939                                                 btScalar distance = distVec.
dot(-sweepResults.m_hitNormalWorld);
   948                                                 btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse()*worldPointB;
   952                                                 bool isPredictive = 
true;
   969     BT_PROFILE( 
"release predictive contact manifolds" );
   992         for (
int i=0;i<numBodies;i++)
  1012 #ifdef USE_STATIC_ONLY  1041                                         btTransform modifiedPredictedTrans = predictedTrans;
  1045                                         if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
  1058                                                 btScalar maxSpeedSqr = maxSpeed*maxSpeed;
  1059                                                 if (linVel.
length2()>maxSpeedSqr)
  1069                                                         printf(
"sm2=%f\n",sm2);
  1107                 BT_PROFILE(
"apply speculative contact restitution");
  1128                                         btVector3 rel_pos1 = pos2 - body1->getWorldTransform().getOrigin();
  1133                                                 body1->applyImpulse(-imp,rel_pos1);
  1166 #ifndef BT_NO_PROFILE  1168 #endif //BT_NO_PROFILE  1214                                 if(minAng == maxAng)
  1218                                 bool drawSect = 
true;
  1230                                         getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng, 
btVector3(0,0,0), drawSect);
  1245                                         static int nSegments = 8*4;
  1249                                         for (
int i=0; i<nSegments; i++)
  1256                                                 if (i%(nSegments/8) == 0)
  1275                                         getDebugDrawer()->
drawArc(pivot, normal, axis1, dbgDrawSize, dbgDrawSize, -twa-tws, -twa+tws, 
btVector3(0,0,0), 
true);
  1298                                         getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize * 
btScalar(.9f), minTh, maxTh, minPs, maxPs, 
btVector3(0,0,0));
  1307                                         ref[0] = cy*cz*axis[0] + cy*sz*axis[1] - sy*axis[2];
  1308                                         ref[1] = -sz*axis[0] + cz*axis[1];
  1309                                         ref[2] = cz*sy*axis[0] + sz*sy*axis[1] + cy*axis[2];
  1316                                                 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI, 
SIMD_PI, 
btVector3(0,0,0), 
false);
  1318                                         else if(minFi < maxFi)
  1320                                                 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi, 
btVector3(0,0,0), 
true);
  1348                                         getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize * 
btScalar(.9f), minTh, maxTh, minPs, maxPs, 
btVector3(0, 0, 0));
  1357                                         ref[0] = cy*cz*axis[0] + cy*sz*axis[1] - sy*axis[2];
  1358                                         ref[1] = -sz*axis[0] + cz*axis[1];
  1359                                         ref[2] = cz*sy*axis[0] + sz*sy*axis[1] + cy*axis[2];
  1366                                                 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI, 
SIMD_PI, 
btVector3(0, 0, 0), 
false);
  1368                                         else if (minFi < maxFi)
  1370                                                 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi, 
btVector3(0, 0, 0), 
true);
  1398                                         getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max, 
btVector3(0,0,0), 
true);
  1475 #ifdef BT_USE_DOUBLE_PRECISION  1485                 memset(worldInfo ,0x00,len);
  1515 #ifdef BT_USE_DOUBLE_PRECISION  1516                 const char* structType = 
"btDynamicsWorldDoubleData";
  1517 #else//BT_USE_DOUBLE_PRECISION  1518                 const char* structType = 
"btDynamicsWorldFloatData";
  1519 #endif//BT_USE_DOUBLE_PRECISION 
virtual void setConstraintSolver(btConstraintSolver *solver)
virtual void internalSingleStepSimulation(btScalar timeStep)
virtual void finishSerialization()=0
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
void serializeDynamicsWorldInfo(btSerializer *serializer)
const btRigidBody & getRigidBodyA() const
void startProfiling(btScalar timeStep)
btContactSolverInfo * m_solverInfo
virtual void releaseManifold(btPersistentManifold *manifold)=0
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep...
void serializeCollisionObjects(btSerializer *serializer)
btScalar length(const btQuaternion &q)
Return the length of a quaternion. 
btOverlappingPairCache * m_pairCache
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
const btVector3 & getInterpolationAngularVelocity() const
void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btIDebugDraw *debugDrawer)
void push_back(const T &_Val)
void btMutexLock(btSpinMutex *)
btScalar getUpperLimit() const
virtual void addAction(btActionInterface *)
virtual void solveConstraints(btContactSolverInfo &solverInfo)
point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocke...
bool operator()(const btTypedConstraint *lhs, const btTypedConstraint *rhs) const
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
virtual void removeVehicle(btActionInterface *vehicle)
obsolete, use removeAction instead 
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure) 
const btRigidBody & getRigidBodyB() const
int btGetConstraintIslandId(const btTypedConstraint *lhs)
btIDebugDraw * m_debugDrawer
const btVector3 & getPositionWorldOnA() const
const btVector3 & getPivotInA() const
#define BT_CONSTRAINT_CODE
const btTransform & getBFrame() const
btSimulationIslandManager * m_islandManager
const btTransform & getCalculatedTransformA() const
btScalar getLowerLimit() const
const btTransform & getCalculatedTransformB() const
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction 
virtual void addRigidBody(btRigidBody *body)
btScalar btSin(btScalar x)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
const btVector3 & getPivotInB() const
btScalar m_loLimit
limit_parameters 
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
virtual void setGravity(const btVector3 &gravity)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::StaticFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter)
const btTransform & getCenterOfMassTransform() const
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
btScalar m_combinedRestitution
virtual void removeCharacter(btActionInterface *character)
obsolete, use removeAction instead 
btScalar length2() const
Return the length of the vector squared. 
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
const btRigidBody & getRigidBodyB() const
virtual void startSerialization()=0
btTranslationalLimitMotor * getTranslationalLimitMotor()
Retrieves the limit informacion. 
void integrateTransformsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
bool gDisableDeactivation
virtual void drawBox(const btVector3 &bbMin, const btVector3 &bbMax, const btVector3 &color)
const btRigidBody & getRigidBodyA() const
SimulationIslandManager creates and handles simulation islands, using btUnionFind. 
int getNumContacts() const
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
btScalar m_appliedImpulse
btInternalTickCallback m_internalTickCallback
The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc. 
void releasePredictiveContacts()
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
virtual btVector3 getGravity() const
btAlignedObjectArray< btActionInterface * > m_actions
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, int islandId)
void setHitFraction(btScalar hitFraction)
#define BT_DYNAMICSWORLD_CODE
bool isKinematicObject() const
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 
btSimulationIslandManager * getSimulationIslandManager()
btScalar getLowerLinLimit()
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
#define SIMD_FORCE_INLINE
virtual void removeAction(btActionInterface *)
bool m_ownsConstraintSolver
The btSphereShape implements an implicit sphere, centered around a local origin with radius...
virtual void drawArc(const btVector3 ¢er, const btVector3 &normal, const btVector3 &axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle, const btVector3 &color, bool drawSect, btScalar stepDegrees=btScalar(10.f))
Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWor...
btVector3 m_upperLimit
the constraint upper limits 
ManifoldContactPoint collects and maintains persistent contactpoints. 
int getActivationState() const
btDispatcher * m_dispatcher1
class btIDebugDraw * m_debugDraw
virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace)
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
const btRigidBody & getRigidBodyB() const
const btTransform & getCalculatedTransformA() const
const btTransform & getAFrame() const
bool isStaticOrKinematicObject() const
btVector3 GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
btVector3FloatData m_gravity
btScalar getTwistAngle() const
The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out) ...
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1. 
int getNumCollisionObjects() const
const btCollisionShape * getCollisionShape() const
const btVector3 & getInterpolationLinearVelocity() const
const btTransform & getCalculatedTransformA() const
Gets the global transform of the offset for body A. 
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. 
const btManifoldPoint & getContactPoint(int index) const
btDispatcher * m_dispatcher
The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases. 
btContactSolverInfoFloatData m_solverInfo
void updateDeactivation(btScalar timeStep)
const btCollisionObject * m_hitCollisionObject
virtual void drawSpherePatch(const btVector3 ¢er, const btVector3 &up, const btVector3 &axis, btScalar radius, btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, const btVector3 &color, btScalar stepDegrees=btScalar(10.f), bool drawCenter=true)
btVector3 getColumn(int i) const
Get a column of the matrix as a vector. 
int m_collisionFilterMask
virtual btOverlappingPairCache * getOverlappingPairCache()=0
btCollisionWorld * getCollisionWorld()
btTransform & getWorldTransform()
btVector3 m_normalWorldOnB
btScalar getUpperAngLimit()
btVector3 m_positionWorldOnB
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
btInternalTickCallback m_internalPreTickCallback
void processConstraints()
btBroadphaseProxy * getBroadphaseHandle()
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see B...
const btVector3 & getLinearVelocity() const
btIDebugDraw * m_debugDrawer
const btTransform & getCalculatedTransformB() const
Gets the global transform of the offset for body B. 
btAlignedObjectArray< btCollisionObject * > m_bodies
virtual btIDebugDraw * getDebugDrawer()
btScalar getCcdSquareMotionThreshold() const
const btVector3 & getPositionWorldOnB() const
btConstraintSolver * m_solver
virtual void debugDrawWorld()
const btCollisionObject * getBody0() const
btVector3 m_hitNormalLocal
virtual btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
void addConstraintRef(btTypedConstraint *c)
bool isStaticObject() const
btScalar getInvMass() const
const btBroadphaseProxy * getBroadphaseProxy() const
btScalar dot(const btVector3 &v) const
Return the dot product. 
virtual void predictUnconstraintMotion(btScalar timeStep)
const btTransform & getCalculatedTransformB() const
btDispatcher * m_dispatcher
#define btAlignedFree(ptr)
btCollisionObject can be used to manage collision detection objects. 
virtual void saveKinematicState(btScalar timeStep)
virtual ~btDiscreteDynamicsWorld()
bool hasContactResponse() const
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
void setLinearVelocity(const btVector3 &lin_vel)
const btTransform & getInterpolationWorldTransform() const
virtual void flushLines()
btAlignedObjectArray< btPersistentManifold * > m_predictiveManifolds
The btRigidBody is the main class for rigid body objects. 
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity ...
virtual void removeCollisionObject(btCollisionObject *collisionObject)
btVector3 m_lowerLimit
the constraint lower limits 
int m_collisionFilterGroup
virtual btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)=0
virtual int calculateSerializeBufferSize() const
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
void proceedToTransform(const btTransform &newTrans)
btDispatcher * getDispatcher()
virtual btConstraintSolver * getConstraintSolver()
virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace)
int gNumClampedCcdMotions
internal debugging variable. this value shouldn't be too high 
btScalar getUpperLinLimit()
btAlignedObjectArray< btPersistentManifold * > m_manifolds
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. 
virtual int stepSimulation(btScalar timeStep, int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.))
if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's 
virtual void createPredictiveContacts(btScalar timeStep)
btCollisionAlgorithm * m_algorithm
virtual void applyGravity()
apply gravity, call this once per timestep 
The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (...
InplaceSolverIslandCallback(btConstraintSolver *solver, btStackAlloc *stackAlloc, btDispatcher *dispatcher)
static btScalar calculateCombinedFriction(const btCollisionObject *body0, const btCollisionObject *body1)
User can override this material combiner by implementing gContactAddedCallback and setting body0->m_c...
btVector3 can be used to represent 3D points and vectors. 
const btTransform & getAFrame() const
virtual void getAllContactManifolds(btManifoldArray &manifoldArray)=0
int size() const
return the number of elements in the array 
virtual void debugDrawConstraint(btTypedConstraint *constraint)
bool getUseLinearReferenceFrameA()
void btMutexUnlock(btSpinMutex *)
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc) ...
virtual void calculateSimulationIslands()
void serialize(struct btVector3Data &dataOut) const
btScalar getCcdMotionThreshold() const
virtual void removeConstraint(btTypedConstraint *constraint)
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
static void Increment_Frame_Counter(void)
btScalar m_hiLimit
joint limit 
CollisionWorld is interface and container for the collision detection. 
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
void updateActions(btScalar timeStep)
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping ...
virtual btTypedConstraint * getConstraint(int index)
void convexSweepTest(const btConvexShape *castShape, const btTransform &from, const btTransform &to, ConvexResultCallback &resultCallback, btScalar allowedCcdPenetration=btScalar(0.)) const
convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultC...
btScalar getAngle(int axis_index) const
btDispatcherInfo & getDispatchInfo()
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure) 
bool m_latencyMotionStateInterpolation
btScalar getHitFraction() const
virtual void prepareSolve(int, int)
#define WANTS_DEACTIVATION
void remove(const T &key)
btScalar m_allowedCcdPenetration
virtual void drawTransform(const btTransform &transform, btScalar orthoLen)
TypedConstraint is the baseclass for Bullet constraints and vehicles. 
void synchronizeSingleMotionState(btRigidBody *body)
this can be useful to synchronize a single rigid body -> graphics object 
void saveKinematicState(btScalar step)
void resize(int newsize, const T &fillData=T())
bool btFuzzyZero(btScalar x)
bool m_synchronizeAllMotionStates
virtual void integrateTransforms(btScalar timeStep)
const btCollisionObject * getBody1() const
btRotationalLimitMotor * getRotationalLimitMotor(int index)
Retrieves the angular limit informacion. 
int getInternalType() const
reserved for Bullet internal usage 
void setAngularVelocity(const btVector3 &ang_vel)
virtual int getDebugMode() const =0
btClosestNotMeConvexResultCallback(btCollisionObject *me, const btVector3 &fromA, const btVector3 &toA, btOverlappingPairCache *pairCache, btDispatcher *dispatcher)
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
virtual void synchronizeMotionStates()
btDiscreteDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration)
this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete thos...
#define BT_RIGIDBODY_CODE
virtual void storeIslandActivationState(btCollisionWorld *world)
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
#define DISABLE_DEACTIVATION
virtual void performDiscreteCollisionDetection()
btScalar m_combinedFriction
btUnionFind & getUnionFind()
InplaceSolverIslandCallback * m_solverIslandCallback
virtual void addCharacter(btActionInterface *character)
obsolete, use addAction instead 
#define btAlignedAlloc(size, alignment)
virtual int calculateSerializeBufferSize() const
btSpinMutex m_predictiveManifoldsMutex
bool m_applySpeculativeContactRestitution
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btConstraintSolver * m_constraintSolver
btScalar getTwistSpan() const
btMotionState * getMotionState()
btTypedConstraintType getConstraintType() const
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
btScalar getLowerAngLimit()
virtual int getNumConstraints() const
void serializeRigidBodies(btSerializer *serializer)
btScalar m_allowedPenetration
virtual void updateActivationState(btScalar timeStep)
btScalar getAngle(int axis_index) const
Get the relative Euler angle. 
btAlignedObjectArray< btTypedConstraint * > m_constraints
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: 
void createPredictiveContactsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
virtual void addVehicle(btActionInterface *vehicle)
obsolete, use addAction instead 
InplaceSolverIslandCallback & operator=(InplaceSolverIslandCallback &other)
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
virtual void removeRigidBody(btRigidBody *body)
virtual void debugDrawWorld()
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
void removeConstraintRef(btTypedConstraint *c)
const btRigidBody & getRigidBodyA() const
static btScalar calculateCombinedRestitution(const btCollisionObject *body0, const btCollisionObject *body1)
in the future we can let the user override the methods to combine restitution and friction ...
btScalar getDbgDrawSize()
btContactSolverInfo & getSolverInfo()
const btBroadphaseInterface * getBroadphase() const
virtual void setWorldTransform(const btTransform &worldTrans)=0
void setActivationState(int newState) const
int addManifoldPoint(const btManifoldPoint &newPoint, bool isPredictive=false)
virtual btChunk * allocate(size_t size, int numElements)=0
const btTransform & getBFrame() const
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
void quickSort(const L &CompareFunc)
btScalar btCos(btScalar x)
virtual ~btSimulationIslandManager()
virtual ~btConstraintSolver()
btAlignedObjectArray< btTypedConstraint * > m_constraints
void setGravity(const btVector3 &acceleration)
btTypedConstraint ** m_sortedConstraints
The btBroadphasePair class contains a pair of aabb-overlapping objects.