Changeset 2430 for code/branches/physics/src/bullet/BulletCollision/CollisionDispatch

Timestamp:

Dec 13, 2008, 11:45:51 PM (16 years ago)

Author:

rgrieder

Message:

Updated to Bullet 2.73 (first part).

Location:

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch

Files:

• SphereTriangleDetector.cpp (modified) (5 diffs)
• SphereTriangleDetector.h (modified) (4 diffs)
• btActivatingCollisionAlgorithm.cpp (added)
• btActivatingCollisionAlgorithm.h (added)
• btBoxBoxCollisionAlgorithm.cpp (modified) (1 diff)
• btBoxBoxCollisionAlgorithm.h (modified) (3 diffs)
• btBoxBoxDetector.cpp (modified) (1 diff)
• btCollisionConfiguration.h (modified) (1 diff)
• btCollisionCreateFunc.h (modified) (1 diff)
• btCollisionDispatcher.cpp (modified) (3 diffs)
• btCollisionObject.h (modified) (11 diffs)
• btCollisionWorld.cpp (modified) (18 diffs)
• btCollisionWorld.h (modified) (6 diffs)
• btCompoundCollisionAlgorithm.cpp (modified) (1 diff)
• btCompoundCollisionAlgorithm.h (modified) (2 diffs)
• btConvexConcaveCollisionAlgorithm.cpp (modified) (3 diffs)
• btConvexConcaveCollisionAlgorithm.h (modified) (4 diffs)
• btConvexConvexAlgorithm.cpp (modified) (3 diffs)
• btConvexConvexAlgorithm.h (modified) (2 diffs)
• btDefaultCollisionConfiguration.cpp (modified) (1 diff)
• btDefaultCollisionConfiguration.h (modified) (2 diffs)
• btGhostObject.cpp (added)
• btGhostObject.h (added)
• btManifoldResult.cpp (modified) (1 diff)
• btSimulationIslandManager.cpp (modified) (4 diffs)
• btSimulationIslandManager.h (modified) (2 diffs)
• btSphereBoxCollisionAlgorithm.cpp (modified) (1 diff)
• btSphereBoxCollisionAlgorithm.h (modified) (2 diffs)
• btSphereSphereCollisionAlgorithm.cpp (modified) (1 diff)
• btSphereSphereCollisionAlgorithm.h (modified) (3 diffs)
• btSphereTriangleCollisionAlgorithm.cpp (modified) (2 diffs)
• btSphereTriangleCollisionAlgorithm.h (modified) (3 diffs)

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp

@@ -20 +20 @@
 
 
-SphereTriangleDetector::SphereTriangleDetector(btSphereShape* sphere,btTriangleShape* triangle)
+SphereTriangleDetector::SphereTriangleDetector(btSphereShape* sphere,btTriangleShape* triangle,btScalar contactBreakingThreshold)
 :m_sphere(sphere),
-m_triangle(triangle)
+m_triangle(triangle),
+m_contactBreakingThreshold(contactBreakingThreshold)
 {
 
@@ -41 +42 @@
         btTransform     sphereInTr = transformB.inverseTimes(transformA);
 
-        if (collide(sphereInTr.getOrigin(),point,normal,depth,timeOfImpact))
+        if (collide(sphereInTr.getOrigin(),point,normal,depth,timeOfImpact,m_contactBreakingThreshold))
         {
                 if (swapResults)
@@ -94 +95 @@
 
 ///combined discrete/continuous sphere-triangle
-bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact)
+bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact, btScalar contactBreakingThreshold)
 {
 
@@ -116 +117 @@
         }
 
-        ///todo: move this gContactBreakingThreshold into a proper structure
-        extern btScalar gContactBreakingThreshold;
-
-        btScalar contactMargin = gContactBreakingThreshold;
+        btScalar contactMargin = contactBreakingThreshold;
         bool isInsideContactPlane = distanceFromPlane < r + contactMargin;
         bool isInsideShellPlane = distanceFromPlane < r;
@@ -141 +139 @@
                         for (int i = 0; i < m_triangle->getNumEdges(); i++) {
                                 
-                                btPoint3 pa;
-                                btPoint3 pb;
+                                btVector3 pa;
+                                btVector3 pb;
                                 
                                 m_triangle->getEdge(i,pa,pb);

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/SphereTriangleDetector.h

@@ -18 +18 @@
 
 #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
-#include "LinearMath/btPoint3.h"
+
 
 
@@ -31 +31 @@
         virtual void    getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw,bool swapResults=false);
 
-        SphereTriangleDetector(btSphereShape* sphere,btTriangleShape* triangle);
+        SphereTriangleDetector(btSphereShape* sphere,btTriangleShape* triangle, btScalar contactBreakingThreshold);
 
         virtual ~SphereTriangleDetector() {};
@@ -37 +37 @@
 private:
 
-        bool collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact);
+        bool collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact, btScalar contactBreakingThreshold);
         bool pointInTriangle(const btVector3 vertices[], const btVector3 &normal, btVector3 *p );
         bool facecontains(const btVector3 &p,const btVector3* vertices,btVector3& normal);
@@ -43 +43 @@
         btSphereShape* m_sphere;
         btTriangleShape* m_triangle;
-
+        btScalar        m_contactBreakingThreshold;
         
 };

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp

@@ -23 +23 @@
 
 btBoxBoxCollisionAlgorithm::btBoxBoxCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* obj0,btCollisionObject* obj1)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,obj0,obj1),
 m_ownManifold(false),
 m_manifoldPtr(mf)

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h

@@ -17 +17 @@
 #define BOX_BOX__COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
@@ -25 +25 @@
 
 ///box-box collision detection
-class btBoxBoxCollisionAlgorithm : public btCollisionAlgorithm
+class btBoxBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
         bool    m_ownManifold;
@@ -32 +32 @@
 public:
         btBoxBoxCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
-                : btCollisionAlgorithm(ci) {}
+                : btActivatingCollisionAlgorithm(ci) {}
 
         virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp

@@ -208 +208 @@
     }
     q = p[n*2-2]*p[1] - p[0]*p[n*2-1];
-    a = 1.f/(btScalar(3.0)*(a+q));
+        if (btFabs(a+q) > SIMD_EPSILON)
+        {
+                a = 1.f/(btScalar(3.0)*(a+q));
+        } else
+        {
+                a=1e30f;
+        }
     cx = a*(cx + q*(p[n*2-2]+p[0]));
     cy = a*(cy + q*(p[n*2-1]+p[1]));

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCollisionConfiguration.h

@@ -23 +23 @@
 ///btCollisionConfiguration allows to configure Bullet collision detection
 ///stack allocator size, default collision algorithms and persistent manifold pool size
-///todo: describe the meaning
+///@todo: describe the meaning
 class   btCollisionConfiguration
 {

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h

@@ -18 +18 @@
 
 #include "LinearMath/btAlignedObjectArray.h"
-typedef btAlignedObjectArray<class btCollisionObject*> btCollisionObjectArray;
 class btCollisionAlgorithm;
 class btCollisionObject;

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

@@ -58 +58 @@
         
         
-};
+}
 
 
@@ -79 +79 @@
         btCollisionObject* body0 = (btCollisionObject*)b0;
         btCollisionObject* body1 = (btCollisionObject*)b1;
+
+        btScalar contactBreakingThreshold = btMin(gContactBreakingThreshold,btMin(body0->getCollisionShape()->getContactBreakingThreshold(),body1->getCollisionShape()->getContactBreakingThreshold()));
         
         void* mem = 0;
@@ -90 +92 @@
 
         }
-        btPersistentManifold* manifold = new(mem) btPersistentManifold (body0,body1,0);
+        btPersistentManifold* manifold = new(mem) btPersistentManifold (body0,body1,0,contactBreakingThreshold);
         manifold->m_index1a = m_manifoldsPtr.size();
         m_manifoldsPtr.push_back(manifold);

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCollisionObject.h

@@ -30 +30 @@
 #include "LinearMath/btMotionState.h"
 #include "LinearMath/btAlignedAllocator.h"
-
+#include "LinearMath/btAlignedObjectArray.h"
+
+
+typedef btAlignedObjectArray<class btCollisionObject*> btCollisionObjectArray;
 
 
@@ -72 +75 @@
         void*                   m_userObjectPointer;
 
-        ///m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody etc.
+        ///m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
         ///do not assign your own m_internalType unless you write a new dynamics object class.
         int                             m_internalType;
@@ -104 +107 @@
                 CF_KINEMATIC_OBJECT= 2,
                 CF_NO_CONTACT_RESPONSE = 4,
-                CF_CUSTOM_MATERIAL_CALLBACK = 8//this allows per-triangle material (friction/restitution)
+                CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
+                CF_CHARACTER_OBJECT = 16
         };
 
@@ -111 +115 @@
                 CO_COLLISION_OBJECT =1,
                 CO_RIGID_BODY,
-                CO_SOFT_BODY
+                CO_SOFT_BODY,
+                ///CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter
+                ///It is useful for collision sensors, explosion objects, character controller etc.
+                CO_GHOST_OBJECT
         };
 
@@ -177 +184 @@
         }
 
-        int     getActivationState() const { return m_activationState1;}
+        SIMD_FORCE_INLINE       int     getActivationState() const { return m_activationState1;}
         
         void setActivationState(int newState);
@@ -194 +201 @@
         void    activate(bool forceActivation = false);
 
