Changeset 8393 for code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

Timestamp:

May 3, 2011, 5:07:42 AM (13 years ago)

Author:

rgrieder

Message:

Updated Bullet from v2.77 to v2.78.
(I'm not going to make a branch for that since the update from 2.74 to 2.77 hasn't been tested that much either).

You will HAVE to do a complete RECOMPILE! I tested with MSVC and MinGW and they both threw linker errors at me.

File:

• code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp (modified) (6 diffs)

code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -27 +27 @@
 #include "BulletCollision/CollisionShapes/btConvexShape.h"
 #include "BulletCollision/CollisionShapes/btCapsuleShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleShape.h"
+
 
 
@@ -49 +51 @@
 #include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
 #include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
-
+#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h"
 
 
@@ -332 +334 @@
 
 
+
+
 #ifdef USE_SEPDISTANCE_UTIL2
         if (dispatchInfo.m_useConvexConservativeDistanceUtil)
@@ -358 +362 @@
 #endif //USE_SEPDISTANCE_UTIL2
         {
-                if (dispatchInfo.m_convexMaxDistanceUseCPT)
-                {
-                        input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactProcessingThreshold();
-                } else
-                {
-                        input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold();
-                }
+                //if (dispatchInfo.m_convexMaxDistanceUseCPT)
+                //{
+                //      input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactProcessingThreshold();
+                //} else
+                //{
+                input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold();
+//              }
+
                 input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
         }
@@ -372 +377 @@
         input.m_transformB = body1->getWorldTransform();
 
-        gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
+
 
         
@@ -389 +394 @@
         }
 #endif //USE_SEPDISTANCE_UTIL2
+
+        if (min0->isPolyhedral() && min1->isPolyhedral())
+        {
+
+
+                struct btDummyResult : public btDiscreteCollisionDetectorInterface::Result
+                {
+                        virtual void setShapeIdentifiersA(int partId0,int index0){}
+                        virtual void setShapeIdentifiersB(int partId1,int index1){}
+                        virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth) 
+                        {
+                        }
+                };
+                
+                btDummyResult dummy;
+
+
+                btPolyhedralConvexShape* polyhedronA = (btPolyhedralConvexShape*) min0;
+                btPolyhedralConvexShape* polyhedronB = (btPolyhedralConvexShape*) min1;
+                if (polyhedronA->getConvexPolyhedron() && polyhedronB->getConvexPolyhedron())
+                {
+
+
+                        gjkPairDetector.getClosestPoints(input,dummy,dispatchInfo.m_debugDraw);
+                        
+
+                        btScalar threshold = m_manifoldPtr->getContactBreakingThreshold();
+
+                        btScalar minDist = 0.f;
+                        btVector3 sepNormalWorldSpace;
+                        bool foundSepAxis  = true;
+
+                        if (dispatchInfo.m_enableSatConvex)
+                        {
+                                foundSepAxis = btPolyhedralContactClipping::findSeparatingAxis(
+                                        *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
+                                        body0->getWorldTransform(), 
+                                        body1->getWorldTransform(),
+                                        sepNormalWorldSpace);
+                        } else
+                        {
+                                sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized();
+                                minDist = gjkPairDetector.getCachedSeparatingDistance();
+                        }
+                        if (foundSepAxis)
+                        {
+//                              printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.getX(),sepNormalWorldSpace.getY(),sepNormalWorldSpace.getZ());
+
+                                btPolyhedralContactClipping::clipHullAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
+                                        body0->getWorldTransform(), 
+                                        body1->getWorldTransform(), minDist-threshold, threshold, *resultOut);
+                                
+                        }
+                        if (m_ownManifold)
+                        {
+                                resultOut->refreshContactPoints();
+                        }
+                        return;
+
+                } else
+                {
+                        //we can also deal with convex versus triangle (without connectivity data)
+                        if (polyhedronA->getConvexPolyhedron() && polyhedronB->getShapeType()==TRIANGLE_SHAPE_PROXYTYPE)
+                        {
+                                gjkPairDetector.getClosestPoints(input,dummy,dispatchInfo.m_debugDraw);
+                
+                                btVector3 sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized();
+
+                                btVertexArray vertices;
+                                btTriangleShape* tri = (btTriangleShape*)polyhedronB;
+                                vertices.push_back(     body1->getWorldTransform()*tri->m_vertices1[0]);
+                                vertices.push_back(     body1->getWorldTransform()*tri->m_vertices1[1]);
+                                vertices.push_back(     body1->getWorldTransform()*tri->m_vertices1[2]);
+
+                                btScalar threshold = m_manifoldPtr->getContactBreakingThreshold();
+                                btScalar minDist = gjkPairDetector.getCachedSeparatingDistance();
+                                btPolyhedralContactClipping::clipFaceAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(), 
+                                        body0->getWorldTransform(), vertices, minDist-threshold, threshold, *resultOut);
+                                
+                                
+                                if (m_ownManifold)
+                                {
+                                        resultOut->refreshContactPoints();
+                                }
+                                
+                                return;
+                        }
+                        
+                }
+
+
+        }
+        
+        gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
 
         //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects