70 :m_dispatcher1(dispatcher),
    71 m_broadphasePairCache(pairCache),
    73 m_forceUpdateAllAabbs(true)
   136                 collisionFilterGroup,
   154         minAabb -= contactThreshold;
   155         maxAabb += contactThreshold;
   161                 minAabb2 -= contactThreshold;
   162                 maxAabb2 += contactThreshold;
   179                 static bool reportMe = 
true;
   218         BT_PROFILE(
"performDiscreteCollisionDetection");
   317                         convexCasterPtr = &gjkConvexCaster;
   319                         convexCasterPtr = &subSimplexConvexCaster;
   323                 if (convexCaster.
calcTimeOfImpact(rayFromTrans,rayToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
   331 #ifdef USE_SUBSIMPLEX_CONVEX_CAST   334 #endif //USE_SUBSIMPLEX_CONVEX_CAST   345                                         bool normalInWorldSpace = 
true;
   368                                                         m_resultCallback(resultCallback),
   369                                                         m_collisionObject(collisionObject),
   370                                                         m_triangleMesh(triangleMesh),
   371                                                         m_colObjWorldTransform(colObjWorldTransform)
   390                                                 bool    normalInWorldSpace = 
true;
   391                                                 return m_resultCallback->
addSingleResult(rayResult,normalInWorldSpace);
   406                                 BridgeTriangleRaycastCallback rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObjectWrap->
getCollisionObject(),triangleMesh,colObjWorldTransform);
   434                                                 m_resultCallback(resultCallback),
   435                                                 m_collisionObject(collisionObject),
   436                                                 m_triangleMesh(triangleMesh),
   437                                                 m_colObjWorldTransform(colObjWorldTransform)
   456                                                 bool    normalInWorldSpace = 
true;
   457                                                 return m_resultCallback->
addSingleResult(rayResult,normalInWorldSpace);
   463                                 BridgeTriangleRaycastCallback   rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObjectWrap->
getCollisionObject(),concaveShape, colObjWorldTransform);
   466                                 btVector3 rayAabbMinLocal = rayFromLocal;
   467                                 rayAabbMinLocal.
setMin(rayToLocal);
   468                                 btVector3 rayAabbMaxLocal = rayFromLocal;
   469                                 rayAabbMaxLocal.
setMax(rayToLocal);
   483                                                 : m_userCallback(user), m_i(i)
   486                                                 m_flags = m_userCallback->