-        inline bool isActive() const
+        SIMD_FORCE_INLINE bool isActive() const
         {
                 return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
@@ -238 +245 @@
 
 
-        btBroadphaseProxy*      getBroadphaseHandle()
+        SIMD_FORCE_INLINE btBroadphaseProxy*    getBroadphaseHandle()
         {
                 return m_broadphaseHandle;
         }
 
-        const btBroadphaseProxy*        getBroadphaseHandle() const
+        SIMD_FORCE_INLINE const btBroadphaseProxy*      getBroadphaseHandle() const
         {
                 return m_broadphaseHandle;
@@ -289 +296 @@
         }
 
-        const int getIslandTag() const
+        SIMD_FORCE_INLINE int getIslandTag() const
         {
                 return  m_islandTag1;
@@ -299 +306 @@
         }
 
-        const int getCompanionId() const
+        SIMD_FORCE_INLINE int getCompanionId() const
         {
                 return  m_companionId;
@@ -309 +316 @@
         }
 
-        const btScalar                  getHitFraction() const
+        SIMD_FORCE_INLINE btScalar                      getHitFraction() const
         {
                 return m_hitFraction; 
@@ -320 +327 @@
 
         
-        const int       getCollisionFlags() const
+        SIMD_FORCE_INLINE int   getCollisionFlags() const
         {
                 return m_collisionFlags;

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

@@ -33 +33 @@
 #include "LinearMath/btStackAlloc.h"
 
+//#define USE_BRUTEFORCE_RAYBROADPHASE 1
+//RECALCULATE_AABB is slower, but benefit is that you don't need to call 'stepSimulation'  or 'updateAabbs' before using a rayTest
+//#define RECALCULATE_AABB_RAYCAST 1
 
 //When the user doesn't provide dispatcher or broadphase, create basic versions (and delete them in destructor)
@@ -114 +117 @@
 }
 
+
+
 void    btCollisionWorld::updateAabbs()
 {
@@ -126 +131 @@
                 if (colObj->isActive())
                 {
-                        btPoint3 minAabb,maxAabb;
+                        btVector3 minAabb,maxAabb;
                         colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
                         //need to increase the aabb for contact thresholds
@@ -227 +232 @@
         if (collisionShape->isConvex())
         {
+//              BT_PROFILE("rayTestConvex");
                 btConvexCast::CastResult castResult;
                 castResult.m_fraction = resultCallback.m_closestHitFraction;
@@ -270 +276 @@
                 if (collisionShape->isConcave())
                 {
+//                      BT_PROFILE("rayTestConcave");
                         if (collisionShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
                         {
@@ -318 +325 @@
                         } else
                         {
-                                btTriangleMeshShape* triangleMesh = (btTriangleMeshShape*)collisionShape;
+                                //generic (slower) case
+                                btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;
 
                                 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
@@ -331 +339 @@
                                         btCollisionWorld::RayResultCallback* m_resultCallback;
                                         btCollisionObject*      m_collisionObject;
-                                        btTriangleMeshShape*    m_triangleMesh;
+                                        btConcaveShape* m_triangleMesh;
 
                                         BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
-                                                btCollisionWorld::RayResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape*    triangleMesh):
+                                                btCollisionWorld::RayResultCallback* resultCallback, btCollisionObject* collisionObject,btConcaveShape* triangleMesh):
                                                 btTriangleRaycastCallback(from,to),
                                                         m_resultCallback(resultCallback),
@@ -364 +372 @@
 
 
-                                BridgeTriangleRaycastCallback   rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObject,triangleMesh);
+                                BridgeTriangleRaycastCallback   rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObject,concaveShape);
                                 rcb.m_hitFraction = resultCallback.m_closestHitFraction;
 
@@ -372 +380 @@
                                 rayAabbMaxLocal.setMax(rayToLocal);
 
-                                triangleMesh->processAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
+                                concaveShape->processAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
                         }
                 } else {
-                        //todo: use AABB tree or other BVH acceleration structure!
+//                      BT_PROFILE("rayTestCompound");
+                        ///@todo: use AABB tree or other BVH acceleration structure, see btDbvt
                         if (collisionShape->isCompound())
                         {
@@ -409 +418 @@
         if (collisionShape->isConvex())
         {
+                //BT_PROFILE("convexSweepConvex");
                 btConvexCast::CastResult castResult;
                 castResult.m_allowedPenetration = allowedPenetration;
-                castResult.m_fraction = btScalar(1.);//??
+                castResult.m_fraction = resultCallback.m_closestHitFraction;//btScalar(1.);//??
 
                 btConvexShape* convexShape = (btConvexShape*) collisionShape;
@@ -453 +463 @@
                         if (collisionShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
                         {
+                                //BT_PROFILE("convexSweepbtBvhTriangleMesh");
                                 btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
                                 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
@@ -509 +520 @@
                         } else
                         {
-                                btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
+                                //BT_PROFILE("convexSweepConcave");
+                                btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;
                                 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
                                 btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
@@ -521 +533 @@
                                         btCollisionWorld::ConvexResultCallback* m_resultCallback;
                                         btCollisionObject*      m_collisionObject;
-                                        btTriangleMeshShape*    m_triangleMesh;
+                                        btConcaveShape* m_triangleMesh;
 
                                         BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from,const btTransform& to,
-                                                btCollisionWorld::ConvexResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape* triangleMesh, const btTransform& triangleToWorld):
+                                                btCollisionWorld::ConvexResultCallback* resultCallback, btCollisionObject* collisionObject,btConcaveShape*      triangleMesh, const btTransform& triangleToWorld):
                                                 btTriangleConvexcastCallback(castShape, from,to, triangleToWorld, triangleMesh->getMargin()),
                                                         m_resultCallback(resultCallback),
@@ -557 +569 @@
                                 };
 
-                                BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,collisionObject,triangleMesh, colObjWorldTransform);
+                                BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,collisionObject,concaveShape, colObjWorldTransform);
                                 tccb.m_hitFraction = resultCallback.m_closestHitFraction;
                                 btVector3 boxMinLocal, boxMaxLocal;
@@ -568 +580 @@
                                 rayAabbMinLocal += boxMinLocal;
                                 rayAabbMaxLocal += boxMaxLocal;
-                                triangleMesh->processAllTriangles(&tccb,rayAabbMinLocal,rayAabbMaxLocal);
+                                concaveShape->processAllTriangles(&tccb,rayAabbMinLocal,rayAabbMaxLocal);
                         }
                 } else {
-                        //todo: use AABB tree or other BVH acceleration structure!
+                        ///@todo : use AABB tree or other BVH acceleration structure!
                         if (collisionShape->isCompound())
                         {
+                                BT_PROFILE("convexSweepCompound");
                                 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
                                 int i=0;
@@ -597 +610 @@
 }
 
-void    btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
-{
-
-
-        btTransform     rayFromTrans,rayToTrans;
-        rayFromTrans.setIdentity();
-        rayFromTrans.setOrigin(rayFromWorld);
-        rayToTrans.setIdentity();
-
-        rayToTrans.setOrigin(rayToWorld);
-
-        /// go over all objects, and if the ray intersects their aabb, do a ray-shape query using convexCaster (CCD)
-
-        int i;
-        for (i=0;i<m_collisionObjects.size();i++)
+
+struct btSingleRayCallback : public btBroadphaseRayCallback
+{
+
+        btVector3       m_rayFromWorld;
+        btVector3       m_rayToWorld;
+        btTransform     m_rayFromTrans;
+        btTransform     m_rayToTrans;
+        btVector3       m_hitNormal;
+
+        const btCollisionWorld* m_world;
+        btCollisionWorld::RayResultCallback&    m_resultCallback;
+
+        btSingleRayCallback(const btVector3& rayFromWorld,const btVector3& rayToWorld,const btCollisionWorld* world,btCollisionWorld::RayResultCallback& resultCallback)
+        :m_rayFromWorld(rayFromWorld),
+        m_rayToWorld(rayToWorld),
+        m_world(world),
+        m_resultCallback(resultCallback)
+        {
+                m_rayFromTrans.setIdentity();
+                m_rayFromTrans.setOrigin(m_rayFromWorld);
+                m_rayToTrans.setIdentity();
+                m_rayToTrans.setOrigin(m_rayToWorld);
+
+                btVector3 rayDir = (rayToWorld-rayFromWorld);
+
+                rayDir.normalize ();
+                ///what about division by zero? --> just set rayDirection[i] to INF/1e30
+                m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[0];
+                m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[1];
+                m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[2];
+                m_signs[0] = m_rayDirectionInverse[0] < 0.0;
+                m_signs[1] = m_rayDirectionInverse[1] < 0.0;
+                m_signs[2] = m_rayDirectionInverse[2] < 0.0;
+
+                m_lambda_max = rayDir.dot(m_rayToWorld-m_rayFromWorld);
+
+        }
+
+        
+
+        virtual bool    process(const btBroadphaseProxy* proxy)
         {
                 ///terminate further ray tests, once the closestHitFraction reached zero
-                if (resultCallback.m_closestHitFraction == btScalar(0.f))
-                        break;
-
-                btCollisionObject*      collisionObject= m_collisionObjects[i];
+                if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
+                        return false;
+
+                btCollisionObject*      collisionObject = (btCollisionObject*)proxy->m_clientObject;
+
                 //only perform raycast if filterMask matches
-                if(resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
+                if(m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) 
+                {
                         //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
+                        //btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
+                        
+#ifdef RECALCULATE_AABB
                         btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
                         collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
-
-                        btScalar hitLambda = resultCallback.m_closestHitFraction;
-                        btVector3 hitNormal;
-                        if (btRayAabb(rayFromWorld,rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
-                        {
-                                rayTestSingle(rayFromTrans,rayToTrans,
+#else
+                        //getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
+                        const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
+                        const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
+#endif
+                        //btScalar hitLambda = m_resultCallback.m_closestHitFraction;
+                        //culling already done by broadphase
+                        //if (btRayAabb(m_rayFromWorld,m_rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,m_hitNormal))
+                        {
+                                m_world->rayTestSingle(m_rayFromTrans,m_rayToTrans,
                                         collisionObject,
                                                 collisionObject->getCollisionShape(),
                                                 collisionObject->getWorldTransform(),
-                                                resultCallback);
+                                                m_resultCallback);
                         }
                 }
-
-        }
-
-}
-
-void    btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, ConvexResultCallback& resultCallback) const
-{
+                return true;
+        }
+};
+
+void    btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
+{
+        BT_PROFILE("rayTest");
+        /// use the broadphase to accelerate the search for objects, based on their aabb
+        /// and for each object with ray-aabb overlap, perform an exact ray test
+        btSingleRayCallback rayCB(rayFromWorld,rayToWorld,this,resultCallback);
+
+#ifndef USE_BRUTEFORCE_RAYBROADPHASE
+        m_broadphasePairCache->rayTest(rayFromWorld,rayToWorld,rayCB);
+#else
+        for (int i=0;i<this->getNumCollisionObjects();i++)
+        {
+                rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
+        }       
+#endif //USE_BRUTEFORCE_RAYBROADPHASE
+
+}
+
+
+struct btSingleSweepCallback : public btBroadphaseRayCallback
+{
+
+        btTransform     m_convexFromTrans;
+        btTransform     m_convexToTrans;
+        btVector3       m_hitNormal;
+        const btCollisionWorld* m_world;
+        btCollisionWorld::ConvexResultCallback& m_resultCallback;
+        btScalar        m_allowedCcdPenetration;
+        const btConvexShape* m_castShape;
+
+
+        btSingleSweepCallback(const btConvexShape* castShape, const btTransform& convexFromTrans,const btTransform& convexToTrans,const btCollisionWorld* world,btCollisionWorld::ConvexResultCallback& resultCallback,btScalar allowedPenetration)
+                :m_convexFromTrans(convexFromTrans),
+                m_convexToTrans(convexToTrans),
+                m_world(world),
+                m_resultCallback(resultCallback),
+                m_allowedCcdPenetration(allowedPenetration),
+                m_castShape(castShape)
+        {
+                btVector3 unnormalizedRayDir = (m_convexToTrans.getOrigin()-m_convexFromTrans.getOrigin());
+                btVector3 rayDir = unnormalizedRayDir.normalized();
+                ///what about division by zero? --> just set rayDirection[i] to INF/1e30
+                m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[0];
+                m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[1];
+                m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[2];
+                m_signs[0] = m_rayDirectionInverse[0] < 0.0;
+                m_signs[1] = m_rayDirectionInverse[1] < 0.0;
+                m_signs[2] = m_rayDirectionInverse[2] < 0.0;
+
+                m_lambda_max = rayDir.dot(unnormalizedRayDir);
+
+        }
+
+        virtual bool    process(const btBroadphaseProxy* proxy)
+        {
+                ///terminate further convex sweep tests, once the closestHitFraction reached zero
+                if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
+                        return false;
+
+                btCollisionObject*      collisionObject = (btCollisionObject*)proxy->m_clientObject;
+
+                //only perform raycast if filterMask matches
+                if(m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
+                        //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
+                        m_world->objectQuerySingle(m_castShape, m_convexFromTrans,m_convexToTrans,
+                                        collisionObject,
+                                                collisionObject->getCollisionShape(),
+                                                collisionObject->getWorldTransform(),
+                                                m_resultCallback,
+                                                m_allowedCcdPenetration);
+                }
+                
+                return true;
+        }
+};
+
+
+
+void    btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration) const
+{
+
+        BT_PROFILE("convexSweepTest");
+        /// use the broadphase to accelerate the search for objects, based on their aabb
+        /// and for each object with ray-aabb overlap, perform an exact ray test
+        /// unfortunately the implementation for rayTest and convexSweepTest duplicated, albeit practically identical
+
+        
+
         btTransform     convexFromTrans,convexToTrans;
         convexFromTrans = convexFromWorld;
@@ -650 +784 @@
                 btVector3 linVel, angVel;
                 btTransformUtil::calculateVelocity (convexFromTrans, convexToTrans, 1.0, linVel, angVel);
+                btVector3 zeroLinVel;
+                zeroLinVel.setValue(0,0,0);
                 btTransform R;
                 R.setIdentity ();
                 R.setRotation (convexFromTrans.getRotation());
-                castShape->calculateTemporalAabb (R, linVel, angVel, 1.0, castShapeAabbMin, castShapeAabbMax);
-        }
-
+                castShape->calculateTemporalAabb (R, zeroLinVel, angVel, 1.0, castShapeAabbMin, castShapeAabbMax);
+        }
+
+#ifndef USE_BRUTEFORCE_RAYBROADPHASE
+
+        btSingleSweepCallback   convexCB(castShape,convexFromWorld,convexToWorld,this,resultCallback,allowedCcdPenetration);
+
+        m_broadphasePairCache->rayTest(convexFromTrans.getOrigin(),convexToTrans.getOrigin(),convexCB,castShapeAabbMin,castShapeAabbMax);
+
+#else
         /// go over all objects, and if the ray intersects their aabb + cast shape aabb,
         // do a ray-shape query using convexCaster (CCD)
@@ -677 +820 @@
                                                 collisionObject->getWorldTransform(),
                                                 resultCallback,
-                                                getDispatchInfo().m_allowedCcdPenetration);
+                                                allowedCcdPenetration);
                         }
                 }
         }
