56 int firstHit=startHit;
77 int rIslandId0,lIslandId0;
80 return lIslandId0 < rIslandId0;
142 int numCurConstraints = 0;
169 for (i=0;i<numBodies;i++)
171 for (i=0;i<numManifolds;i++)
173 for (i=0;i<numCurConstraints;i++)
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);
406 int numSimulationSubSteps = 0;
415 numSimulationSubSteps = int(
m_localTime / fixedTimeStep);
416 m_localTime -= numSimulationSubSteps * fixedTimeStep;
421 fixedTimeStep = timeStep;
426 numSimulationSubSteps = 0;
430 numSimulationSubSteps = 1;
441 if (numSimulationSubSteps)
445 int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps)? maxSubSteps : numSimulationSubSteps;
453 for (
int i=0;i<clampedSimulationSteps;i++)
466 #ifndef BT_NO_PROFILE 468 #endif //BT_NO_PROFILE 470 return numSimulationSubSteps;
479 (*m_internalPreTickCallback)(
this, timeStep);
519 (*m_internalTickCallback)(
this, timeStep);
615 m_actions[i]->updateAction(
this, timeStep);
662 if (disableCollisionsBetweenLinkedBodies)
756 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
757 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
767 for (i=0;i< numConstraints ; i++ )
775 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
776 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
825 btVector3 relativeVelocity = (linVelA-linVelB);
830 return ClosestConvexResultCallback::addSingleResult (convexResult, normalInWorldSpace);
840 if (!ClosestConvexResultCallback::needsCollision(proxy0))
858 for (
int j=0;j<manifoldArray.
size();j++)
883 for (
int i=0;i<numBodies;i++)
901 #ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY 930 btTransform modifiedPredictedTrans = predictedTrans;
934 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
938 btScalar distance = distVec.
dot(-sweepResults.m_hitNormalWorld);
947 btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse()*worldPointB;
951 bool isPredictive =
true;
968 BT_PROFILE(
"release predictive contact manifolds" );
991 for (
int i=0;i<numBodies;i++)
1011 #ifdef USE_STATIC_ONLY 1040 btTransform modifiedPredictedTrans = predictedTrans;
1044 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
1057 btScalar maxSpeedSqr = maxSpeed*maxSpeed;
1058 if (linVel.
length2()>maxSpeedSqr)
1068 printf(
"sm2=%f\n",sm2);
1106 BT_PROFILE(
"apply speculative contact restitution");
1127 btVector3 rel_pos1 = pos2 - body1->getWorldTransform().getOrigin();
1132 body1->applyImpulse(-imp,rel_pos1);
1165 #ifndef BT_NO_PROFILE 1167 #endif //BT_NO_PROFILE 1213 if(minAng == maxAng)
1217 bool drawSect =
true;
1229 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng,
btVector3(0,0,0), drawSect);
1244 static int nSegments = 8*4;
1248 for (
int i=0; i<nSegments; i++)
1255 if (i%(nSegments/8) == 0)
1274 getDebugDrawer()->
drawArc(pivot, normal, axis1, dbgDrawSize, dbgDrawSize, -twa-tws, -twa+tws,
btVector3(0,0,0),
true);
1297 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0,0,0));
1306 ref[0] = cy*cz*axis[0] + cy*sz*axis[1] - sy*axis[2];
1307 ref[1] = -sz*axis[0] + cz*axis[1];
1308 ref[2] = cz*sy*axis[0] + sz*sy*axis[1] + cy*axis[2];
1315 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0,0,0),
false);
1317 else if(minFi < maxFi)
1319 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0,0,0),
true);
1347 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1356 ref[0] = cy*cz*axis[0] + cy*sz*axis[1] - sy*axis[2];
1357 ref[1] = -sz*axis[0] + cz*axis[1];
1358 ref[2] = cz*sy*axis[0] + sz*sy*axis[1] + cy*axis[2];
1365 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1367 else if (minFi < maxFi)
1369 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1397 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max,
btVector3(0,0,0),
true);
1474 #ifdef BT_USE_DOUBLE_PRECISION 1484 memset(worldInfo ,0x00,len);
1517 #ifdef BT_USE_DOUBLE_PRECISION 1518 const char* structType =
"btDynamicsWorldDoubleData";
1519 #else//BT_USE_DOUBLE_PRECISION 1520 const char* structType =
"btDynamicsWorldFloatData";
1521 #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)
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
btVector3 m_convexToWorld
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
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.
btVector3 m_convexFromWorld
int getActivationState() const
btDispatcher * m_dispatcher1
class btIDebugDraw * m_debugDraw
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.
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
const btManifoldPoint & getContactPoint(int index) const
btDispatcher * m_dispatcher
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
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.
ClosestConvexResultCallback(const btVector3 &convexFromWorld, const btVector3 &convexToWorld)
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()
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 btMutexUnlock(btSpinMutex *mutex)
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
void btMutexLock(btSpinMutex *mutex)
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.