m_flags;
   522                                                 m_collisionObject(collisionObject),
   523                                                 m_compoundShape(compoundShape),
   524                                                 m_colObjWorldTransform(colObjWorldTransform),
   525                                                 m_rayFromTrans(rayFromTrans),
   526                                                 m_rayToTrans(rayToTrans),
   527                                                 m_resultCallback(resultCallback)
   532                                         void ProcessLeaf(
int i)
   536                                                 btTransform childWorldTrans = m_colObjWorldTransform * childTrans;
   543                                                 LocalInfoAdder2 my_cb(i, &m_resultCallback);
   566                                         colObjWorldTransform,
   570 #ifndef DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION   573                                         btVector3 localRayFrom = colObjWorldTransform.inverseTimes(rayFromTrans).getOrigin();
   574                                         btVector3 localRayTo = colObjWorldTransform.inverseTimes(rayToTrans).getOrigin();
   578 #endif //DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION   582                                                 rayCB.ProcessLeaf(i);
   626                 if (castPtr->
calcTimeOfImpact(convexFromTrans,convexToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
   643                                         bool normalInWorldSpace = 
true;
   672                                                 m_resultCallback(resultCallback),
   673                                                 m_collisionObject(collisionObject),
   674                                                 m_triangleMesh(triangleMesh)
   684                                                 if (hitFraction <= m_resultCallback->m_closestHitFraction)
   694                                                         bool    normalInWorldSpace = 
true;
   697                                                         return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
   704                                 BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,colObjWrap->
getCollisionObject(),triangleMesh, colObjWorldTransform);
   706                                 tccb.m_allowedPenetration = allowedPenetration;
   708                                 castShape->
getAabb(rotationXform, boxMinLocal, boxMaxLocal);
   709                                 triangleMesh->
performConvexcast(&tccb,convexFromLocal,convexToLocal,boxMinLocal, boxMaxLocal);
   721                                         if (castPtr->
calcTimeOfImpact(convexFromTrans,convexToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
   738                                                                 bool normalInWorldSpace = 
true;
   764                                                         m_resultCallback(resultCallback),
   765                                                         m_collisionObject(collisionObject),
   766                                                         m_triangleMesh(triangleMesh)
   776                                                         if (hitFraction <= m_resultCallback->m_closestHitFraction)
   786                                                                 bool    normalInWorldSpace = 
true;
   788                                                                 return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
   795                                         BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,colObjWrap->
getCollisionObject(),concaveShape, colObjWorldTransform);
   797                                         tccb.m_allowedPenetration = allowedPenetration;
   799                                         castShape->
getAabb(rotationXform, boxMinLocal, boxMaxLocal);
   801                                         btVector3 rayAabbMinLocal = convexFromLocal;
   802                                         rayAabbMinLocal.
setMin(convexToLocal);
   803                                         btVector3 rayAabbMaxLocal = convexFromLocal;
   804                                         rayAabbMaxLocal.
setMax(convexToLocal);
   805                                         rayAabbMinLocal += boxMinLocal;
   806                                         rayAabbMaxLocal += boxMaxLocal;
   825                                           m_colObjWrap(colObjWrap),
   826                                                 m_castShape(castShape),
   827                                                 m_convexFromTrans(convexFromTrans),
   828                                                 m_convexToTrans(convexToTrans),
   829                                                 m_allowedPenetration(allowedPenetration),
   830                                                 m_compoundShape(compoundShape),
   831                                                 m_colObjWorldTransform(colObjWorldTransform),
   832                                                 m_resultCallback(resultCallback) {
   848                                                 btTransform childWorldTrans = m_colObjWorldTransform * childTrans;
   855                                                                 : m_userCallback(user), m_i(i)
   877                                                 LocalInfoAdder my_cb(index, &m_resultCallback);
   892                                                 ProcessChild(index, childTrans, childCollisionShape);
   899                                 btVector3 fromLocalAabbMin, fromLocalAabbMax;
   900                                 btVector3 toLocalAabbMin, toLocalAabbMax;
   902                                 castShape->
getAabb(colObjWorldTransform.
inverse() * convexFromTrans, fromLocalAabbMin, fromLocalAabbMax);
   903                                 castShape->
getAabb(colObjWorldTransform.
inverse() * convexToTrans, toLocalAabbMin, toLocalAabbMax);
   905                                 fromLocalAabbMin.setMin(toLocalAabbMin);
   906                                 fromLocalAabbMax.
setMax(toLocalAabbMax);
   909                                           allowedPenetration, compoundShape, colObjWorldTransform, resultCallback);
   921                                                 callback.ProcessChild(i, childTrans, childCollisionShape);
   943                 :m_rayFromWorld(rayFromWorld),
   944                 m_rayToWorld(rayToWorld),
   946                 m_resultCallback(resultCallback)
   949                 m_rayFromTrans.
setOrigin(m_rayFromWorld);
   953                 btVector3 rayDir = (rayToWorld-rayFromWorld);
   960                 m_signs[0] = m_rayDirectionInverse[0] < 0.0;
   961                 m_signs[1] = m_rayDirectionInverse[1] < 0.0;
   962                 m_signs[2] = m_rayDirectionInverse[2] < 0.0;
   964                 m_lambda_max = rayDir.
dot(m_rayToWorld-m_rayFromWorld);
   984 #ifdef RECALCULATE_AABB   985                         btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
  1015 #ifndef USE_BRUTEFORCE_RAYBROADPHASE  1022 #endif //USE_BRUTEFORCE_RAYBROADPHASE  1040                 :m_convexFromTrans(convexFromTrans),
  1041                 m_convexToTrans(convexToTrans),
  1043                 m_resultCallback(resultCallback),
  1044                 m_allowedCcdPenetration(allowedPenetration),
  1045                 m_castShape(castShape)
  1053                 m_signs[0] = m_rayDirectionInverse[0] < 0.0;
  1054                 m_signs[1] = m_rayDirectionInverse[1] < 0.0;
  1055                 m_signs[2] = m_rayDirectionInverse[2] < 0.0;
  1057                 m_lambda_max = rayDir.
dot(unnormalizedRayDir);
  1077                                 m_allowedCcdPenetration);
  1097         convexFromTrans = convexFromWorld;
  1098         convexToTrans = convexToWorld;
  1099         btVector3 castShapeAabbMin, castShapeAabbMax;
  1112 #ifndef USE_BRUTEFORCE_RAYBROADPHASE  1114         btSingleSweepCallback   convexCB(castShape,convexFromWorld,convexToWorld,
this,resultCallback,allowedCcdPenetration);
  1128                         btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
  1130                         AabbExpand (collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
  1133                         if (
btRayAabb(convexFromWorld.
getOrigin(),convexToWorld.
getOrigin(),collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
  1140                                         allowedCcdPenetration);
  1144 #endif //USE_BRUTEFORCE_RAYBROADPHASE  1156                 m_resultCallback(resultCallback)
  1162                 bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
  1163                 btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
  1168                         localA = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointA );
  1169                         localB = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
  1172                         localA = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointA );
  1173                         localB = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
  1215                 :m_collisionObject(collisionObject),
  1217                 m_resultCallback(resultCallback)
  1224                 if (collisionObject == m_collisionObject)
  1239                                 algorithm->processCollision(&ob0,&ob1, m_world->
getDispatchInfo(),&contactPointResult);
  1241                                 algorithm->~btCollisionAlgorithm();
  1275                 algorithm->processCollision(&obA,&obB, 
getDispatchInfo(),&contactPointResult);
  1277                 algorithm->~btCollisionAlgorithm();
  1295           m_debugDrawer(debugDrawer),
  1297                   m_worldTrans(worldTrans)
  1303                   processTriangle(triangle,partId,triangleIndex);
  1309                   (void)triangleIndex;
  1312                   wv0 = m_worldTrans*triangle[0];
  1313                   wv1 = m_worldTrans*triangle[1];
  1314                   wv2 = m_worldTrans*triangle[2];
  1319                     btVector3 normal = (wv1-wv0).cross(wv2-wv0);
  1322                     m_debugDrawer->
