Changeset 2882 for code/trunk/src/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

Timestamp:

Mar 31, 2009, 8:05:51 PM (15 years ago)

Author:

rgrieder

Message:

Update from Bullet 2.73 to 2.74.

File:

• code/trunk/src/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp (modified) (8 diffs)

code/trunk/src/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -25 +25 @@
 #include "LinearMath/btQuickprof.h"
 
-btSimulationIslandManager::btSimulationIslandManager()
+btSimulationIslandManager::btSimulationIslandManager():
+m_splitIslands(true)
 {
 }
@@ -44 +45 @@
         
         {
-                btBroadphasePair* pairPtr = colWorld->getPairCache()->getOverlappingPairArrayPtr();
-
+                
                 for (int i=0;i<colWorld->getPairCache()->getNumOverlappingPairs();i++)
                 {
+                        btBroadphasePair* pairPtr = colWorld->getPairCache()->getOverlappingPairArrayPtr();
                         const btBroadphasePair& collisionPair = pairPtr[i];
                         btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject;
@@ -186 +187 @@
                         }
 
-                        assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+                        btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
                         if (colObj0->getIslandTag() == islandId)
                         {
@@ -213 +214 @@
                                 }
 
-                                assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+                                btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
 
                                 if (colObj0->getIslandTag() == islandId)
@@ -234 +235 @@
                                 }
 
-                                assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+                                btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
 
                                 if (colObj0->getIslandTag() == islandId)
@@ -252 +253 @@
         int maxNumManifolds = dispatcher->getNumManifolds();
 
-#define SPLIT_ISLANDS 1
-#ifdef SPLIT_ISLANDS
-
-        
-#endif //SPLIT_ISLANDS
+//#define SPLIT_ISLANDS 1
+//#ifdef SPLIT_ISLANDS
+
+        
+//#endif //SPLIT_ISLANDS
 
         
@@ -280 +281 @@
                                 colObj0->activate();
                         }
-#ifdef SPLIT_ISLANDS
-        //              //filtering for response
-                        if (dispatcher->needsResponse(colObj0,colObj1))
-                                m_islandmanifold.push_back(manifold);
-#endif //SPLIT_ISLANDS
+                        if(m_splitIslands)
+                        { 
+                                //filtering for response
+                                if (dispatcher->needsResponse(colObj0,colObj1))
+                                        m_islandmanifold.push_back(manifold);
+                        }
                 }
         }
@@ -304 +306 @@
         BT_PROFILE("processIslands");
 
