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);
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())))
806 m_allowedPenetration(0.0f),
807 m_pairCache(pairCache),
808 m_dispatcher(dispatcher)
822 linVelA = m_convexToWorld-m_convexFromWorld;
825 btVector3 relativeVelocity = (linVelA-linVelB);
861 for (
int j=0;j<manifoldArray.
size();j++)
886 for (
int i=0;i<numBodies;i++)
904 #ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY 933 btTransform modifiedPredictedTrans = predictedTrans;
937 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
941 btScalar distance = distVec.
dot(-sweepResults.m_hitNormalWorld);
950 btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse()*worldPointB;
954 bool isPredictive =
true;
971 BT_PROFILE(
"release predictive contact manifolds" );
994 for (
int i=0;i<numBodies;i++)
1014 #ifdef USE_STATIC_ONLY 1043 btTransform modifiedPredictedTrans = predictedTrans;
1047 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
1060 btScalar maxSpeedSqr = maxSpeed*maxSpeed;
1061 if (linVel.
length2()>maxSpeedSqr)
1071 printf(
"sm2=%f\n",sm2);
1109 BT_PROFILE(
"apply speculative contact restitution");
1130 btVector3 rel_pos1 = pos2 - body1->getWorldTransform().getOrigin();
1135 body1->applyImpulse(-imp,rel_pos1);
1168 #ifndef BT_NO_PROFILE 1170 #endif //BT_NO_PROFILE 1216 if(minAng == maxAng)
1220 bool drawSect =
true;
1232 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng,
btVector3(0,0,0), drawSect);
1247 static int nSegments = 8*4;
1251 for (
int i=0; i<nSegments; i++)
1258 if (i%(nSegments/8) == 0)
1277 getDebugDrawer()->
drawArc(pivot, normal, axis1, dbgDrawSize, dbgDrawSize, -twa-tws, -twa+tws,
btVector3(0,0,0),
true);
1300 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0,0,0));
1309 ref[0] = cy*cz*axis[0] + cy*sz*axis[1] - sy*axis[2];
1310 ref[1] = -sz*axis[0] + cz*axis[1];
1311 ref[2] = cz*sy*axis[0] + sz*sy*axis[1] + cy*axis[2];
1318 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0,0,0),
false);
1320 else if(minFi < maxFi)
1322 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0,0,0),
true);
1352 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1362 ref[0] = cy*cz*axis[0] + cy*sz*axis[1] - sy*axis[2];
1363 ref[1] = -sz*axis[0] + cz*axis[1];
1364 ref[2] = cz*sy*axis[0] + sz*sy*axis[1] + cy*axis[2];
1371 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1373 else if (minFi < maxFi)
1375 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1403 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max,
btVector3(0,0,0),
true);
1480 #ifdef BT_USE_DOUBLE_PRECISION 1490 memset(worldInfo ,0x00,len);
1523 #ifdef BT_USE_DOUBLE_PRECISION 1524 const char* structType =
"btDynamicsWorldDoubleData";
1525 #else//BT_USE_DOUBLE_PRECISION 1526 const char* structType =
"btDynamicsWorldFloatData";
1527 #endif//BT_USE_DOUBLE_PRECISION
btScalar getInvMass() const
virtual void setConstraintSolver(btConstraintSolver *solver)
const btCollisionShape * getCollisionShape() const
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)
void startProfiling(btScalar timeStep)
btContactSolverInfo * m_solverInfo
virtual void releaseManifold(btPersistentManifold *manifold)=0
btScalar getCcdMotionThreshold() const
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep...
const btTransform & getAFrame() const
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...
void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btIDebugDraw *debugDrawer)
void push_back(const T &_Val)
const btTransform & getCalculatedTransformA() 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...
btTypedConstraintType getConstraintType() const
const btTransform & getCalculatedTransformB() const
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
virtual void removeVehicle(btActionInterface *vehicle)
obsolete, use removeAction instead
virtual btVector3 getGravity() const
int btGetConstraintIslandId(const btTypedConstraint *lhs)
void serializeContactManifolds(btSerializer *serializer)
btIDebugDraw * m_debugDrawer
#define BT_CONSTRAINT_CODE
btSimulationIslandManager * m_islandManager
const btTransform & getCalculatedTransformA() const
Gets the global transform of the offset for body A.
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 ...
btScalar m_loLimit
limit_parameters
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
virtual void setGravity(const btVector3 &gravity)
const btTransform & getCalculatedTransformB() const
Gets the global transform of the offset for body B.
const btRigidBody & getRigidBodyB() const
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
btScalar m_combinedRestitution
virtual void removeCharacter(btActionInterface *character)
obsolete, use removeAction instead
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
virtual void startSerialization()=0
btTranslationalLimitMotor * getTranslationalLimitMotor()
Retrieves the limit informacion.
int getInternalType() const
reserved for Bullet internal usage
const btVector3 & getInterpolationAngularVelocity() const
void integrateTransformsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
virtual int calculateSerializeBufferSize() const
bool gDisableDeactivation
virtual void drawBox(const btVector3 &bbMin, const btVector3 &bbMax, const btVector3 &color)
SimulationIslandManager creates and handles simulation islands, using btUnionFind.
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
CalculateCombinedCallback gCalculateCombinedRestitutionCallback
const btTransform & getBFrame() const
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)
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
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
int getNumCollisionObjects() const
virtual void removeAction(btActionInterface *)
bool m_ownsConstraintSolver
The btSphereShape implements an implicit sphere, centered around a local origin with radius...
btScalar getTwistSpan() const
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.
const btCollisionObject * getBody0() const
btDispatcher * m_dispatcher1
btVector3 getColumn(int i) const
Get a column of the matrix as a vector.
const btRigidBody & getRigidBodyA() const
class btIDebugDraw * m_debugDraw
virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace)
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
const btVector3 & getInterpolationLinearVelocity() const
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
btScalar dot(const btVector3 &v) const
Return the dot product.
bool hasContactResponse() const
btVector3FloatData m_gravity
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.
btScalar getCcdSquareMotionThreshold() const
const btTransform & getInterpolationWorldTransform() 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.
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)
int m_collisionFilterMask
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
virtual btOverlappingPairCache * getOverlappingPairCache()=0
btCollisionWorld * getCollisionWorld()
void setActivationState(int newState) const
btTransform & getWorldTransform()
btVector3 m_normalWorldOnB
btScalar getUpperAngLimit()
btVector3 m_positionWorldOnB
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
btInternalTickCallback m_internalPreTickCallback
void processConstraints()
int size() const
return the number of elements in the array
btBroadphaseProxy * getBroadphaseHandle()
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see B...
btScalar getUpperLimit() const
btIDebugDraw * m_debugDrawer
btAlignedObjectArray< btCollisionObject * > m_bodies
virtual btIDebugDraw * getDebugDrawer()
const btTransform & getCenterOfMassTransform() const
bool isKinematicObject() const
btConstraintSolver * m_solver
virtual void debugDrawWorld()
btVector3 m_hitNormalLocal
virtual btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
void addConstraintRef(btTypedConstraint *c)
bool isStaticObject() const
const btVector3 & getPivotInA() const
btScalar getAngle(int axis_index) const
Get the relative Euler angle.
virtual void predictUnconstraintMotion(btScalar timeStep)
btDispatcher * m_dispatcher
bool isStaticOrKinematicObject() const
void serialize(struct btVector3Data &dataOut) const
#define btAlignedFree(ptr)
btCollisionObject can be used to manage collision detection objects.
virtual void saveKinematicState(btScalar timeStep)
virtual ~btDiscreteDynamicsWorld()
btScalar getLowerLimit() const
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
void setLinearVelocity(const btVector3 &lin_vel)
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
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
void proceedToTransform(const btTransform &newTrans)
const btManifoldPoint & getContactPoint(int index) const
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
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
const btTransform & getCalculatedTransformB() const
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)
btScalar getHitFraction() const
const btVector3 & getPositionWorldOnB() const
btVector3 can be used to represent 3D points and vectors.
virtual void getAllContactManifolds(btManifoldArray &manifoldArray)=0
btScalar length2() const
Return the length of the vector squared.
const btTransform & getAFrame() const
virtual void debugDrawConstraint(btTypedConstraint *constraint)
const btBroadphaseInterface * getBroadphase() const
bool getUseLinearReferenceFrameA()
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc) ...
virtual void calculateSimulationIslands()
virtual int getNumConstraints() const
bool operator()(const btTypedConstraint *lhs, const btTypedConstraint *rhs) 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)
btDispatcherInfo & getDispatchInfo()
const btTransform & getCalculatedTransformA() const
bool m_latencyMotionStateInterpolation
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)
int getNumContacts() const
bool m_synchronizeAllMotionStates
virtual void integrateTransforms(btScalar timeStep)
btRotationalLimitMotor * getRotationalLimitMotor(int index)
Retrieves the angular limit informacion.
const btRigidBody & getRigidBodyA() const
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 const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
virtual int calculateSerializeBufferSize() const
virtual void performDiscreteCollisionDetection()
const btBroadphaseProxy * getBroadphaseProxy() const
btScalar m_combinedFriction
void btMutexLock(btSpinMutex *mutex)
btUnionFind & getUnionFind()
InplaceSolverIslandCallback * m_solverIslandCallback
const btVector3 & getPositionWorldOnA() const
virtual void addCharacter(btActionInterface *character)
obsolete, use addAction instead
#define btAlignedAlloc(size, alignment)
btVector3 GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const
btSpinMutex m_predictiveManifoldsMutex
bool m_applySpeculativeContactRestitution
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btConstraintSolver * m_constraintSolver
btMotionState * getMotionState()
const btRigidBody & getRigidBodyA() const
const btVector3 & getLinearVelocity() const
const btVector3 & getPivotInB() const
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
btScalar getLowerAngLimit()
void serializeRigidBodies(btSerializer *serializer)
btScalar m_allowedPenetration
virtual void updateActivationState(btScalar timeStep)
btAlignedObjectArray< btTypedConstraint * > m_constraints
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...
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)=0
const btRigidBody & getRigidBodyB() const
void createPredictiveContactsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
virtual void addVehicle(btActionInterface *vehicle)
obsolete, use addAction instead
InplaceSolverIslandCallback & operator=(InplaceSolverIslandCallback &other)
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)
btScalar getDbgDrawSize()
const btTransform & getBFrame() const
btScalar getTwistAngle() const
int getActivationState() const
btContactSolverInfo & getSolverInfo()
CalculateCombinedCallback gCalculateCombinedFrictionCallback
const btRigidBody & getRigidBodyB() const
virtual void setWorldTransform(const btTransform &worldTrans)=0
const btCollisionObject * getBody1() const
int addManifoldPoint(const btManifoldPoint &newPoint, bool isPredictive=false)
virtual btChunk * allocate(size_t size, int numElements)=0
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::StaticFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter^btBroadphaseProxy::StaticFilter)
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)
btScalar getAngle(int axis_index) const
btTypedConstraint ** m_sortedConstraints
The btBroadphasePair class contains a pair of aabb-overlapping objects.