Changeset 7983 for code/branches/kicklib/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h

Timestamp:

Feb 27, 2011, 7:43:24 AM (14 years ago)

Author:

rgrieder

Message:

Updated Bullet Physics Engine from v2.74 to v2.77

File:

• code/branches/kicklib/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h (modified) (22 diffs)

code/branches/kicklib/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -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 ).
  *
+ * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution.
  * There is the Physics Forum for feedback and general Collision Detection and Physics discussions.
  * Please visit http://www.bulletphysics.com
@@ -30 +31 @@
  * @subsection step1 Step 1: Download
  * 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.
- * 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/jam
+ * Bullet main build system for all platforms is cmake, you can download http://www.cmake.org
+ * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles.
+ * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles.
+ * You can also use cmake in the command-line. Here are some examples for various platforms:
+ * cmake . -G "Visual Studio 9 2008"
+ * cmake . -G Xcode
+ * cmake . -G "Unix Makefiles"
+ * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make.
  * 
  * @subsection step3 Step 3: Testing demos
@@ -54 +57 @@
  *
  * @section copyright Copyright
- * Copyright (C) 2005-2008 Erwin Coumans, some contributions Copyright Gino van den Bergen, Christer Ericson, Simon Hobbs, Ricardo Padrela, F Richter(res), Stephane Redon
- * Special thanks to all visitors of the Bullet Physics forum, and in particular above contributors, John McCutchan, Nathanael Presson, Dave Eberle, Dirk Gregorius, Erin Catto, Dave Eberle, Adam Moravanszky,
- * Pierre Terdiman, Kenny Erleben, Russell Smith, Oliver Strunk, Jan Paul van Waveren, Marten Svanfeldt.
+ * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf
  * 
  */
-
-
  
  
@@ -71 +70 @@
 class btConvexShape;
 class btBroadphaseInterface;
+class btSerializer;
+
 #include "LinearMath/btVector3.h"
 #include "LinearMath/btTransform.h"
@@ -82 +83 @@
 {
 
-
         
 protected:
 
         btAlignedObjectArray<btCollisionObject*>        m_collisionObjects;
-
         
         btDispatcher*   m_dispatcher1;
@@ -99 +98 @@
         btIDebugDraw*   m_debugDrawer;
 
-
-        
+        ///m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs
+        ///it is true by default, because it is error-prone (setting the position of static objects wouldn't update their AABB)
+        bool m_forceUpdateAllAabbs;
+
+        void    serializeCollisionObjects(btSerializer* serializer);
+
 public:
 
@@ -142 +145 @@
 
         virtual void    updateAabbs();
-
         
         virtual void    setDebugDrawer(btIDebugDraw*    debugDrawer)
@@ -153 +155 @@
                 return m_debugDrawer;
         }
+
+        virtual void    debugDrawWorld();
+
+        virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
 
 
@@ -161 +167 @@
                 int     m_shapePart;
                 int     m_triangleIndex;
-
                 
                 //const btCollisionShape*       m_shapeTemp;
@@ -239 +244 @@
                 btVector3       m_hitNormalWorld;
                 btVector3       m_hitPointWorld;
-
                         
                 virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
@@ -245 +249 @@
                         //caller already does the filter on the m_closestHitFraction
                         btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
-
                         
                         m_closestHitFraction = rayResult.m_hitFraction;
@@ -262 +265 @@
         };
 