drawLine(center,center+normal,normalColor);
  1324                   m_debugDrawer->
drawLine(wv0,wv1,m_color);
  1325                   m_debugDrawer->
drawLine(wv1,wv2,m_color);
  1326                   m_debugDrawer->
drawLine(wv2,wv0,m_color);
  1445                                 int lastV = poly->
m_faces[i].m_indices[numVerts-1];
  1446                                 for (
int v=0;v<poly->
m_faces[i].m_indices.
size();v++)
  1448                                     int curVert = poly->
m_faces[i].m_indices[v];
  1527                                 for (
int i=0;i<numManifolds;i++)
  1534                                         for (
int j=0;j<numContacts;j++)
  1584                                                 minAabb -= contactThreshold;
  1585                                                 maxAabb += contactThreshold;
  1592                                                         minAabb2 -= contactThreshold;
  1593                                                         maxAabb2 += contactThreshold;
  1594                                                         minAabb.
setMin(minAabb2);
  1595                                                         maxAabb.
setMax(maxAabb2);
  1619                 if (!serializedShapes.
find(shape))
  1621                         serializedShapes.
insert(shape,shape);
 
btVector3 getHalfExtentsWithMargin() const
virtual void finishSerialization()=0
btSingleSweepCallback(const btConvexShape *castShape, const btTransform &convexFromTrans, const btTransform &convexToTrans, const btCollisionWorld *world, btCollisionWorld::ConvexResultCallback &resultCallback, btScalar allowedPenetration)
void serializeCollisionObjects(btSerializer *serializer)
btAlignedObjectArray< btVector3 > m_vertices
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good...
void push_back(const T &_Val)
btScalar getSphereRadius(int index) const
btConvexCast is an interface for Casting 
virtual DefaultColors getDefaultColors() const
btVector3 m_wantsDeactivationObject
btScalar getRadius() const
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
void performRaycast(btTriangleCallback *callback, const btVector3 &raySource, const btVector3 &rayTarget)
LocalShapeInfo * m_localShapeInfo
virtual void updateAabbs()
btVector3 m_deactivatedObject
int findLinearSearch(const T &key) const
btCollisionWorld(btDispatcher *dispatcher, btBroadphaseInterface *broadphasePairCache, btCollisionConfiguration *collisionConfiguration)
for debug drawing 
virtual void reportErrorWarning(const char *warningString)=0
virtual btPersistentManifold * getManifoldByIndexInternal(int index)=0
const Value * find(const Key &key) const
bool m_forceUpdateAllAabbs
m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs it is...
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
btScalar length2() const
Return the length of the vector squared. 
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
virtual void dispatchAllCollisionPairs(btOverlappingPairCache *pairCache, const btDispatcherInfo &dispatchInfo, btDispatcher *dispatcher)=0
virtual void startSerialization()=0
The btMultiSphereShape represents the convex hull of a collection of spheres. 
const btScalar & getPlaneConstant() const
virtual btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold, ebtDispatcherQueryType queryType)=0
virtual void InternalProcessAllTriangles(btInternalTriangleIndexCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
virtual void drawBox(const btVector3 &bbMin, const btVector3 &bbMax, const btVector3 &color)
int getNumContacts() const
The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned ...
const btDbvt * getDynamicAabbTree() const
virtual void drawPlane(const btVector3 &planeNormal, btScalar planeConst, const btTransform &transform, const btVector3 &color)
btVector3 getHalfExtentsWithMargin() const
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
virtual void serializeSingleShape(btSerializer *serializer) const
The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes ...
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
RayResultCallback is used to report new raycast results. 
btContinuousConvexCollision implements angular and linear time of impact for convex objects...
void setWorldArrayIndex(int ix)
The btSphereShape implements an implicit sphere, centered around a local origin with radius...
btCollisionWorld::RayResultCallback & m_resultCallback
ManifoldContactPoint collects and maintains persistent contactpoints. 
const btCollisionWorld * m_world
int getActivationState() const
btDispatcher * m_dispatcher1
btManifoldResult is a helper class to manage contact results. 
btVector3 m_disabledSimulationObject
static DBVT_PREFIX void rayTest(const btDbvtNode *root, const btVector3 &rayFrom, const btVector3 &rayTo, DBVT_IPOLICY)
rayTest is a re-entrant ray test, and can be called in parallel as long as the btAlignedAlloc is thre...
static void rayTestSingleInternal(const btTransform &rayFromTrans, const btTransform &rayToTrans, const btCollisionObjectWrapper *collisionObjectWrap, RayResultCallback &resultCallback)
const btCollisionShape * getCollisionShape() const
virtual void computeOverlappingPairs()
the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSi...
bool isStaticOrKinematicObject() const
virtual void drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, const btTransform &transform, const btVector3 &color)
int getNumChildShapes() const
btScalar m_closestHitFraction
btSingleRayCallback(const btVector3 &rayFromWorld, const btVector3 &rayToWorld, const btCollisionWorld *world, btCollisionWorld::RayResultCallback &resultCallback)
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const =0
void swap(int index0, int index1)
virtual void drawContactPoint(const btVector3 &PointOnB, const btVector3 &normalOnB, btScalar distance, int lifeTime, const btVector3 &color)=0
virtual void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t...
The btHashMap template class implements a generic and lightweight hashmap. 
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1. 
btTransform m_convexToTrans
int getNumCollisionObjects() const
btVector3 normalized() const
Return a normalized version of this vector. 
The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape...
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
GjkConvexCast performs a raycast on a convex object using support mapping. 
const btManifoldPoint & getContactPoint(int index) const
The btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly...
btScalar m_allowedPenetration
virtual void getEdge(int i, btVector3 &pa, btVector3 &pb) const =0
void AabbExpand(btVector3 &aabbMin, btVector3 &aabbMax, const btVector3 &expansionMin, const btVector3 &expansionMax)
virtual btOverlappingPairCache * getOverlappingPairCache()=0
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
btIDebugDraw * m_debugDrawer
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)=0
int getSphereCount() const
btTransform & getWorldTransform()
btVector3 m_normalWorldOnB
btScalar getHalfHeight() const
RayResult stores the closest result alternatively, add a callback method to decide about closest/all ...
btScalar m_closestPointDistanceThreshold
btVector3 m_positionWorldOnB
virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform &transform, const btVector3 &color)
void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb's default implementation is brute force, expected derived classes to implement a fast dedicat...
btBroadphaseProxy * getBroadphaseHandle()
int getConeUpIndex() const
btTransform m_convexFromTrans
btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points...
const btCollisionWorld * m_world
btCollisionWorld::ConvexResultCallback & m_resultCallback
btIDebugDraw * m_debugDrawer
virtual btIDebugDraw * getDebugDrawer()
void contactPairTest(btCollisionObject *colObjA, btCollisionObject *colObjB, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between two collision objects and calls the resultCall...
btAlignedObjectArray< btFace > m_faces
The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTrian...
DebugDrawcallback(btIDebugDraw *debugDrawer, const btTransform &worldTrans, const btVector3 &color)
bool isStaticObject() const
The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y ...
btTransform & getChildTransform(int index)
virtual void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)=0
static btDbvtAabbMm FromMM(const btVector3 &mi, const btVector3 &mx)
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
btScalar dot(const btVector3 &v) const
Return the dot product. 
const btCollisionObject * getCollisionObject() const
virtual void debugDrawObject(const btTransform &worldTransform, const btCollisionShape *shape, const btVector3 &color)
void contactTest(btCollisionObject *colObj, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between colObj against all objects in the btCollisionW...
btCollisionObject can be used to manage collision detection objects. 
void insert(const Key &key, const Value &value)
#define DISABLE_SIMULATION
The btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes. 
DBVT_PREFIX void collideTV(const btDbvtNode *root, const btDbvtVolume &volume, DBVT_IPOLICY) const
static void rayTestSingle(const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, RayResultCallback &resultCallback)
rayTestSingle performs a raycast call and calls the resultCallback. 
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
const btTransform & getInterpolationWorldTransform() const
btScalar getRadius() const
LocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is avai...
virtual void drawAabb(const btVector3 &from, const btVector3 &to, const btVector3 &color)
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity ...
btScalar getHeight() const
virtual void removeCollisionObject(btCollisionObject *collisionObject)
virtual void freeCollisionAlgorithm(void *ptr)=0
void performConvexcast(btTriangleCallback *callback, const btVector3 &boxSource, const btVector3 &boxTarget, const btVector3 &boxMin, const btVector3 &boxMax)
virtual ~btCollisionWorld()
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
btDispatcher * getDispatcher()
int getWorldArrayIndex() const
int getCollisionFlags() const
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. 
virtual void rayTest(const btVector3 &rayFromWorld, const btVector3 &rayToWorld, RayResultCallback &resultCallback) const
rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback This ...
virtual void processTriangle(btVector3 *triangle, int partId, int triangleIndex)
The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by ...
virtual void setMargin(btScalar margin)
btVector3 can be used to represent 3D points and vectors. 
#define ATTRIBUTE_ALIGNED16(a)
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bulle...
int size() const
return the number of elements in the array 
bool isPolyhedral() const
virtual int getNumManifolds() const =0
static void objectQuerySingle(const btConvexShape *castShape, const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, ConvexResultCallback &resultCallback, btScalar allowedPenetration)
objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest. 
btSubsimplexConvexCast implements Gino van den Bergens' paper "Ray Casting against bteral Convex Obje...
const btVector3 & getPlaneNormal() const
CollisionWorld is interface and container for the collision detection. 
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...
EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth be...
void setBroadphaseHandle(btBroadphaseProxy *handle)
btDispatcherInfo & getDispatchInfo()
#define WANTS_DEACTIVATION
The btConcaveShape class provides an interface for non-moving (static) concave shapes. 
void remove(const T &key)
virtual void drawTransform(const btTransform &transform, btScalar orthoLen)
int getInternalType() const
reserved for Bullet internal usage 
virtual btScalar getRadius() const
virtual int getDebugMode() const =0
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
const btTransform & getWorldTransform() const
The btCylinderShape class implements a cylinder shape primitive, centered around the origin...
#define DISABLE_DEACTIVATION
virtual bool process(const btBroadphaseProxy *proxy)
bool getCustomDebugColor(btVector3 &colorRGB) const
virtual void performDiscreteCollisionDetection()
virtual void serializeSingleObject(class btSerializer *serializer) const
void calculateTemporalAabb(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btVector3 &temporalAabbMin, btVector3 &temporalAabbMax) const
calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0...
LocalShapeInfo * m_localShapeInfo
btBroadphaseInterface * m_broadphasePairCache
btScalar m_closestHitFraction
virtual void setAabb(btBroadphaseProxy *proxy, const btVector3 &aabbMin, const btVector3 &aabbMax, btDispatcher *dispatcher)=0
btScalar m_allowedCcdPenetration
const btConvexShape * m_castShape
virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace)=0
void updateSingleAabb(btCollisionObject *colObj)
virtual btScalar getMargin() const
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3. 
class btStridingMeshInterface * getMeshInterface()
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. ...
RayResultCallback is used to report new raycast results. 
btBridgedManifoldResult(const btCollisionObjectWrapper *obj0Wrap, const btCollisionObjectWrapper *obj1Wrap, btCollisionWorld::ContactResultCallback &resultCallback)
virtual bool process(const btBroadphaseProxy *proxy)
btCollisionShape * getChildShape(int index)
virtual void internalProcessTriangleIndex(btVector3 *triangle, int partId, int triangleIndex)
virtual void debugDrawWorld()
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
btScalar gContactBreakingThreshold
virtual void drawSphere(btScalar radius, const btTransform &transform, const btVector3 &color)
bool btRayAabb(const btVector3 &rayFrom, const btVector3 &rayTo, const btVector3 &aabbMin, const btVector3 &aabbMax, btScalar ¶m, btVector3 &normal)
virtual void destroyProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)=0
virtual void addContactPoint(const btVector3 &normalOnBInWorld, const btVector3 &pointInWorld, btScalar depth)
const btBroadphaseInterface * getBroadphase() const
btVector3 m_disabledDeactivationObject
btCollisionWorld::ContactResultCallback & m_resultCallback
void setActivationState(int newState) const
btTransform m_rayFromTrans
virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform &transform, const btVector3 &color)
virtual void rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, btBroadphaseRayCallback &rayCallback, const btVector3 &aabbMin=btVector3(0, 0, 0), const btVector3 &aabbMax=btVector3(0, 0, 0))=0
static void objectQuerySingleInternal(const btConvexShape *castShape, const btTransform &convexFromTrans, const btTransform &convexToTrans, const btCollisionObjectWrapper *colObjWrap, ConvexResultCallback &resultCallback, btScalar allowedPenetration)
btScalar getDistance() const
const btVector3 & getSpherePosition(int index) const
const btConvexPolyhedron * getConvexPolyhedron() const
virtual void calculateOverlappingPairs(btDispatcher *dispatcher)=0
calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during th...
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3. 
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
const btCollisionShape * getCollisionShape() const
virtual btScalar getMargin() const
static btDbvtVolume bounds(const tNodeArray &leaves)
virtual void aabbTest(const btVector3 &aabbMin, const btVector3 &aabbMax, btBroadphaseAabbCallback &callback)=0
virtual bool calcTimeOfImpact(const btTransform &fromA, const btTransform &toA, const btTransform &fromB, const btTransform &toB, CastResult &result)=0
cast a convex against another convex object 
virtual int getNumEdges() const =0