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();
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))
830 for (
int j=0;j<manifoldArray.
size();j++)
852 for (
int i = 0; i < numBodies; i++)
869 #ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY
896 btTransform modifiedPredictedTrans = predictedTrans;
900 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
903 btScalar distance = distVec.
dot(-sweepResults.m_hitNormalWorld);
911 btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse() * worldPointB;
915 bool isPredictive =
true;
931 BT_PROFILE(
"release predictive contact manifolds");
954 for (
int i = 0; i < numBodies; i++)
971 #ifdef USE_STATIC_ONLY
998 btTransform modifiedPredictedTrans = predictedTrans;
1002 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
1014 btScalar maxSpeedSqr = maxSpeed*maxSpeed;
1015 if (linVel.
length2()>maxSpeedSqr)
1025 printf(
"sm2=%f\n",sm2);
1058 BT_PROFILE(
"apply speculative contact restitution");
1112 #ifndef BT_NO_PROFILE
1113 CProfileManager::Reset();
1154 if (minAng == maxAng)
1158 bool drawSect =
true;
1170 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng,
btVector3(0, 0, 0), drawSect);
1185 static int nSegments = 8 * 4;
1189 for (
int i = 0; i < nSegments; i++)
1196 if (i % (nSegments / 8) == 0)
1215 getDebugDrawer()->
drawArc(pivot, normal, axis1, dbgDrawSize, dbgDrawSize, -twa - tws, -twa + tws,
btVector3(0, 0, 0),
true);
1237 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1246 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2];
1247 ref[1] = -sz * axis[0] + cz * axis[1];
1248 ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2];
1255 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1257 else if (minFi < maxFi)
1259 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1289 getDebugDrawer()->
drawSpherePatch(center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1299 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2];
1300 ref[1] = -sz * axis[0] + cz * axis[1];
1301 ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2];
1308 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1310 else if (minFi < maxFi)
1312 getDebugDrawer()->
drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1340 getDebugDrawer()->
drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max,
btVector3(0, 0, 0),
true);
1407 #ifdef BT_USE_DOUBLE_PRECISION
1417 memset(worldInfo, 0x00, len);
1448 #ifdef BT_USE_DOUBLE_PRECISION
1449 const char* structType =
"btDynamicsWorldDoubleData";
1451 const char* structType =
"btDynamicsWorldFloatData";
#define btAlignedFree(ptr)
#define btAlignedAlloc(size, alignment)
#define DISABLE_DEACTIVATION
#define WANTS_DEACTIVATION
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
int btGetConstraintIslandId(const btTypedConstraint *lhs)
int gNumClampedCcdMotions
internal debugging variable. this value shouldn't be too high
CalculateCombinedCallback gCalculateCombinedFrictionCallback
CalculateCombinedCallback gCalculateCombinedRestitutionCallback
btScalar length(const btQuaternion &q)
Return the length of a quaternion.
bool gDisableDeactivation
@ BT_DISABLE_WORLD_GRAVITY
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
btScalar btSin(btScalar x)
#define SIMD_FORCE_INLINE
btScalar btCos(btScalar x)
bool btFuzzyZero(btScalar x)
#define BT_RIGIDBODY_CODE
#define BT_DYNAMICSWORLD_CODE
#define BT_CONSTRAINT_CODE
void btMutexLock(btSpinMutex *mutex)
void btMutexUnlock(btSpinMutex *mutex)
@ CONETWIST_CONSTRAINT_TYPE
@ POINT2POINT_CONSTRAINT_TYPE
@ D6_SPRING_2_CONSTRAINT_TYPE
@ D6_SPRING_CONSTRAINT_TYPE
Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWor...
int size() const
return the number of elements in the array
void resize(int newsize, const T &fillData=T())
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
void remove(const T &key)
void quickSort(const L &CompareFunc)
void push_back(const T &_Val)
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
btDispatcher * m_dispatcher
btClosestNotMeConvexResultCallback(btCollisionObject *me, const btVector3 &fromA, const btVector3 &toA, btOverlappingPairCache *pairCache, btDispatcher *dispatcher)
virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace)
btOverlappingPairCache * m_pairCache
btScalar m_allowedPenetration
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
virtual void getAllContactManifolds(btManifoldArray &manifoldArray)=0
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
btCollisionObject can be used to manage collision detection objects.
const btTransform & getInterpolationWorldTransform() const
bool isStaticOrKinematicObject() const
btScalar getHitFraction() const
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btTransform & getWorldTransform()
const btVector3 & getInterpolationAngularVelocity() const
btBroadphaseProxy * getBroadphaseHandle()
const btVector3 & getInterpolationLinearVelocity() const
int getInternalType() const
reserved for Bullet internal usage
bool hasContactResponse() const
bool isStaticObject() const
void setActivationState(int newState) const
virtual int calculateSerializeBufferSize() const
bool isKinematicObject() const
btScalar getCcdMotionThreshold() const
void setHitFraction(btScalar hitFraction)
int getActivationState() const
btScalar getCcdSquareMotionThreshold() const
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
CollisionWorld is interface and container for the collision detection.
virtual void debugDrawWorld()
const btBroadphaseInterface * getBroadphase() const
virtual void removeCollisionObject(btCollisionObject *collisionObject)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
btDispatcher * getDispatcher()
virtual btIDebugDraw * getDebugDrawer()
int getNumCollisionObjects() const
virtual void performDiscreteCollisionDetection()
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...
btIDebugDraw * m_debugDrawer
btDispatcherInfo & getDispatchInfo()
btDispatcher * m_dispatcher1
void serializeContactManifolds(btSerializer *serializer)
void serializeCollisionObjects(btSerializer *serializer)
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
btScalar getTwistAngle() const
btVector3 GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const
const btTransform & getAFrame() const
const btRigidBody & getRigidBodyB() const
btScalar getTwistSpan() const
const btRigidBody & getRigidBodyA() const
const btTransform & getBFrame() const
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
virtual ~btConstraintSolver()
virtual void prepareSolve(int, int)
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
void updateActions(btScalar timeStep)
virtual void removeAction(btActionInterface *)
btAlignedObjectArray< btPersistentManifold * > m_predictiveManifolds
void integrateTransformsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
virtual void calculateSimulationIslands()
btSimulationIslandManager * getSimulationIslandManager()
virtual void setGravity(const btVector3 &gravity)
virtual void removeConstraint(btTypedConstraint *constraint)
virtual void integrateTransforms(btScalar timeStep)
void synchronizeSingleMotionState(btRigidBody *body)
this can be useful to synchronize a single rigid body -> graphics object
bool m_latencyMotionStateInterpolation
void createPredictiveContactsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
virtual void addVehicle(btActionInterface *vehicle)
obsolete, use addAction instead
virtual btConstraintSolver * getConstraintSolver()
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see B...
void serializeRigidBodies(btSerializer *serializer)
virtual void internalSingleStepSimulation(btScalar timeStep)
virtual void addRigidBody(btRigidBody *body)
virtual void removeRigidBody(btRigidBody *body)
virtual btTypedConstraint * getConstraint(int index)
void serializeDynamicsWorldInfo(btSerializer *serializer)
btCollisionWorld * getCollisionWorld()
bool m_applySpeculativeContactRestitution
virtual void addAction(btActionInterface *)
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
btDiscreteDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration)
this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete thos...
virtual void setConstraintSolver(btConstraintSolver *solver)
virtual void synchronizeMotionStates()
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 saveKinematicState(btScalar timeStep)
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
virtual void addCharacter(btActionInterface *character)
obsolete, use addAction instead
virtual btVector3 getGravity() const
InplaceSolverIslandCallback * m_solverIslandCallback
virtual void applyGravity()
apply gravity, call this once per timestep
btSimulationIslandManager * m_islandManager
virtual void createPredictiveContacts(btScalar timeStep)
btAlignedObjectArray< btTypedConstraint * > m_constraints
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
btAlignedObjectArray< btActionInterface * > m_actions
bool m_ownsConstraintSolver
virtual int getNumConstraints() const
virtual void removeCharacter(btActionInterface *character)
obsolete, use removeAction instead
btSpinMutex m_predictiveManifoldsMutex
virtual void updateActivationState(btScalar timeStep)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::StaticFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter)
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
btConstraintSolver * m_constraintSolver
virtual void debugDrawConstraint(btTypedConstraint *constraint)
virtual void debugDrawWorld()
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
bool m_synchronizeAllMotionStates
virtual void solveConstraints(btContactSolverInfo &solverInfo)
virtual ~btDiscreteDynamicsWorld()
virtual void predictUnconstraintMotion(btScalar timeStep)
void releasePredictiveContacts()
virtual void removeVehicle(btActionInterface *vehicle)
obsolete, use removeAction instead
void startProfiling(btScalar timeStep)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
virtual void releaseManifold(btPersistentManifold *manifold)=0
virtual btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)=0
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)=0
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
btInternalTickCallback m_internalTickCallback
btInternalTickCallback m_internalPreTickCallback
btContactSolverInfo & getSolverInfo()
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
btRotationalLimitMotor * getRotationalLimitMotor(int index)
Retrieves the angular limit informacion.
btTranslationalLimitMotor * getTranslationalLimitMotor()
Retrieves the limit informacion.
const btTransform & getCalculatedTransformA() const
Gets the global transform of the offset for body A.
btScalar getAngle(int axis_index) const
Get the relative Euler angle.
const btTransform & getCalculatedTransformB() const
Gets the global transform of the offset for body B.
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
const btTransform & getCalculatedTransformB() const
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
btScalar getAngle(int axis_index) const
const btTransform & getCalculatedTransformA() const
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
btScalar getUpperLimit() const
btScalar getLowerLimit() const
const btRigidBody & getRigidBodyA() const
const btRigidBody & getRigidBodyB() const
const btTransform & getAFrame() const
const btTransform & getBFrame() const
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
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))
virtual void flushLines()
virtual void drawTransform(const btTransform &transform, btScalar orthoLen)
virtual int getDebugMode() const =0
virtual void drawBox(const btVector3 &bbMin, const btVector3 &bbMax, const btVector3 &color)
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)
@ DBG_DrawConstraintLimits
ManifoldContactPoint collects and maintains persistent contactpoints.
const btVector3 & getPositionWorldOnB() const
btScalar m_combinedRestitution
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity
btScalar m_appliedImpulse
const btVector3 & getPositionWorldOnA() const
btVector3 m_normalWorldOnB
btScalar m_combinedFriction
btVector3 m_positionWorldOnB
btVector3 getColumn(int i) const
Get a column of the matrix as a vector.
virtual void setWorldTransform(const btTransform &worldTrans)=0
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
virtual btOverlapFilterCallback * getOverlapFilterCallback()=0
virtual btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
virtual bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const =0
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
const btCollisionObject * getBody1() const
const btCollisionObject * getBody0() const
int getNumContacts() const
int addManifoldPoint(const btManifoldPoint &newPoint, bool isPredictive=false)
const btManifoldPoint & getContactPoint(int index) const
point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocke...
const btVector3 & getPivotInB() const
const btVector3 & getPivotInA() const
The btRigidBody is the main class for rigid body objects.
void addConstraintRef(btTypedConstraint *c)
btMotionState * getMotionState()
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping
btScalar getInvMass() const
void updateDeactivation(btScalar timeStep)
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 setGravity(const btVector3 &acceleration)
void proceedToTransform(const btTransform &newTrans)
void saveKinematicState(btScalar step)
const btBroadphaseProxy * getBroadphaseProxy() const
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
void removeConstraintRef(btTypedConstraint *c)
const btTransform & getCenterOfMassTransform() const
const btVector3 & getLinearVelocity() const
const btCollisionShape * getCollisionShape() const
void setAngularVelocity(const btVector3 &ang_vel)
void setLinearVelocity(const btVector3 &lin_vel)
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
btScalar m_hiLimit
joint limit
btScalar m_loLimit
limit_parameters
The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (...
virtual btChunk * allocate(size_t size, int numElements)=0
virtual void finishSerialization()=0
virtual void startSerialization()=0
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
SimulationIslandManager creates and handles simulation islands, using btUnionFind.
virtual void storeIslandActivationState(btCollisionWorld *world)
btUnionFind & getUnionFind()
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
virtual ~btSimulationIslandManager()
bool getUseLinearReferenceFrameA()
btScalar getUpperLinLimit()
const btTransform & getCalculatedTransformA() const
const btTransform & getCalculatedTransformB() const
btScalar getLowerLinLimit()
btScalar getLowerAngLimit()
btScalar getUpperAngLimit()
bool operator()(const btTypedConstraint *lhs, const btTypedConstraint *rhs) const
The btSphereShape implements an implicit sphere, centered around a local origin with radius.
The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out)
btVector3 m_lowerLimit
the constraint lower limits
btVector3 m_upperLimit
the constraint upper limits
TypedConstraint is the baseclass for Bullet constraints and vehicles.
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btTypedConstraintType getConstraintType() const
const btRigidBody & getRigidBodyA() const
btScalar getDbgDrawSize()
const btRigidBody & getRigidBodyB() const
virtual int calculateSerializeBufferSize() const
btVector3 can be used to represent 3D points and vectors.
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
btScalar dot(const btVector3 &v) const
Return the dot product.
btScalar length2() const
Return the length of the vector squared.
void serialize(struct btVector3Data &dataOut) const
btContactSolverInfo * m_solverInfo
btAlignedObjectArray< btCollisionObject * > m_bodies
InplaceSolverIslandCallback(btConstraintSolver *solver, btStackAlloc *stackAlloc, btDispatcher *dispatcher)
btAlignedObjectArray< btTypedConstraint * > m_constraints
void processConstraints()
InplaceSolverIslandCallback & operator=(InplaceSolverIslandCallback &other)
btDispatcher * m_dispatcher
btConstraintSolver * m_solver
btIDebugDraw * m_debugDrawer
btAlignedObjectArray< btPersistentManifold * > m_manifolds
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, int islandId)
btTypedConstraint ** m_sortedConstraints
void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btIDebugDraw *debugDrawer)
The btBroadphasePair class contains a pair of aabb-overlapping objects.
btCollisionAlgorithm * m_algorithm
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
int m_collisionFilterMask
int m_collisionFilterGroup
btVector3 m_convexToWorld
ClosestConvexResultCallback(const btVector3 &convexFromWorld, const btVector3 &convexToWorld)
btVector3 m_convexFromWorld
btVector3 m_hitNormalLocal
const btCollisionObject * m_hitCollisionObject
btScalar m_allowedCcdPenetration
class btIDebugDraw * m_debugDraw
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btContactSolverInfoDoubleData m_solverInfo
btVector3DoubleData m_gravity
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64