+        struct  AllHitsRayResultCallback : public RayResultCallback
+        {
+                AllHitsRayResultCallback(const btVector3&       rayFromWorld,const btVector3&   rayToWorld)
+                :m_rayFromWorld(rayFromWorld),
+                m_rayToWorld(rayToWorld)
+                {
+                }
+
+                btAlignedObjectArray<btCollisionObject*>                m_collisionObjects;
+
+                btVector3       m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
+                btVector3       m_rayToWorld;
+
+                btAlignedObjectArray<btVector3> m_hitNormalWorld;
+                btAlignedObjectArray<btVector3> m_hitPointWorld;
+                btAlignedObjectArray<btScalar> m_hitFractions;
+                        
+                virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
+                {
+                        m_collisionObject = rayResult.m_collisionObject;
+                        m_collisionObjects.push_back(rayResult.m_collisionObject);
+                        btVector3 hitNormalWorld;
+                        if (normalInWorldSpace)
+                        {
+                                hitNormalWorld = rayResult.m_hitNormalLocal;
+                        } else
+                        {
+                                ///need to transform normal into worldspace
+                                hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
+                        }
+                        m_hitNormalWorld.push_back(hitNormalWorld);
+                        btVector3 hitPointWorld;
+                        hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
+                        m_hitPointWorld.push_back(hitPointWorld);
+                        m_hitFractions.push_back(rayResult.m_hitFraction);
+                        return m_closestHitFraction;
+                }
+        };
+
 
         struct LocalConvexResult
@@ -292 +334 @@
                 short int       m_collisionFilterGroup;
                 short int       m_collisionFilterMask;
-
                 
                 ConvexResultCallback()
@@ -304 +345 @@
                 {
                 }
-
                 
                 bool    hasHit() const
@@ -310 +350 @@
                         return (m_closestHitFraction < btScalar(1.));
                 }
-
 
                 
@@ -339 +378 @@
                 btVector3       m_hitPointWorld;
                 btCollisionObject*      m_hitCollisionObject;
-
                 
                 virtual btScalar        addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
@@ -345 +383 @@
 //caller already does the filter on the m_closestHitFraction
                         btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
-
                                                 
                         m_closestHitFraction = convexResult.m_hitFraction;
@@ -362 +399 @@
         };
 
+        ///ContactResultCallback is used to report contact points
+        struct  ContactResultCallback
+        {
+                short int       m_collisionFilterGroup;
+                short int       m_collisionFilterMask;
+                
+                ContactResultCallback()
+                        :m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
+                        m_collisionFilterMask(btBroadphaseProxy::AllFilter)
+                {
+                }
+
+                virtual ~ContactResultCallback()
+                {
+                }
+                
+                virtual bool needsCollision(btBroadphaseProxy* proxy0) const
+                {
+                        bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
+                        collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+                        return collides;
+                }
+
+                virtual btScalar        addSingleResult(btManifoldPoint& cp,    const btCollisionObject* colObj0,int partId0,int index0,const btCollisionObject* colObj1,int partId1,int index1) = 0;
+        };
+
+
+
         int     getNumCollisionObjects() const
         {
@@ -369 +434 @@
         /// rayTest performs a raycast 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 returned by the callback.
-        void    rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const; 
-
-        // 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.
+        virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const; 
+
+        /// 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,  btScalar allowedCcdPenetration = btScalar(0.)) const;
+
+        ///contactTest performs a discrete collision test between colObj against all objects in the btCollisionWorld, and calls the resultCallback.
+        ///it reports one or more contact points for every overlapping object (including the one with deepest penetration)
+        void    contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
+
+        ///contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected.
+        ///it reports one or more contact points (including the one with deepest penetration)
+        void    contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
 
 
@@ -392 +465 @@
                                           ConvexResultCallback& resultCallback, btScalar        allowedPenetration);
 
-        void    addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter);
+        virtual void    addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter);
 
         btCollisionObjectArray& getCollisionObjectArray()
@@ -405 +478 @@
 
 
-        void    removeCollisionObject(btCollisionObject* collisionObject);
+        virtual void    removeCollisionObject(btCollisionObject* collisionObject);
 
         virtual void    performDiscreteCollisionDetection();
@@ -418 +491 @@
                 return m_dispatchInfo;
         }
+        
+        bool    getForceUpdateAllAabbs() const
+        {
+                return m_forceUpdateAllAabbs;
+        }
+        void setForceUpdateAllAabbs( bool forceUpdateAllAabbs)
+        {
+                m_forceUpdateAllAabbs = forceUpdateAllAabbs;
+        }
+
+        ///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bullet/Demos/SerializeDemo)
+        virtual void    serialize(btSerializer* serializer);
 
 };