67         : m_dispatcher1(dispatcher),
 
   68           m_broadphasePairCache(pairCache),
 
   70           m_forceUpdateAllAabbs(true)
 
  117                         collisionFilterGroup,
 
  147                 collisionFilterGroup,
 
  158         minAabb -= contactThreshold;
 
  159         maxAabb += contactThreshold;
 
  165                 minAabb2 -= contactThreshold;
 
  166                 maxAabb2 += contactThreshold;
 
  184                 static bool reportMe = 
true;
 
  222         BT_PROFILE(
"performDiscreteCollisionDetection");
 
  306                 btGjkConvexCast gjkConvexCaster(castShape, convexShape, &simplexSolver);
 
  313                         convexCasterPtr = &gjkConvexCaster;
 
  315                         convexCasterPtr = &subSimplexConvexCaster;
 
  319                 if (convexCaster.
calcTimeOfImpact(rayFromTrans, rayToTrans, colObjWorldTransform, colObjWorldTransform, castResult))
 
  327 #ifdef USE_SUBSIMPLEX_CONVEX_CAST 
  330 #endif  //USE_SUBSIMPLEX_CONVEX_CAST 
  339                                         bool normalInWorldSpace = 
true;
 
  361                                                                                                                                                                                                                                                                                                                                                                                                                                                         m_resultCallback(resultCallback),
 
  362                                                                                                                                                                                                                                                                                                                                                                                                                                                         m_collisionObject(collisionObject),
 
  363                                                                                                                                                                                                                                                                                                                                                                                                                                                         m_triangleMesh(triangleMesh),
 
  364                                                                                                                                                                                                                                                                                                                                                                                                                                                         m_colObjWorldTransform(colObjWorldTransform)
 
  381                                         bool normalInWorldSpace = 
true;
 
  382                                         return m_resultCallback->
addSingleResult(rayResult, normalInWorldSpace);
 
  396                                 BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->
getCollisionObject(), triangleMesh, colObjWorldTransform);
 
  408                                 btVector3 rayFromLocalScaled = rayFromLocal / scale;
 
  409                                 btVector3 rayToLocalScaled = rayToLocal / scale;
 
  412                                 BridgeTriangleRaycastCallback rcb(rayFromLocalScaled, rayToLocalScaled, &resultCallback, collisionObjectWrap->
getCollisionObject(), triangleMesh, colObjWorldTransform);
 
  414                                 triangleMesh->
performRaycast(&rcb, rayFromLocalScaled, rayToLocalScaled);
 
  439                                                                                                                                                                                                                                                                                                                                                                                                                                                   m_resultCallback(resultCallback),
 
  440                                                                                                                                                                                                                                                                                                                                                                                                                                                   m_collisionObject(collisionObject),
 
  441                                                                                                                                                                                                                                                                                                                                                                                                                                                   m_triangleMesh(triangleMesh),
 
  442                                                                                                                                                                                                                                                                                                                                                                                                                                                   m_colObjWorldTransform(colObjWorldTransform)
 
  459                                                 bool normalInWorldSpace = 
true;
 
  460                                                 return m_resultCallback->
addSingleResult(rayResult, normalInWorldSpace);
 
  464                                 BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->
getCollisionObject(), concaveShape, colObjWorldTransform);
 
  467                                 btVector3 rayAabbMinLocal = rayFromLocal;
 
  468                                 rayAabbMinLocal.
setMin(rayToLocal);
 
  469                                 btVector3 rayAabbMaxLocal = rayFromLocal;
 
  470                                 rayAabbMaxLocal.
setMax(rayToLocal);
 
  486                                                 : m_userCallback(user), m_i(i)
 
  489                                                 m_flags = m_userCallback->
m_flags;
 
  525                                                                                                                                    m_compoundShape(compoundShape),
 
  526                                                                                                                                    m_colObjWorldTransform(colObjWorldTransform),
 
  527                                                                                                                                    m_rayFromTrans(rayFromTrans),
 
  528                                                                                                                                    m_rayToTrans(rayToTrans),
 
  529                                                                                                                                    m_resultCallback(resultCallback)
 
  533                                         void ProcessLeaf(
int i)
 
  537                                                 btTransform childWorldTrans = m_colObjWorldTransform * childTrans;
 
  542                                                 LocalInfoAdder2 my_cb(i, &m_resultCallback);
 
  557                                 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
 
  563                                         colObjWorldTransform,
 
  567 #ifndef DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION 
  570                                         btVector3 localRayFrom = colObjWorldTransform.inverseTimes(rayFromTrans).getOrigin();
 
  571                                         btVector3 localRayTo = colObjWorldTransform.inverseTimes(rayToTrans).getOrigin();
 
  575 #endif  //DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION 
  579                                                 rayCB.ProcessLeaf(i);
 
  621                 if (castPtr->
calcTimeOfImpact(convexFromTrans, convexToTrans, colObjWorldTransform, colObjWorldTransform, castResult))
 
  636                                         bool normalInWorldSpace = 
true;
 
  665                                                                                                                                                                                                                                                                                                                                                                                                                                                                 m_resultCallback(resultCallback),
 
  666                                                                                                                                                                                                                                                                                                                                                                                                                                                                 m_collisionObject(collisionObject),
 
  667                                                                                                                                                                                                                                                                                                                                                                                                                                                                 m_triangleMesh(triangleMesh)
 
  676                                                 if (hitFraction <= m_resultCallback->m_closestHitFraction)
 
  684                                                         bool normalInWorldSpace = 
true;
 
  686                                                         return m_resultCallback->addSingleResult(convexResult, normalInWorldSpace);
 
  692                                 BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->
getCollisionObject(), triangleMesh, colObjWorldTransform);
 
  694                                 tccb.m_allowedPenetration = allowedPenetration;
 
  696                                 castShape->
getAabb(rotationXform, boxMinLocal, boxMaxLocal);
 
  697                                 triangleMesh->
performConvexcast(&tccb, convexFromLocal, convexToLocal, boxMinLocal, boxMaxLocal);
 
  710                                         if (castPtr->
calcTimeOfImpact(convexFromTrans, convexToTrans, colObjWorldTransform, colObjWorldTransform, castResult))
 
  725                                                                 bool normalInWorldSpace = 
true;
 
  750                                                                                                                                                                                                                                                                                                                                                                                                                                                            m_resultCallback(resultCallback),
 
  751                                                                                                                                                                                                                                                                                                                                                                                                                                                            m_collisionObject(collisionObject),
 
  752                                                                                                                                                                                                                                                                                                                                                                                                                                                            m_triangleMesh(triangleMesh)
 
  761                                                         if (hitFraction <= m_resultCallback->m_closestHitFraction)
 
  769                                                                 bool normalInWorldSpace = 
true;
 
  771                                                                 return m_resultCallback->addSingleResult(convexResult, normalInWorldSpace);
 
  777                                         BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->
getCollisionObject(), concaveShape, colObjWorldTransform);
 
  779                                         tccb.m_allowedPenetration = allowedPenetration;
 
  781                                         castShape->
getAabb(rotationXform, boxMinLocal, boxMaxLocal);
 
  783                                         btVector3 rayAabbMinLocal = convexFromLocal;
 
  784                                         rayAabbMinLocal.
setMin(convexToLocal);
 
  785                                         btVector3 rayAabbMaxLocal = convexFromLocal;
 
  786                                         rayAabbMaxLocal.
setMax(convexToLocal);
 
  787                                         rayAabbMinLocal += boxMinLocal;
 
  788                                         rayAabbMaxLocal += boxMaxLocal;
 
  808                                                 : m_colObjWrap(colObjWrap),
 
  809                                                   m_castShape(castShape),
 
  810                                                   m_convexFromTrans(convexFromTrans),
 
  811                                                   m_convexToTrans(convexToTrans),
 
  812                                                   m_allowedPenetration(allowedPenetration),
 
  813                                                   m_compoundShape(compoundShape),
 
  814                                                   m_colObjWorldTransform(colObjWorldTransform),
 
  815                                                   m_resultCallback(resultCallback)
 
  831                                                 btTransform childWorldTrans = m_colObjWorldTransform * childTrans;
 
  839                                                                 : m_userCallback(user), m_i(i)
 
  860                                                 LocalInfoAdder my_cb(index, &m_resultCallback);
 
  875                                                 ProcessChild(index, childTrans, childCollisionShape);
 
  880                                 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
 
  882                                 btVector3 fromLocalAabbMin, fromLocalAabbMax;
 
  883                                 btVector3 toLocalAabbMin, toLocalAabbMax;
 
  885                                 castShape->
getAabb(colObjWorldTransform.
inverse() * convexFromTrans, fromLocalAabbMin, fromLocalAabbMax);
 
  886                                 castShape->
