53 int firstHit=startHit;
71 int rIslandId0, lIslandId0;
74 return lIslandId0 < rIslandId0;
134 int numCurConstraints = 0;
161 for (i = 0; i < numBodies; i++)
163 for (i = 0; i < numManifolds; i++)
165 for (i = 0; i < numCurConstraints; i++)
193 m_sortedConstraints(),
194 m_solverIslandCallback(NULL),
195 m_constraintSolver(constraintSolver),
196 m_gravity(0, -10, 0),
199 m_synchronizeAllMotionStates(false),
200 m_applySpeculativeContactRestitution(false),
202 m_latencyMotionStateInterpolation(true)
275 bool drawConstraints =
false;
281 drawConstraints =
true;
350 interpolatedTransform);
386 int numSimulationSubSteps = 0;
395 numSimulationSubSteps = int(
m_localTime / fixedTimeStep);
396 m_localTime -= numSimulationSubSteps * fixedTimeStep;
402 fixedTimeStep = timeStep;
407 numSimulationSubSteps = 0;
412 numSimulationSubSteps = 1;
423 if (numSimulationSubSteps)
426 int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps) ? maxSubSteps : numSimulationSubSteps;
432 for (
int i = 0; i < clampedSimulationSteps; i++)
445 #ifndef BT_NO_PROFILE 446 CProfileManager::Increment_Frame_Counter();
447 #endif //BT_NO_PROFILE 449 return numSimulationSubSteps;
458 (*m_internalPreTickCallback)(
this, timeStep);
495 (*m_internalTickCallback)(
this, timeStep);
590 m_actions[i]->updateAction(
this, timeStep);
637 if (disableCollisionsBetweenLinkedBodies)
724 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
725 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
735 for (i = 0; i < numConstraints; i++)
743 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
744 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
786 btVector3 relativeVelocity = (linVelA - linVelB);
791 return ClosestConvexResultCallback::addSingleResult(convexResult, normalInWorldSpace);
801 if (!ClosestConvexResultCallback::needsCollision(proxy0))
822 for (
int j=0;j<manifoldArray.
size();j++)
844 for (
int i = 0; i < numBodies; i++)
861 #ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY 888 btTransform modifiedPredictedTrans = predictedTrans;
892 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
895 btScalar distance = distVec.
dot(-sweepResults.m_hitNormalWorld);
903 btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse() * worldPointB;
907 bool isPredictive =
true;
923 BT_PROFILE(
"release predictive contact manifolds");
946 for (
int i = 0; i < numBodies; i++)
963 #ifdef USE_STATIC_ONLY 990 btTransform modifiedPredictedTrans = predictedTrans;
994 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
1006 btScalar maxSpeedSqr = maxSpeed*maxSpeed;
1007 if (linVel.
length2()>maxSpeedSqr)
1017 printf(
"sm2=%f\n",sm2);
1050 BT_PROFILE(
"apply speculative contact restitution");
1071 btVector3 rel_pos1 = pos2 - body1->getWorldTransform().getOrigin();
1076 body1->applyImpulse(-imp, rel_pos1);
1104 #ifndef BT_NO_PROFILE 1105 CProfileManager::Reset();
1106 #endif //BT_NO_PROFILE 1146 if (minAng == maxAng)
1150 bool drawSect =
true;
1162 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng,
btVector3(0, 0, 0), drawSect);
1177 static int nSegments = 8 * 4;
1181 for (
int i = 0; i < nSegments; i++)
1188 if (i % (nSegments / 8) == 0)
1207 getDebugDrawer()->
drawArc(pivot, normal, axis1, dbgDrawSize, dbgDrawSize, -twa - tws, -twa + tws,
btVector3(0, 0, 0),
true);
1229 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1238 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2];
1239 ref[1] = -sz * axis[0] + cz * axis[1];
1240 ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2];
1247 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1249 else if (minFi < maxFi)
1251 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1281 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1291 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2];
1292 ref[1] = -sz * axis[0] + cz * axis[1];
1293 ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2];
1300 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1302 else if (minFi < maxFi)
1304 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1332 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max,
btVector3(0, 0, 0),
true);
1399 #ifdef BT_USE_DOUBLE_PRECISION 1409 memset(worldInfo, 0x00, len);
1442 #ifdef BT_USE_DOUBLE_PRECISION 1443 const char* structType =
"btDynamicsWorldDoubleData";
1444 #else //BT_USE_DOUBLE_PRECISION 1445 const char* structType =
"btDynamicsWorldFloatData";
1446 #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)
void serializeContactManifolds(btSerializer *serializer)
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)
CalculateCombinedCallback gCalculateCombinedRestitutionCallback
btScalar m_appliedImpulse
btInternalTickCallback m_internalTickCallback
btVector3 m_convexToWorld
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.
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), 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.
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)
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
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
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)=0
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
btScalar getDbgDrawSize()
btContactSolverInfo & getSolverInfo()
CalculateCombinedCallback gCalculateCombinedFrictionCallback
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.