-
-}
+#endif //USE_BRUTEFORCE_RAYBROADPHASE
+}

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -1 +1 @@
 /*
 Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+Copyright (c) 2003-2006 Erwin Coumans  http://bulletphysics.com/Bullet/
 
 This software is provided 'as-is', without any express or implied warranty.
@@ -23 +23 @@
  * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ).
  *
- * There is the Physics Forum for Feedback and bteral Collision Detection and Physics discussions.
- * Please visit http://www.continuousphysics.com/Bullet/phpBB2/index.php
+ * There is the Physics Forum for feedback and general Collision Detection and Physics discussions.
+ * Please visit http://www.bulletphysics.com
  *
  * @section install_sec Installation
  *
  * @subsection step1 Step 1: Download
- * You can download the Bullet Physics Library from our website: http://www.continuousphysics.com/Bullet/
+ * You can download the Bullet Physics Library from the Google Code repository: http://code.google.com/p/bullet/downloads/list
  * @subsection step2 Step 2: Building
  * Bullet comes with autogenerated Project Files for Microsoft Visual Studio 6, 7, 7.1 and 8.
  * The main Workspace/Solution is located in Bullet/msvc/8/wksbullet.sln (replace 8 with your version).
  * 
- * Under other platforms, like Linux or Mac OS-X, Bullet can be build using either using make, cmake, http://www.cmake.org, or jam, http://www.perforce.com/jam/jam.html . cmake can autogenerate Xcode, KDevelop, MSVC and other build systems. just run cmake . in the root of Bullet.
+ * Under other platforms, like Linux or Mac OS-X, Bullet can be build using either using make, cmake, http://www.cmake.org , or jam, http://www.perforce.com/jam/jam.html . cmake can autogenerate Xcode, KDevelop, MSVC and other build systems. just run cmake . in the root of Bullet.
  * So if you are not using MSVC or cmake, you can run ./autogen.sh ./configure to create both Makefile and Jamfile and then run make or jam.
  * Jam is a build system that can build the library, demos and also autogenerate the MSVC Project Files.
- * If you don't have jam installed, you can make jam from the included jam-2.5 sources, or download jam from ftp://ftp.perforce.com/pub/jam/
+ * If you don't have jam installed, you can make jam from the included jam-2.5 sources, or download jam from ftp://ftp.perforce.com/jam
  * 
  * @subsection step3 Step 3: Testing demos
@@ -72 +72 @@
 #include "LinearMath/btTransform.h"
 #include "btCollisionObject.h"
-#include "btCollisionDispatcher.h" //for definition of btCollisionObjectArray
+#include "btCollisionDispatcher.h"
 #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
 #include "LinearMath/btAlignedObjectArray.h"
@@ -108 +108 @@
         }
 
+        const btBroadphaseInterface*    getBroadphase() const
+        {
+                return m_broadphasePairCache;
+        }
+
         btBroadphaseInterface*  getBroadphase()
         {
@@ -131 +136 @@
         virtual void    updateAabbs();
 
+        
         virtual void    setDebugDrawer(btIDebugDraw*    debugDrawer)
         {
@@ -348 +354 @@
         // convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback
         // This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback.
-        void    convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback) const;
+        void    convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback,  btScalar allowedCcdPenetration = btScalar(0.)) const;
 
 

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -22 +22 @@
 
 btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped)
-:btCollisionAlgorithm(ci),
+:btActivatingCollisionAlgorithm(ci,body0,body1),
 m_isSwapped(isSwapped),
 m_sharedManifold(ci.m_manifold)

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

@@ -17 +17 @@
 #define COMPOUND_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
@@ -29 +29 @@
 
 /// btCompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
-class btCompoundCollisionAlgorithm  : public btCollisionAlgorithm
+class btCompoundCollisionAlgorithm  : public btActivatingCollisionAlgorithm
 {
         btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithms;

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

@@ -28 +28 @@
 
 btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1,bool isSwapped)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,body0,body1),
 m_isSwapped(isSwapped),
 m_btConvexTriangleCallback(ci.m_dispatcher1,body0,body1,isSwapped)
@@ -73 +73 @@
 {
         m_dispatcher->clearManifold(m_manifoldPtr);
-};
+}
 
 
@@ -94 +94 @@
         
         ///debug drawing of the overlapping triangles
-        if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && m_dispatchInfoPtr->m_debugDraw->getDebugMode() > 0)
+        if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && (m_dispatchInfoPtr->m_debugDraw->getDebugMode() &btIDebugDraw::DBG_DrawWireframe ))
         {
                 btVector3 color(255,255,0);

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h

@@ -17 +17 @@
 #define CONVEX_CONCAVE_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
@@ -35 +35 @@
         btVector3       m_aabbMax ;
 
+
         btManifoldResult* m_resultOut;
-
         btDispatcher*   m_dispatcher;
         const btDispatcherInfo* m_dispatchInfoPtr;
@@ -71 +71 @@
 
 /// btConvexConcaveCollisionAlgorithm  supports collision between convex shapes and (concave) trianges meshes.
-class btConvexConcaveCollisionAlgorithm  : public btCollisionAlgorithm
+class btConvexConcaveCollisionAlgorithm  : public btActivatingCollisionAlgorithm
 {
 
@@ -77 +77 @@
 
         btConvexTriangleCallback m_btConvexTriangleCallback;
+
 
 

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -39 +39 @@
 #include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h"
 
-#include "BulletCollision/NarrowPhaseCollision/btGjkEpa.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
 #include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
 
@@ -61 +61 @@
 
 btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver)
-: btCollisionAlgorithm(ci),
-m_gjkPairDetector(0,0,simplexSolver,pdSolver),
+: btActivatingCollisionAlgorithm(ci,body0,body1),
+m_simplexSolver(simplexSolver),
+m_pdSolver(pdSolver),
 m_ownManifold (false),
 m_manifoldPtr(mf),
 m_lowLevelOfDetail(false)
+#ifdef USE_SEPDISTANCE_UTIL2
+,m_sepDistance((static_cast<btConvexShape*>(body0->getCollisionShape()))->getAngularMotionDisc(),
+                          (static_cast<btConvexShape*>(body1->getCollisionShape()))->getAngularMotionDisc())
+#endif
 {
         (void)body0;
         (void)body1;
-
-
 }
 
@@ -108 +111 @@
         resultOut->setPersistentManifold(m_manifoldPtr);
 
-#ifdef USE_BT_GJKEPA
-        btConvexShape*                          shape0(static_cast<btConvexShape*>(body0->getCollisionShape()));
-        btConvexShape*                          shape1(static_cast<btConvexShape*>(body1->getCollisionShape()));
-        const btScalar                          radialmargin(0/*shape0->getMargin()+shape1->getMargin()*/);
-        btGjkEpaSolver::sResults        results;
-        if(btGjkEpaSolver::Collide(     shape0,body0->getWorldTransform(),
-                                                                shape1,body1->getWorldTransform(),
-                                                                radialmargin,results))
-                {
-                dispatchInfo.m_debugDraw->drawLine(results.witnesses[1],results.witnesses[1]+results.normal,btVector3(255,0,0));
-                resultOut->addContactPoint(results.normal,results.witnesses[1],-results.depth);
-                }
-#else
+        
 
         btConvexShape* min0 = static_cast<btConvexShape*>(body0->getCollisionShape());
         btConvexShape* min1 = static_cast<btConvexShape*>(body1->getCollisionShape());