getAabb(colObjWorldTransform.
inverse() * convexToTrans, toLocalAabbMin, toLocalAabbMax);
 
  888                                 fromLocalAabbMin.setMin(toLocalAabbMin);
 
  889                                 fromLocalAabbMax.
setMax(toLocalAabbMax);
 
  892                                                                                                 allowedPenetration, compoundShape, colObjWorldTransform, resultCallback);
 
  907                                                 callback.ProcessChild(i, childTrans, childCollisionShape);
 
  937                 btVector3 rayDir = (rayToWorld - rayFromWorld);
 
  965 #ifdef RECALCULATE_AABB 
  966                         btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 
  996 #ifndef USE_BRUTEFORCE_RAYBROADPHASE 
 1003 #endif  //USE_BRUTEFORCE_RAYBROADPHASE 
 1069         convexFromTrans = convexFromWorld;
 
 1070         convexToTrans = convexToWorld;
 
 1071         btVector3 castShapeAabbMin, castShapeAabbMax;
 
 1084 #ifndef USE_BRUTEFORCE_RAYBROADPHASE 
 1086         btSingleSweepCallback convexCB(castShape, convexFromWorld, convexToWorld, 
this, resultCallback, allowedCcdPenetration);
 
 1101                         btVector3 collisionObjectAabbMin, collisionObjectAabbMax;
 
 1103                         AabbExpand(collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
 
 1106                         if (
btRayAabb(convexFromWorld.
getOrigin(), convexToWorld.
getOrigin(), collisionObjectAabbMin, collisionObjectAabbMax, hitLambda, hitNormal))
 
 1113                                                                   allowedCcdPenetration);
 
 1117 #endif  //USE_BRUTEFORCE_RAYBROADPHASE 
 1133                 btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
 
 1207                                 algorithm->~btCollisionAlgorithm();
 
 1239                 algorithm->processCollision(&obA, &obB, 
getDispatchInfo(), &contactPointResult);
 
 1241                 algorithm->~btCollisionAlgorithm();
 
 1267                 (void)triangleIndex;
 
 1277                         btVector3 normal = (wv1 - wv0).cross(wv2 - wv0);
 
 1298                 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(shape);
 
 1312                                 const btBoxShape* boxShape = static_cast<const btBoxShape*>(shape);
 
 1320                                 const btSphereShape* sphereShape = static_cast<const btSphereShape*>(shape);
 
 1328                                 const btMultiSphereShape* multiSphereShape = static_cast<const btMultiSphereShape*>(shape);
 
 1333                                 for (
int i = multiSphereShape->
getSphereCount() - 1; i >= 0; i--)
 
 1343                                 const btCapsuleShape* capsuleShape = static_cast<const btCapsuleShape*>(shape);
 
 1354                                 const btConeShape* coneShape = static_cast<const btConeShape*>(shape);
 
 1364                                 const btCylinderShape* cylinder = static_cast<const btCylinderShape*>(shape);
 
 1374                                 const btStaticPlaneShape* staticPlaneShape = static_cast<const btStaticPlaneShape*>(shape);
 
 1397                                                                 int lastV = poly->
m_faces[i].m_indices[numVerts - 1];
 
 1398                                                                 for (
int v = 0; v < poly->
m_faces[i].m_indices.
size(); v++)
 
 1400                                                                         int curVert = poly->
m_faces[i].m_indices[v];
 
 1411                                                                 getDebugDrawer()->
drawLine(worldTransform * centroid, worldTransform * (centroid + faceNormal), normalColor);
 
 1469                                 for (
int i = 0; i < numManifolds; i++)
 
 1476                                         for (
int j = 0; j < numContacts; j++)
 
 1531                                                 minAabb -= contactThreshold;
 
 1532                                                 maxAabb += contactThreshold;
 
 1539                                                         minAabb2 -= contactThreshold;
 
 1540                                                         maxAabb2 += contactThreshold;
 
 1541                                                         minAabb.
setMin(minAabb2);
 
 1542                                                         maxAabb.
setMax(maxAabb2);
 
 1565                 if (!serializedShapes.
find(shape))
 
 1567                         serializedShapes.
insert(shape, shape);
 
 1588                 for (
int i = 0; i < numManifolds; i++)
 
 1597                         const char* structType = manifold->
serialize(manifold, chunk->
m_oldPtr, serializer);