-#ifndef SPLIT_ISLANDS
-        btPersistentManifold** manifold = dispatcher->getInternalManifoldPointer();
-        
-        callback->ProcessIsland(&collisionObjects[0],collisionObjects.size(),manifold,maxNumManifolds, -1);
-#else
-        // Sort manifolds, based on islands
-        // Sort the vector using predicate and std::sort
-        //std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate);
-
-        int numManifolds = int (m_islandmanifold.size());
-
-        //we should do radix sort, it it much faster (O(n) instead of O (n log2(n))
-        m_islandmanifold.quickSort(btPersistentManifoldSortPredicate());
-
-        //now process all active islands (sets of manifolds for now)
-
-        int startManifoldIndex = 0;
-        int endManifoldIndex = 1;
-
-        //int islandId;
-
-        
-
-//      printf("Start Islands\n");
-
-        //traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated
-        for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
-        {
-                int islandId = getUnionFind().getElement(startIslandIndex).m_id;
-
-
-               bool islandSleeping = false;
-                
-                for (endIslandIndex = startIslandIndex;(endIslandIndex<numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
-                {
-                        int i = getUnionFind().getElement(endIslandIndex).m_sz;
-                        btCollisionObject* colObj0 = collisionObjects[i];
-                                                m_islandBodies.push_back(colObj0);
-                        if (!colObj0->isActive())
-                                islandSleeping = true;
-                }
-                
-
-                //find the accompanying contact manifold for this islandId
-                int numIslandManifolds = 0;
-                btPersistentManifold** startManifold = 0;
-
-                if (startManifoldIndex<numManifolds)
-                {
-                        int curIslandId = getIslandId(m_islandmanifold[startManifoldIndex]);
-                        if (curIslandId == islandId)
-                        {
-                                startManifold = &m_islandmanifold[startManifoldIndex];
+        if(!m_splitIslands)
+        {
+                btPersistentManifold** manifold = dispatcher->getInternalManifoldPointer();
+                int maxNumManifolds = dispatcher->getNumManifolds();
+                callback->ProcessIsland(&collisionObjects[0],collisionObjects.size(),manifold,maxNumManifolds, -1);
+        }
+        else
+        {
+                // Sort manifolds, based on islands
+                // Sort the vector using predicate and std::sort
+                //std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate);
+
+                int numManifolds = int (m_islandmanifold.size());
+
+                //we should do radix sort, it it much faster (O(n) instead of O (n log2(n))
+                m_islandmanifold.quickSort(btPersistentManifoldSortPredicate());
+
+                //now process all active islands (sets of manifolds for now)
+
+                int startManifoldIndex = 0;
+                int endManifoldIndex = 1;
+
+                //int islandId;
+
+                
+
+        //      printf("Start Islands\n");
+
+                //traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated
+                for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
+                {
+                        int islandId = getUnionFind().getElement(startIslandIndex).m_id;
+
+
+                           bool islandSleeping = false;
+                        
+                                        for (endIslandIndex = startIslandIndex;(endIslandIndex<numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
+                                        {
+                                                        int i = getUnionFind().getElement(endIslandIndex).m_sz;
+                                                        btCollisionObject* colObj0 = collisionObjects[i];
+                                                        m_islandBodies.push_back(colObj0);
+                                                        if (!colObj0->isActive())
+                                                                        islandSleeping = true;
+                                        }
+                        
+
+                        //find the accompanying contact manifold for this islandId
+                        int numIslandManifolds = 0;
+                        btPersistentManifold** startManifold = 0;
+
+                        if (startManifoldIndex<numManifolds)
+                        {
+                                int curIslandId = getIslandId(m_islandmanifold[startManifoldIndex]);
+                                if (curIslandId == islandId)
+                                {
+                                        startManifold = &m_islandmanifold[startManifoldIndex];
+                                
+                                        for (endManifoldIndex = startManifoldIndex+1;(endManifoldIndex<numManifolds) && (islandId == getIslandId(m_islandmanifold[endManifoldIndex]));endManifoldIndex++)
+                                        {
+
+                                        }
+                                        /// Process the actual simulation, only if not sleeping/deactivated
+                                        numIslandManifolds = endManifoldIndex-startManifoldIndex;
+                                }
+
+                        }
+
+                        if (!islandSleeping)
+                        {
+                                callback->ProcessIsland(&m_islandBodies[0],m_islandBodies.size(),startManifold,numIslandManifolds, islandId);
+        //                      printf("Island callback of size:%d bodies, %d manifolds\n",islandBodies.size(),numIslandManifolds);
+                        }
                         
-                                for (endManifoldIndex = startManifoldIndex+1;(endManifoldIndex<numManifolds) && (islandId == getIslandId(m_islandmanifold[endManifoldIndex]));endManifoldIndex++)
-                                {
-
-                                }
-                                /// Process the actual simulation, only if not sleeping/deactivated
-                                numIslandManifolds = endManifoldIndex-startManifoldIndex;
-                        }
-
-                }
-
-                if (!islandSleeping)
-                {
-                        callback->ProcessIsland(&m_islandBodies[0],m_islandBodies.size(),startManifold,numIslandManifolds, islandId);
-//                      printf("Island callback of size:%d bodies, %d manifolds\n",islandBodies.size(),numIslandManifolds);
-                }
-                
-                if (numIslandManifolds)
-                {
-                        startManifoldIndex = endManifoldIndex;
-                }
-
-                m_islandBodies.resize(0);
-        }
-#endif //SPLIT_ISLANDS
-
-
-}
+                        if (numIslandManifolds)
+                        {
+                                startManifoldIndex = endManifoldIndex;
+                        }
+
+                        m_islandBodies.resize(0);
+                }
+        } // else if(!splitIslands) 
+
+}