+
+#ifdef USE_SEPDISTANCE_UTIL2
+        m_sepDistance.updateSeparatingDistance(body0->getWorldTransform(),body1->getWorldTransform());
+        if (!dispatchInfo.m_useConvexConservativeDistanceUtil || m_sepDistance.getConservativeSeparatingDistance()<=0.f)
+#endif //USE_SEPDISTANCE_UTIL2
+
+        {
+
         
         btGjkPairDetector::ClosestPointInput input;
 
+        btGjkPairDetector       gjkPairDetector(min0,min1,m_simplexSolver,m_pdSolver);
         //TODO: if (dispatchInfo.m_useContinuous)
-        m_gjkPairDetector.setMinkowskiA(min0);
-        m_gjkPairDetector.setMinkowskiB(min1);
-        input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold();
-        input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
+        gjkPairDetector.setMinkowskiA(min0);
+        gjkPairDetector.setMinkowskiB(min1);
+
+#ifdef USE_SEPDISTANCE_UTIL2
+        if (dispatchInfo.m_useConvexConservativeDistanceUtil)
+        {
+                input.m_maximumDistanceSquared = 1e30f;
+        } else
+#endif //USE_SEPDISTANCE_UTIL2
+        {
+                input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold();
+                input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
+        }
+
         input.m_stackAlloc = dispatchInfo.m_stackAllocator;
-
-//      input.m_maximumDistanceSquared = btScalar(1e30);
-        
         input.m_transformA = body0->getWorldTransform();
         input.m_transformB = body1->getWorldTransform();
-        
-        m_gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
-#endif
+
+        gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
+
+        btScalar sepDist = gjkPairDetector.getCachedSeparatingDistance()+dispatchInfo.m_convexConservativeDistanceThreshold;
+
+#ifdef USE_SEPDISTANCE_UTIL2
+        if (dispatchInfo.m_useConvexConservativeDistanceUtil)
+        {
+                m_sepDistance.initSeparatingDistance(gjkPairDetector.getCachedSeparatingAxis(),sepDist,body0->getWorldTransform(),body1->getWorldTransform());
+        }
+#endif //USE_SEPDISTANCE_UTIL2
+
+
+        }
 
         if (m_ownManifold)

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h

