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

Timestamp:

Oct 20, 2008, 5:40:38 PM (16 years ago)

Author:

rgrieder

Message:

Downgraded Bullet to latest tagged version: 2.72
That should give us more stability.

Location:

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

Files:

• btCollisionObject.h (modified) (1 diff)
• btCollisionWorld.cpp (modified) (5 diffs)
• btCollisionWorld.h (modified) (1 diff)

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

@@ -238 +238 @@
 
 
-        SIMD_FORCE_INLINE btBroadphaseProxy*    getBroadphaseHandle()
+        btBroadphaseProxy*      getBroadphaseHandle()
         {
                 return m_broadphaseHandle;
         }
 
-        SIMD_FORCE_INLINE const btBroadphaseProxy*      getBroadphaseHandle() const
+        const btBroadphaseProxy*        getBroadphaseHandle() const
         {
                 return m_broadphaseHandle;

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)
@@ -230 +227 @@
         if (collisionShape->isConvex())
         {
-                BT_PROFILE("rayTestConvex");
                 btConvexCast::CastResult castResult;
                 castResult.m_fraction = resultCallback.m_closestHitFraction;
@@ -274 +270 @@
                 if (collisionShape->isConcave())
                 {
-                        BT_PROFILE("rayTestConcave");
                         if (collisionShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
                         {
@@ -380 +375 @@
                         }
                 } else {
-                        BT_PROFILE("rayTestCompound");
                         //todo: use AABB tree or other BVH acceleration structure!
                         if (collisionShape->isCompound())
@@ -603 +597 @@
 }
 
-
-struct btSingleRayCallback : public btBroadphaseRayCallback
-{
-
-        btVector3       m_rayFromWorld;
-        btVector3       m_rayToWorld;
-        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)
-        {
-
-        }
-
-        virtual bool    process(const btBroadphaseProxy* proxy)
+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++)
         {
                 ///terminate further ray tests, once the closestHitFraction reached zero
-                if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
-                        return false;
-
-                btCollisionObject*      collisionObject = (btCollisionObject*)proxy->m_clientObject;
-
+                if (resultCallback.m_closestHitFraction == btScalar(0.f))
+                        break;
+
+                btCollisionObject*      collisionObject= m_collisionObjects[i];
                 //only perform raycast if filterMask matches
-                if(m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) 
-                {
+                if(resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
                         //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
-                        //btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
-                        
-#ifdef RECALCULATE_AABB
                         btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
                         collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
-#else
-                        //getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
-                        btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
-                        btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
-#endif
-                        btScalar hitLambda = m_resultCallback.m_closestHitFraction;
+
+                        btScalar hitLambda = resultCallback.m_closestHitFraction;
                         btVector3 hitNormal;
-                        if (btRayAabb(m_rayFromWorld,m_rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
-                        {
-                                btTransform     rayFromTrans,rayToTrans;
-                                rayFromTrans.setIdentity();
-                                rayFromTrans.setOrigin(m_rayFromWorld);
-                                rayToTrans.setIdentity();
-                                rayToTrans.setOrigin(m_rayToWorld);
-
-                                m_world->rayTestSingle(rayFromTrans,rayToTrans,
+                        if (btRayAabb(rayFromWorld,rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
+                        {
+                                rayTestSingle(rayFromTrans,rayToTrans,
                                         collisionObject,
                                                 collisionObject->getCollisionShape(),
                                                 collisionObject->getWorldTransform(),
-                                                m_resultCallback);
-                        }
-                }
-                return true;
-        }
-};
-
-void    btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
-{
-        BT_PROFILE("rayTest");
-        /// go over all objects, and if the ray intersects their aabb, do a ray-shape query using convexCaster (CCD)
-        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
+                                                resultCallback);
+                        }
+                }
+
+        }
 
 }

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

@@ -108 +108 @@
         }
 
-        const btBroadphaseInterface*    getBroadphase() const
-        {
-                return m_broadphasePairCache;
-        }
-
         btBroadphaseInterface*  getBroadphase()
         {