@@ -17 +17 @@
 #define CONVEX_CONVEX_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
@@ -24 +24 @@
 #include "btCollisionCreateFunc.h"
 #include "btCollisionDispatcher.h"
+#include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil
 
 class btConvexPenetrationDepthSolver;
 
+///Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation. However, when using large size ratios GJK can be imprecise
+///so the distance is not conservative. In that case, enabling this USE_SEPDISTANCE_UTIL2 would result in failing/missing collisions.
+///Either improve GJK for large size ratios (testing a 100 units versus a 0.1 unit object) or only enable the util
+///for certain pairs that have a small size ratio
+///#define USE_SEPDISTANCE_UTIL2 1
+
 ///ConvexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations.
-class btConvexConvexAlgorithm : public btCollisionAlgorithm
+class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
 {
-        btGjkPairDetector m_gjkPairDetector;
-public:
+#ifdef USE_SEPDISTANCE_UTIL2
+        btConvexSeparatingDistanceUtil  m_sepDistance;
+#endif
+        btSimplexSolverInterface*               m_simplexSolver;
+        btConvexPenetrationDepthSolver* m_pdSolver;
 
+        
         bool    m_ownManifold;
         btPersistentManifold*   m_manifoldPtr;
         bool                    m_lowLevelOfDetail;
+        
+        ///cache separating vector to speedup collision detection
         
 

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp

@@ -101 +101 @@
         int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm);
         int maxSize3 = sizeof(btCompoundCollisionAlgorithm);
-        int maxSize4 = sizeof(btEmptyAlgorithm);
-        
+        int sl = sizeof(btConvexSeparatingDistanceUtil);
+        sl = sizeof(btGjkPairDetector);
         int     collisionAlgorithmMaxElementSize = btMax(maxSize,maxSize2);
         collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize3);
-        collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize4);
 
         if (constructionInfo.m_stackAlloc)

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h

@@ -34 +34 @@
                 m_persistentManifoldPool(0),
                 m_collisionAlgorithmPool(0),
-                m_defaultMaxPersistentManifoldPoolSize(65535),
-                m_defaultMaxCollisionAlgorithmPoolSize(65535),
-                m_defaultStackAllocatorSize(5*1024*1024)
+                m_defaultMaxPersistentManifoldPoolSize(4096),
+                m_defaultMaxCollisionAlgorithmPoolSize(4096),
+                m_defaultStackAllocatorSize(0)
         {
         }
@@ -45 +45 @@
 ///btCollisionConfiguration allows to configure Bullet collision detection
 ///stack allocator, pool memory allocators
-///todo: describe the meaning
+///@todo: describe the meaning
 class   btDefaultCollisionConfiguration : public btCollisionConfiguration
 {

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btManifoldResult.cpp

@@ -94 +94 @@
    newPt.m_index1  = m_index1;
         
-        ///todo, check this for any side effects
+        ///@todo, check this for any side effects
         if (insertIndex >= 0)
         {

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -144 +144 @@
 
 
-void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects)
+void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisionWorld* collisionWorld)
 {
 
         BT_PROFILE("islandUnionFindAndQuickSort");
         
+        btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray();
+
         m_islandmanifold.resize(0);
 
@@ -239 +241 @@
                                         {
                                                 colObj0->setActivationState( WANTS_DEACTIVATION);
+                                                colObj0->setDeactivationTime(0.f);
                                         }
                                 }
@@ -263 +266 @@
                  btCollisionObject* colObj1 = static_cast<btCollisionObject*>(manifold->getBody1());
                 
-                 //todo: check sleeping conditions!
+                 ///@todo: check sleeping conditions!
                  if (((colObj0) && colObj0->getActivationState() != ISLAND_SLEEPING) ||
                         ((colObj1) && colObj1->getActivationState() != ISLAND_SLEEPING))
@@ -288 +291 @@
 
 
-//
-// todo: this is random access, it can be walked 'cache friendly'!
-//
-void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback)
-{
-
-        buildIslands(dispatcher,collisionObjects);
+///@todo: this is random access, it can be walked 'cache friendly'!
+void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,btCollisionWorld* collisionWorld, IslandCallback* callback)
+{
+        btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray();
+
+        buildIslands(dispatcher,collisionWorld);
 
         int endIslandIndex=1;

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.h

@@ -20 +20 @@
 #include "btCollisionCreateFunc.h"
 #include "LinearMath/btAlignedObjectArray.h"
-
+#include "btCollisionObject.h"
 
 class btCollisionObject;
@@ -62 +62 @@
         };
 
-        void    buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback);
+        void    buildAndProcessIslands(btDispatcher* dispatcher,btCollisionWorld* collisionWorld, IslandCallback* callback);
 
-        void buildIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects);
+        void buildIslands(btDispatcher* dispatcher,btCollisionWorld* colWorld);
 
 };

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp

@@ -22 +22 @@
 
 btSphereBoxCollisionAlgorithm::btSphereBoxCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,col0,col1),
 m_ownManifold(false),
 m_manifoldPtr(mf),

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h

@@ -17 +17 @@
 #define SPHERE_BOX_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
@@ -27 +27 @@
 /// btSphereBoxCollisionAlgorithm  provides sphere-box collision detection.
 /// Other features are frame-coherency (persistent data) and collision response.
-class btSphereBoxCollisionAlgorithm : public btCollisionAlgorithm
+class btSphereBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
         bool    m_ownManifold;

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

@@ -20 +20 @@
 
 btSphereSphereCollisionAlgorithm::btSphereSphereCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,col0,col1),
 m_ownManifold(false),
 m_manifoldPtr(mf)

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h

@@ -17 +17 @@
 #define SPHERE_SPHERE_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
@@ -27 +27 @@
 /// Other features are frame-coherency (persistent data) and collision response.
 /// Also provides the most basic sample for custom/user btCollisionAlgorithm
-class btSphereSphereCollisionAlgorithm : public btCollisionAlgorithm
+class btSphereSphereCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
         bool    m_ownManifold;
@@ -36 +36 @@
 
         btSphereSphereCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
-                : btCollisionAlgorithm(ci) {}
+                : btActivatingCollisionAlgorithm(ci) {}
 
         virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp

@@ -23 +23 @@
 
 btSphereTriangleCollisionAlgorithm::btSphereTriangleCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1,bool swapped)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,col0,col1),
 m_ownManifold(false),
 m_manifoldPtr(mf),
@@ -57 +57 @@
         /// report a contact. internally this will be kept persistent, and contact reduction is done
         resultOut->setPersistentManifold(m_manifoldPtr);
-        SphereTriangleDetector detector(sphere,triangle);
+        SphereTriangleDetector detector(sphere,triangle, m_manifoldPtr->getContactBreakingThreshold());
         
         btDiscreteCollisionDetectorInterface::ClosestPointInput input;
-        input.m_maximumDistanceSquared = btScalar(1e30);//todo: tighter bounds
+        input.m_maximumDistanceSquared = btScalar(1e30);///@todo: tighter bounds
         input.m_transformA = sphereObj->getWorldTransform();
         input.m_transformB = triObj->getWorldTransform();

code/branches/physics/src/bullet/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h

@@ -17 +17 @@
 #define SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
@@ -26 +26 @@
 /// Other features are frame-coherency (persistent data) and collision response.
 /// Also provides the most basic sample for custom/user btCollisionAlgorithm
-class btSphereTriangleCollisionAlgorithm : public btCollisionAlgorithm
+class btSphereTriangleCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
         bool    m_ownManifold;
@@ -36 +36 @@
 
         btSphereTriangleCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
-                : btCollisionAlgorithm(ci) {}
+                : btActivatingCollisionAlgorithm(ci) {}
 
         virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);