Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Apr 8, 2009, 12:58:47 AM (16 years ago)
Author:
dafrick
Message:

Reverted to revision 2906 (because I'm too stupid to merge correctly, 2nd try will follow shortly. ;))

Location:
code/branches/questsystem5
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • code/branches/questsystem5

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

    r2907 r2908  
    5353                {
    5454                        m_doubleDispatch[i][j] = m_collisionConfiguration->getCollisionAlgorithmCreateFunc(i,j);
    55                         btAssert(m_doubleDispatch[i][j]);
     55                        assert(m_doubleDispatch[i][j]);
    5656                }
    5757        }
    … …  
    8080        btCollisionObject* body1 = (btCollisionObject*)b1;
    8181
    82         //test for Bullet 2.74: use a relative contact breaking threshold without clamping against 'gContactBreakingThreshold'
    83         //btScalar contactBreakingThreshold = btMin(gContactBreakingThreshold,btMin(body0->getCollisionShape()->getContactBreakingThreshold(),body1->getCollisionShape()->getContactBreakingThreshold()));
    84         btScalar contactBreakingThreshold = btMin(body0->getCollisionShape()->getContactBreakingThreshold(),body1->getCollisionShape()->getContactBreakingThreshold());
    85 
    86         btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(),body1->getContactProcessingThreshold());
    87                
     82        btScalar contactBreakingThreshold = btMin(gContactBreakingThreshold,btMin(body0->getCollisionShape()->getContactBreakingThreshold(),body1->getCollisionShape()->getContactBreakingThreshold()));
     83       
    8884        void* mem = 0;
    8985       
    … …  
    9692
    9793        }
    98         btPersistentManifold* manifold = new(mem) btPersistentManifold (body0,body1,0,contactBreakingThreshold,contactProcessingThreshold);
     94        btPersistentManifold* manifold = new(mem) btPersistentManifold (body0,body1,0,contactBreakingThreshold);
    9995        manifold->m_index1a = m_manifoldsPtr.size();
    10096        m_manifoldsPtr.push_back(manifold);
    … …  
    147143        return algo;
    148144}
     145
    149146
    150147
    … …  
    164161bool    btCollisionDispatcher::needsCollision(btCollisionObject* body0,btCollisionObject* body1)
    165162{
    166         btAssert(body0);
    167         btAssert(body1);
     163        assert(body0);
     164        assert(body1);
    168165
    169166        bool needsCollision = true;

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btCollisionObject.cpp

    r2907 r2908  
    1818
    1919btCollisionObject::btCollisionObject()
    20         :       m_anisotropicFriction(1.f,1.f,1.f),
    21         m_hasAnisotropicFriction(false),
    22         m_contactProcessingThreshold(1e30f),
    23                 m_broadphaseHandle(0),
     20        :       m_broadphaseHandle(0),
    2421                m_collisionShape(0),
    2522                m_rootCollisionShape(0),

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btCollisionObject.h

    r2907 r2908  
    5353        btVector3       m_interpolationLinearVelocity;
    5454        btVector3       m_interpolationAngularVelocity;
    55        
    56         btVector3               m_anisotropicFriction;
    57         bool                            m_hasAnisotropicFriction;
    58         btScalar                m_contactProcessingThreshold;   
    59 
    6055        btBroadphaseProxy*              m_broadphaseHandle;
    6156        btCollisionShape*               m_collisionShape;
    … …  
    120115                CO_COLLISION_OBJECT =1,
    121116                CO_RIGID_BODY,
     117                CO_SOFT_BODY,
    122118                ///CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter
    123119                ///It is useful for collision sensors, explosion objects, character controller etc.
    124                 CO_GHOST_OBJECT,
    125                 CO_SOFT_BODY,
    126                 CO_HF_FLUID
     120                CO_GHOST_OBJECT
    127121        };
    128122
    … …  
    133127        }
    134128
    135         const btVector3& getAnisotropicFriction() const
    136         {
    137                 return m_anisotropicFriction;
    138         }
    139         void    setAnisotropicFriction(const btVector3& anisotropicFriction)
    140         {
    141                 m_anisotropicFriction = anisotropicFriction;
    142                 m_hasAnisotropicFriction = (anisotropicFriction[0]!=1.f) || (anisotropicFriction[1]!=1.f) || (anisotropicFriction[2]!=1.f);
    143         }
    144         bool    hasAnisotropicFriction() const
    145         {
    146                 return m_hasAnisotropicFriction;
    147         }
    148 
    149         ///the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default.
    150         ///Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges
    151         void    setContactProcessingThreshold( btScalar contactProcessingThreshold)
    152         {
    153                 m_contactProcessingThreshold = contactProcessingThreshold;
    154         }
    155         btScalar        getContactProcessingThreshold() const
    156         {
    157                 return m_contactProcessingThreshold;
    158         }
    159129
    160130        SIMD_FORCE_INLINE bool          isStaticObject() const {

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

    r2907 r2908  
    7070                        getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp,m_dispatcher1);
    7171                        getBroadphase()->destroyProxy(bp,m_dispatcher1);
    72                         collisionObject->setBroadphaseHandle(0);
    7372                }
    7473        }
    … …  
    120119
    121120
    122 void    btCollisionWorld::updateSingleAabb(btCollisionObject* colObj)
    123 {
    124         btVector3 minAabb,maxAabb;
    125         colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
    126         //need to increase the aabb for contact thresholds
    127         btVector3 contactThreshold(gContactBreakingThreshold,gContactBreakingThreshold,gContactBreakingThreshold);
    128         minAabb -= contactThreshold;
    129         maxAabb += contactThreshold;
    130 
    131         btBroadphaseInterface* bp = (btBroadphaseInterface*)m_broadphasePairCache;
    132 
    133         //moving objects should be moderately sized, probably something wrong if not
    134         if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < btScalar(1e12)))
    135         {
    136                 bp->setAabb(colObj->getBroadphaseHandle(),minAabb,maxAabb, m_dispatcher1);
    137         } else
    138         {
    139                 //something went wrong, investigate
    140                 //this assert is unwanted in 3D modelers (danger of loosing work)
    141                 colObj->setActivationState(DISABLE_SIMULATION);
    142 
    143                 static bool reportMe = true;
    144                 if (reportMe && m_debugDrawer)
    145                 {
    146                         reportMe = false;
    147                         m_debugDrawer->reportErrorWarning("Overflow in AABB, object removed from simulation");
    148                         m_debugDrawer->reportErrorWarning("If you can reproduce this, please email bugs@continuousphysics.com\n");
    149                         m_debugDrawer->reportErrorWarning("Please include above information, your Platform, version of OS.\n");
    150                         m_debugDrawer->reportErrorWarning("Thanks.\n");
    151                 }
    152         }
    153 }
    154 
    155121void    btCollisionWorld::updateAabbs()
    156122{
    … …  
    165131                if (colObj->isActive())
    166132                {
    167                         updateSingleAabb(colObj);
    168                 }
    169         }
     133                        btVector3 minAabb,maxAabb;
     134                        colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
     135                        //need to increase the aabb for contact thresholds
     136                        btVector3 contactThreshold(gContactBreakingThreshold,gContactBreakingThreshold,gContactBreakingThreshold);
     137                        minAabb -= contactThreshold;
     138                        maxAabb += contactThreshold;
     139
     140                        btBroadphaseInterface* bp = (btBroadphaseInterface*)m_broadphasePairCache;
     141
     142                        //moving objects should be moderately sized, probably something wrong if not
     143                        if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < btScalar(1e12)))
     144                        {
     145                                bp->setAabb(colObj->getBroadphaseHandle(),minAabb,maxAabb, m_dispatcher1);
     146                        } else
     147                        {
     148                                //something went wrong, investigate
     149                                //this assert is unwanted in 3D modelers (danger of loosing work)
     150                                colObj->setActivationState(DISABLE_SIMULATION);
     151
     152                                static bool reportMe = true;
     153                                if (reportMe && m_debugDrawer)
     154                                {
     155                                        reportMe = false;
     156                                        m_debugDrawer->reportErrorWarning("Overflow in AABB, object removed from simulation");
     157                                        m_debugDrawer->reportErrorWarning("If you can reproduce this, please email bugs@continuousphysics.com\n");
     158                                        m_debugDrawer->reportErrorWarning("Please include above information, your Platform, version of OS.\n");
     159                                        m_debugDrawer->reportErrorWarning("Thanks.\n");
     160                                }
     161                        }
     162                }
     163        }
     164
    170165}
    171166
    … …  
    299294                                        BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
    300295                                                btCollisionWorld::RayResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape*    triangleMesh):
    301                   //@BP Mod
    302                                                 btTriangleRaycastCallback(from,to, resultCallback->m_flags),
     296                                                btTriangleRaycastCallback(from,to),
    303297                                                        m_resultCallback(resultCallback),
    304298                                                        m_collisionObject(collisionObject),
    … …  
    349343                                        BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
    350344                                                btCollisionWorld::RayResultCallback* resultCallback, btCollisionObject* collisionObject,btConcaveShape* triangleMesh):
    351                   //@BP Mod
    352                   btTriangleRaycastCallback(from,to, resultCallback->m_flags),
     345                                                btTriangleRaycastCallback(from,to),
    353346                                                        m_resultCallback(resultCallback),
    354347                                                        m_collisionObject(collisionObject),
    … …  
    671664                        //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
    672665                        //btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
    673 #if 0
     666                       
    674667#ifdef RECALCULATE_AABB
    675668                        btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
    … …  
    679672                        const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
    680673                        const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
    681 #endif
    682674#endif
    683675                        //btScalar hitLambda = m_resultCallback.m_closestHitFraction;

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h

    r2907 r2908  
    5959 *
    6060 */
    61 
    62 
    6361 
    6462 
    … …  
    8280{
    8381
    84 
    8582       
    8683protected:
    8784
    8885        btAlignedObjectArray<btCollisionObject*>        m_collisionObjects;
    89 
    9086       
    9187        btDispatcher*   m_dispatcher1;
    … …  
    9995        btIDebugDraw*   m_debugDrawer;
    10096
    101 
    10297       
    10398public:
    … …  
    138133                return m_dispatcher1;
    139134        }
    140 
    141         void    updateSingleAabb(btCollisionObject* colObj);
    142135
    143136        virtual void    updateAabbs();
    … …  
    161154                int     m_shapePart;
    162155                int     m_triangleIndex;
    163 
    164156               
    165157                //const btCollisionShape*       m_shapeTemp;
    … …  
    194186                short int       m_collisionFilterGroup;
    195187                short int       m_collisionFilterMask;
    196       //@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback
    197       unsigned int m_flags;
    198188
    199189                virtual ~RayResultCallback()
    … …  
    209199                        m_collisionObject(0),
    210200                        m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
    211                         m_collisionFilterMask(btBroadphaseProxy::AllFilter),
    212          //@BP Mod
    213          m_flags(0)
     201                        m_collisionFilterMask(btBroadphaseProxy::AllFilter)
    214202                {
    215203                }
    … …  
    239227                btVector3       m_hitNormalWorld;
    240228                btVector3       m_hitPointWorld;
    241 
    242229                       
    243230                virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
    … …  
    245232                        //caller already does the filter on the m_closestHitFraction
    246233                        btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
    247 
    248234                       
    249235                        m_closestHitFraction = rayResult.m_hitFraction;
    … …  
    292278                short int       m_collisionFilterGroup;
    293279                short int       m_collisionFilterMask;
    294 
    295280               
    296281                ConvexResultCallback()
    … …  
    304289                {
    305290                }
    306 
    307291               
    308292                bool    hasHit() const
    … …  
    310294                        return (m_closestHitFraction < btScalar(1.));
    311295                }
    312 
    313296
    314297               
    … …  
    339322                btVector3       m_hitPointWorld;
    340323                btCollisionObject*      m_hitCollisionObject;
    341 
    342324               
    343325                virtual btScalar        addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
    … …  
    345327//caller already does the filter on the m_closestHitFraction
    346328                        btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
    347 
    348329                                               
    349330                        m_closestHitFraction = convexResult.m_hitFraction;

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

    r2907 r2908  
    2020#include "LinearMath/btIDebugDraw.h"
    2121#include "LinearMath/btAabbUtil2.h"
    22 #include "btManifoldResult.h"
    2322
    2423btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped)
    … …  
    3029
    3130        btCollisionObject* colObj = m_isSwapped? body1 : body0;
    32         btAssert (colObj->getCollisionShape()->isCompound());
     31        btCollisionObject* otherObj = m_isSwapped? body0 : body1;
     32        assert (colObj->getCollisionShape()->isCompound());
    3333       
    3434        btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
    35         m_compoundShapeRevision = compoundShape->getUpdateRevision();
    36        
    37         preallocateChildAlgorithms(body0,body1);
    38 }
    39 
    40 void    btCompoundCollisionAlgorithm::preallocateChildAlgorithms(btCollisionObject* body0,btCollisionObject* body1)
    41 {
    42         btCollisionObject* colObj = m_isSwapped? body1 : body0;
    43         btCollisionObject* otherObj = m_isSwapped? body0 : body1;
    44         btAssert (colObj->getCollisionShape()->isCompound());
    45        
    46         btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
    47 
    4835        int numChildren = compoundShape->getNumChildShapes();
    4936        int i;
    … …  
    6047                        btCollisionShape* childShape = compoundShape->getChildShape(i);
    6148                        colObj->internalSetTemporaryCollisionShape( childShape );
    62                         m_childCollisionAlgorithms[i] = m_dispatcher->findAlgorithm(colObj,otherObj,m_sharedManifold);
     49                        m_childCollisionAlgorithms[i] = ci.m_dispatcher1->findAlgorithm(colObj,otherObj,m_sharedManifold);
    6350                        colObj->internalSetTemporaryCollisionShape( tmpShape );
    6451                }
    … …  
    6653}
    6754
    68 void    btCompoundCollisionAlgorithm::removeChildAlgorithms()
     55
     56btCompoundCollisionAlgorithm::~btCompoundCollisionAlgorithm()
    6957{
    7058        int numChildren = m_childCollisionAlgorithms.size();
    … …  
    7866                }
    7967        }
    80 }
    81 
    82 btCompoundCollisionAlgorithm::~btCompoundCollisionAlgorithm()
    83 {
    84         removeChildAlgorithms();
    8568}
    8669
    … …  
    185168        btCollisionObject* otherObj = m_isSwapped? body0 : body1;
    186169
    187        
    188 
    189         btAssert (colObj->getCollisionShape()->isCompound());
     170        assert (colObj->getCollisionShape()->isCompound());
    190171        btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
    191 
    192         ///btCompoundShape might have changed:
    193         ////make sure the internal child collision algorithm caches are still valid
    194         if (compoundShape->getUpdateRevision() != m_compoundShapeRevision)
    195         {
    196                 ///clear and update all
    197                 removeChildAlgorithms();
    198                
    199                 preallocateChildAlgorithms(body0,body1);
    200         }
    201 
    202172
    203173        btDbvt* tree = compoundShape->getDynamicAabbTree();
    … …  
    205175        btCompoundLeafCallback  callback(colObj,otherObj,m_dispatcher,dispatchInfo,resultOut,&m_childCollisionAlgorithms[0],m_sharedManifold);
    206176
    207         ///we need to refresh all contact manifolds
    208         ///note that we should actually recursively traverse all children, btCompoundShape can nested more then 1 level deep
    209         ///so we should add a 'refreshManifolds' in the btCollisionAlgorithm
    210         {
    211                 int i;
    212                 btManifoldArray manifoldArray;
    213                 for (i=0;i<m_childCollisionAlgorithms.size();i++)
    214                 {
    215                         if (m_childCollisionAlgorithms[i])
    216                         {
    217                                 m_childCollisionAlgorithms[i]->getAllContactManifolds(manifoldArray);
    218                                 for (int m=0;m<manifoldArray.size();m++)
    219                                 {
    220                                         if (manifoldArray[m]->getNumContacts())
    221                                         {
    222                                                 resultOut->setPersistentManifold(manifoldArray[m]);
    223                                                 resultOut->refreshContactPoints();
    224                                                 resultOut->setPersistentManifold(0);//??necessary?
    225                                         }
    226                                 }
    227                                 manifoldArray.clear();
    228                         }
    229                 }
    230         }
    231177
    232178        if (tree)
    … …  
    297243        btCollisionObject* otherObj = m_isSwapped? body0 : body1;
    298244
    299         btAssert (colObj->getCollisionShape()->isCompound());
     245        assert (colObj->getCollisionShape()->isCompound());
    300246       
    301247        btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
    … …  
    340286
    341287
    342 

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

    r2907 r2908  
    2727#include "LinearMath/btAlignedObjectArray.h"
    2828class btDispatcher;
    29 class btCollisionObject;
    3029
    3130/// btCompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
    … …  
    3736        class btPersistentManifold*     m_sharedManifold;
    3837        bool                                    m_ownsManifold;
    39 
    40         int     m_compoundShapeRevision;//to keep track of changes, so that childAlgorithm array can be updated
    4138       
    42         void    removeChildAlgorithms();
    43        
    44         void    preallocateChildAlgorithms(btCollisionObject* body0,btCollisionObject* body1);
    45 
    4639public:
    4740

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

    r2907 r2908  
    5252btConvexConvexAlgorithm::CreateFunc::CreateFunc(btSimplexSolverInterface*                       simplexSolver, btConvexPenetrationDepthSolver* pdSolver)
    5353{
    54         m_numPerturbationIterations = 0;
    55         m_minimumPointsPerturbationThreshold = 3;
    5654        m_simplexSolver = simplexSolver;
    5755        m_pdSolver = pdSolver;
    … …  
    6260}
    6361
    64 btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver,int numPerturbationIterations, int minimumPointsPerturbationThreshold)
     62btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver)
    6563: btActivatingCollisionAlgorithm(ci,body0,body1),
    6664m_simplexSolver(simplexSolver),
    … …  
    6866m_ownManifold (false),
    6967m_manifoldPtr(mf),
    70 m_lowLevelOfDetail(false),
     68m_lowLevelOfDetail(false)
    7169#ifdef USE_SEPDISTANCE_UTIL2
    7270,m_sepDistance((static_cast<btConvexShape*>(body0->getCollisionShape()))->getAngularMotionDisc(),
    73                           (static_cast<btConvexShape*>(body1->getCollisionShape()))->getAngularMotionDisc()),
     71                          (static_cast<btConvexShape*>(body1->getCollisionShape()))->getAngularMotionDisc())
    7472#endif
    75 m_numPerturbationIterations(numPerturbationIterations),
    76 m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold)
    7773{
    7874        (void)body0;
    … …  
    9894
    9995
    100 struct btPerturbedContactResult : public btManifoldResult
    101 {
    102         btManifoldResult* m_originalManifoldResult;
    103         btTransform m_transformA;
    104         btTransform m_transformB;
    105         btTransform     m_unPerturbedTransform;
    106         bool    m_perturbA;
    107         btIDebugDraw*   m_debugDrawer;
    108 
    109 
    110         btPerturbedContactResult(btManifoldResult* originalResult,const btTransform& transformA,const btTransform& transformB,const btTransform& unPerturbedTransform,bool perturbA,btIDebugDraw* debugDrawer)
    111                 :m_originalManifoldResult(originalResult),
    112                 m_transformA(transformA),
    113                 m_transformB(transformB),
    114                 m_perturbA(perturbA),
    115                 m_unPerturbedTransform(unPerturbedTransform),
    116                 m_debugDrawer(debugDrawer)
    117         {
    118         }
    119         virtual ~ btPerturbedContactResult()
    120         {
    121         }
    122 
    123         virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar orgDepth)
    124         {
    125                 btVector3 endPt,startPt;
    126                 btScalar newDepth;
    127                 btVector3 newNormal;
    128 
    129                 if (m_perturbA)
    130                 {
    131                         btVector3 endPtOrg = pointInWorld + normalOnBInWorld*orgDepth;
    132                         endPt = (m_unPerturbedTransform*m_transformA.inverse())(endPtOrg);
    133                         newDepth = (endPt -  pointInWorld).dot(normalOnBInWorld);
    134                         startPt = endPt+normalOnBInWorld*newDepth;
    135                 } else
    136                 {
    137                         endPt = pointInWorld + normalOnBInWorld*orgDepth;
    138                         startPt = (m_unPerturbedTransform*m_transformB.inverse())(pointInWorld);
    139                         newDepth = (endPt -  startPt).dot(normalOnBInWorld);
    140                        
    141                 }
    142 
    143 //#define DEBUG_CONTACTS 1
    144 #ifdef DEBUG_CONTACTS
    145                 m_debugDrawer->drawLine(startPt,endPt,btVector3(1,0,0));
    146                 m_debugDrawer->drawSphere(startPt,0.05,btVector3(0,1,0));
    147                 m_debugDrawer->drawSphere(endPt,0.05,btVector3(0,0,1));
    148 #endif //DEBUG_CONTACTS
    149 
    150                
    151                 m_originalManifoldResult->addContactPoint(normalOnBInWorld,startPt,newDepth);
    152         }
    153 
    154 };
    155 
    156 extern btScalar gContactBreakingThreshold;
     96
     97
    15798
    15899//
    … …  
    170111        resultOut->setPersistentManifold(m_manifoldPtr);
    171112
    172         //comment-out next line to test multi-contact generation
    173         //resultOut->getPersistentManifold()->clearManifold();
    174113       
    175114
    … …  
    208147
    209148        gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
     149
    210150        btScalar sepDist = gjkPairDetector.getCachedSeparatingDistance()+dispatchInfo.m_convexConservativeDistanceThreshold;
    211 
    212         //now perturbe directions to get multiple contact points
    213         btVector3 v0,v1;
    214         btVector3 sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized();
    215         btPlaneSpace1(sepNormalWorldSpace,v0,v1);
    216         //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects
    217        
    218         //perform perturbation when more then 'm_minimumPointsPerturbationThreshold' points
    219         if (resultOut->getPersistentManifold()->getNumContacts() < m_minimumPointsPerturbationThreshold)
    220         {
    221                
    222                 int i;
    223 
    224                 bool perturbeA = true;
    225                 const btScalar angleLimit = 0.125f * SIMD_PI;
    226                 btScalar perturbeAngle;
    227                 btScalar radiusA = min0->getAngularMotionDisc();
    228                 btScalar radiusB = min1->getAngularMotionDisc();
    229                 if (radiusA < radiusB)
    230                 {
    231                         perturbeAngle = gContactBreakingThreshold /radiusA;
    232                         perturbeA = true;
    233                 } else
    234                 {
    235                         perturbeAngle = gContactBreakingThreshold / radiusB;
    236                         perturbeA = false;
    237                 }
    238                 if ( perturbeAngle > angleLimit )
    239                                 perturbeAngle = angleLimit;
    240 
    241                 btTransform unPerturbedTransform;
    242                 if (perturbeA)
    243                 {
    244                         unPerturbedTransform = input.m_transformA;
    245                 } else
    246                 {
    247                         unPerturbedTransform = input.m_transformB;
    248                 }
    249                
    250                 for ( i=0;i<m_numPerturbationIterations;i++)
    251                 {
    252                         btQuaternion perturbeRot(v0,perturbeAngle);
    253                         btScalar iterationAngle = i*(SIMD_2_PI/btScalar(m_numPerturbationIterations));
    254                         btQuaternion rotq(sepNormalWorldSpace,iterationAngle);
    255                        
    256                        
    257                         if (perturbeA)
    258                         {
    259                                 input.m_transformA.setBasis(  btMatrix3x3(rotq.inverse()*perturbeRot*rotq)*body0->getWorldTransform().getBasis());
    260                                 input.m_transformB = body1->getWorldTransform();
    261 #ifdef DEBUG_CONTACTS
    262                                 dispatchInfo.m_debugDraw->drawTransform(input.m_transformA,10.0);
    263 #endif //DEBUG_CONTACTS
    264                         } else
    265                         {
    266                                 input.m_transformA = body0->getWorldTransform();
    267                                 input.m_transformB.setBasis( btMatrix3x3(rotq.inverse()*perturbeRot*rotq)*body1->getWorldTransform().getBasis());
    268 #ifdef DEBUG_CONTACTS
    269                                 dispatchInfo.m_debugDraw->drawTransform(input.m_transformB,10.0);
    270 #endif
    271                         }
    272                        
    273                         btPerturbedContactResult perturbedResultOut(resultOut,input.m_transformA,input.m_transformB,unPerturbedTransform,perturbeA,dispatchInfo.m_debugDraw);
    274                         gjkPairDetector.getClosestPoints(input,perturbedResultOut,dispatchInfo.m_debugDraw);
    275                        
    276                        
    277                 }
    278         }
    279 
    280        
    281151
    282152#ifdef USE_SEPDISTANCE_UTIL2

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h

    r2907 r2908  
    3434///#define USE_SEPDISTANCE_UTIL2 1
    3535
    36 ///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects.
    37 ///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal.
    38 ///This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888
     36///ConvexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations.
    3937class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
    4038{
    … …  
    5048        bool                    m_lowLevelOfDetail;
    5149       
    52         int m_numPerturbationIterations;
    53         int m_minimumPointsPerturbationThreshold;
    54 
    55 
    5650        ///cache separating vector to speedup collision detection
    5751       
    … …  
    5953public:
    6054
    61         btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold);
    62 
     55        btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver);
    6356
    6457        virtual ~btConvexConvexAlgorithm();
    … …  
    8679        struct CreateFunc :public       btCollisionAlgorithmCreateFunc
    8780        {
    88 
    8981                btConvexPenetrationDepthSolver*         m_pdSolver;
    9082                btSimplexSolverInterface*                       m_simplexSolver;
    91                 int m_numPerturbationIterations;
    92                 int m_minimumPointsPerturbationThreshold;
    93 
     83               
    9484                CreateFunc(btSimplexSolverInterface*                    simplexSolver, btConvexPenetrationDepthSolver* pdSolver);
    9585               
    … …  
    9989                {
    10090                        void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConvexAlgorithm));
    101                         return new(mem) btConvexConvexAlgorithm(ci.m_manifold,ci,body0,body1,m_simplexSolver,m_pdSolver,m_numPerturbationIterations,m_minimumPointsPerturbationThreshold);
     91                        return new(mem) btConvexConvexAlgorithm(ci.m_manifold,ci,body0,body1,m_simplexSolver,m_pdSolver);
    10292                }
    10393        };

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp

    r2907 r2908  
    55This software is provided 'as-is', without any express or implied warranty.
    66In no event will the authors be held liable for any damages arising from the use of this software.
    7 Permission is granted to anyone to use this software for any purpose,
    8 including commercial applications, and to alter it and redistribute it freely,
     7Permission is granted to anyone to use this software for any purpose, 
     8including commercial applications, and to alter it and redistribute it freely, 
    99subject to the following restrictions:
    1010
    … …  
    2323//#include <stdio.h>
    2424
    25 btConvexPlaneCollisionAlgorithm::btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped, int numPerturbationIterations,int minimumPointsPerturbationThreshold)
     25btConvexPlaneCollisionAlgorithm::btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped)
    2626: btCollisionAlgorithm(ci),
    2727m_ownManifold(false),
    2828m_manifoldPtr(mf),
    29 m_isSwapped(isSwapped),
    30 m_numPerturbationIterations(numPerturbationIterations),
    31 m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold)
     29m_isSwapped(isSwapped)
    3230{
    3331        btCollisionObject* convexObj = m_isSwapped? col1 : col0;
    3432        btCollisionObject* planeObj = m_isSwapped? col0 : col1;
    35 
     33       
    3634        if (!m_manifoldPtr && m_dispatcher->needsCollision(convexObj,planeObj))
    3735        {
    … …  
    5149}
    5250
    53 void btConvexPlaneCollisionAlgorithm::collideSingleContact (const btQuaternion& perturbeRot, btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
     51
     52
     53void btConvexPlaneCollisionAlgorithm::processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
    5454{
    55     btCollisionObject* convexObj = m_isSwapped? body1 : body0;
     55        (void)dispatchInfo;
     56        (void)resultOut;
     57        if (!m_manifoldPtr)
     58                return;
     59
     60        btCollisionObject* convexObj = m_isSwapped? body1 : body0;
    5661        btCollisionObject* planeObj = m_isSwapped? body0: body1;
    5762
    … …  
    5964        btStaticPlaneShape* planeShape = (btStaticPlaneShape*) planeObj->getCollisionShape();
    6065
    61     bool hasCollision = false;
     66        bool hasCollision = false;
    6267        const btVector3& planeNormal = planeShape->getPlaneNormal();
    6368        const btScalar& planeConstant = planeShape->getPlaneConstant();
    64        
    65         btTransform convexWorldTransform = convexObj->getWorldTransform();
     69        btTransform planeInConvex;
     70        planeInConvex= convexObj->getWorldTransform().inverse() * planeObj->getWorldTransform();
    6671        btTransform convexInPlaneTrans;
    67         convexInPlaneTrans= planeObj->getWorldTransform().inverse() * convexWorldTransform;
    68         //now perturbe the convex-world transform
    69         convexWorldTransform.getBasis()*=btMatrix3x3(perturbeRot);
    70         btTransform planeInConvex;
    71         planeInConvex= convexWorldTransform.inverse() * planeObj->getWorldTransform();
    72        
     72        convexInPlaneTrans= planeObj->getWorldTransform().inverse() * convexObj->getWorldTransform();
     73
    7374        btVector3 vtx = convexShape->localGetSupportingVertex(planeInConvex.getBasis()*-planeNormal);
    74 
    7575        btVector3 vtxInPlane = convexInPlaneTrans(vtx);
    7676        btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant);
    … …  
    8888                resultOut->addContactPoint(normalOnSurfaceB,pOnB,distance);
    8989        }
    90 }
    91 
    92 
    93 void btConvexPlaneCollisionAlgorithm::processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
    94 {
    95         (void)dispatchInfo;
    96         if (!m_manifoldPtr)
    97                 return;
    98 
    99     btCollisionObject* convexObj = m_isSwapped? body1 : body0;
    100         btCollisionObject* planeObj = m_isSwapped? body0: body1;
    101 
    102         btConvexShape* convexShape = (btConvexShape*) convexObj->getCollisionShape();
    103         btStaticPlaneShape* planeShape = (btStaticPlaneShape*) planeObj->getCollisionShape();
    104 
    105     bool hasCollision = false;
    106         const btVector3& planeNormal = planeShape->getPlaneNormal();
    107         const btScalar& planeConstant = planeShape->getPlaneConstant();
    108 
    109         //first perform a collision query with the non-perturbated collision objects
    110         {
    111                 btQuaternion rotq(0,0,0,1);
    112                 collideSingleContact(rotq,body0,body1,dispatchInfo,resultOut);
    113         }
    114 
    115         if (resultOut->getPersistentManifold()->getNumContacts()<m_minimumPointsPerturbationThreshold)
    116         {
    117                 btVector3 v0,v1;
    118                 btPlaneSpace1(planeNormal,v0,v1);
    119                 //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects
    120 
    121                 const btScalar angleLimit = 0.125f * SIMD_PI;
    122                 btScalar perturbeAngle;
    123                 btScalar radius = convexShape->getAngularMotionDisc();
    124                 perturbeAngle = gContactBreakingThreshold / radius;
    125                 if ( perturbeAngle > angleLimit )
    126                                 perturbeAngle = angleLimit;
    127 
    128                 btQuaternion perturbeRot(v0,perturbeAngle);
    129                 for (int i=0;i<m_numPerturbationIterations;i++)
    130                 {
    131                         btScalar iterationAngle = i*(SIMD_2_PI/btScalar(m_numPerturbationIterations));
    132                         btQuaternion rotq(planeNormal,iterationAngle);
    133                         collideSingleContact(rotq.inverse()*perturbeRot*rotq,body0,body1,dispatchInfo,resultOut);
    134                 }
    135         }
    136 
    13790        if (m_ownManifold)
    13891        {

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h

    r2907 r2908  
    55This software is provided 'as-is', without any express or implied warranty.
    66In no event will the authors be held liable for any damages arising from the use of this software.
    7 Permission is granted to anyone to use this software for any purpose,
    8 including commercial applications, and to alter it and redistribute it freely,
     7Permission is granted to anyone to use this software for any purpose, 
     8including commercial applications, and to alter it and redistribute it freely, 
    99subject to the following restrictions:
    1010
    … …  
    2929class btConvexPlaneCollisionAlgorithm : public btCollisionAlgorithm
    3030{
    31         bool            m_ownManifold;
     31        bool    m_ownManifold;
    3232        btPersistentManifold*   m_manifoldPtr;
    33         bool            m_isSwapped;
    34         int                     m_numPerturbationIterations;
    35         int                     m_minimumPointsPerturbationThreshold;
    36 
     33        bool    m_isSwapped;
     34       
    3735public:
    3836
    39         btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped, int numPerturbationIterations,int minimumPointsPerturbationThreshold);
     37        btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped);
    4038
    4139        virtual ~btConvexPlaneCollisionAlgorithm();
    4240
    4341        virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
    44 
    45         void collideSingleContact (const btQuaternion& perturbeRot, btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
    4642
    4743        virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
    … …  
    5753        struct CreateFunc :public       btCollisionAlgorithmCreateFunc
    5854        {
    59                 int     m_numPerturbationIterations;
    60                 int m_minimumPointsPerturbationThreshold;
    61                        
    62                 CreateFunc()
    63                         : m_numPerturbationIterations(3),
    64                         m_minimumPointsPerturbationThreshold(3)
    65                 {
    66                 }
    67                
    6855                virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
    6956                {
    … …  
    7158                        if (!m_swapped)
    7259                        {
    73                                 return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,false,m_numPerturbationIterations,m_minimumPointsPerturbationThreshold);
     60                                return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,false);
    7461                        } else
    7562                        {
    76                                 return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,true,m_numPerturbationIterations,m_minimumPointsPerturbationThreshold);
     63                                return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,true);
    7764                        }
    7865                }

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp

    r2907 r2908  
    289289        return m_emptyCreateFunc;
    290290}
    291 
    292 void btDefaultCollisionConfiguration::setConvexConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
    293 {
    294         btConvexConvexAlgorithm::CreateFunc* convexConvex = (btConvexConvexAlgorithm::CreateFunc*) m_convexConvexCreateFunc;
    295         convexConvex->m_numPerturbationIterations = numPerturbationIterations;
    296         convexConvex->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
    297 }

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h

    r2907 r2908  
    112112        virtual btCollisionAlgorithmCreateFunc* getCollisionAlgorithmCreateFunc(int proxyType0,int proxyType1);
    113113
    114         ///Use this method to allow to generate multiple contact points between at once, between two objects using the generic convex-convex algorithm.
    115         ///By default, this feature is disabled for best performance.
    116         ///@param numPerturbationIterations controls the number of collision queries. Set it to zero to disable the feature.
    117         ///@param minimumPointsPerturbationThreshold is the minimum number of points in the contact cache, above which the feature is disabled
    118         ///3 is a good value for both params, if you want to enable the feature. This is because the default contact cache contains a maximum of 4 points, and one collision query at the unperturbed orientation is performed first.
    119         ///See Bullet/Demos/CollisionDemo for an example how this feature gathers multiple points.
    120         ///@todo we could add a per-object setting of those parameters, for level-of-detail collision detection.
    121         void    setConvexConvexMultipointIterations(int numPerturbationIterations=3, int minimumPointsPerturbationThreshold = 3);
    122114
    123115};

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btGhostObject.cpp

    r2907 r2908  
    6464btPairCachingGhostObject::~btPairCachingGhostObject()
    6565{
    66         m_hashPairCache->~btHashedOverlappingPairCache();
    6766        btAlignedFree( m_hashPairCache );
    6867}

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btManifoldResult.cpp

    r2907 r2908  
    5656void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
    5757{
    58         btAssert(m_manifoldPtr);
     58        assert(m_manifoldPtr);
    5959        //order in manifold needs to match
    6060       
    … …  
    9393   newPt.m_index0  = m_index0;
    9494   newPt.m_index1  = m_index1;
    95         //printf("depth=%f\n",depth);
     95       
    9696        ///@todo, check this for any side effects
    9797        if (insertIndex >= 0)

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btManifoldResult.h

    r2907 r2908  
    4646        int m_index0;
    4747        int m_index1;
    48        
    49 
    5048public:
    5149
    … …  
    8078        }
    8179
    82 
    8380        virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth);
    8481

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

    r2907 r2908  
    2525#include "LinearMath/btQuickprof.h"
    2626
    27 btSimulationIslandManager::btSimulationIslandManager():
    28 m_splitIslands(true)
     27btSimulationIslandManager::btSimulationIslandManager()
    2928{
    3029}
    … …  
    4544       
    4645        {
    47                
     46                btBroadphasePair* pairPtr = colWorld->getPairCache()->getOverlappingPairArrayPtr();
     47
    4848                for (int i=0;i<colWorld->getPairCache()->getNumOverlappingPairs();i++)
    4949                {
    50                         btBroadphasePair* pairPtr = colWorld->getPairCache()->getOverlappingPairArrayPtr();
    5150                        const btBroadphasePair& collisionPair = pairPtr[i];
    5251                        btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject;
    … …  
    187186                        }
    188187
    189                         btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
     188                        assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
    190189                        if (colObj0->getIslandTag() == islandId)
    191190                        {
    … …  
    214213                                }
    215214
    216                                 btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
     215                                assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
    217216
    218217                                if (colObj0->getIslandTag() == islandId)
    … …  
    235234                                }
    236235
    237                                 btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
     236                                assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
    238237
    239238                                if (colObj0->getIslandTag() == islandId)
    … …  
    253252        int maxNumManifolds = dispatcher->getNumManifolds();
    254253
    255 //#define SPLIT_ISLANDS 1
    256 //#ifdef SPLIT_ISLANDS
    257 
    258        
    259 //#endif //SPLIT_ISLANDS
     254#define SPLIT_ISLANDS 1
     255#ifdef SPLIT_ISLANDS
     256
     257       
     258#endif //SPLIT_ISLANDS
    260259
    261260       
    … …  
    281280                                colObj0->activate();
    282281                        }
    283                         if(m_splitIslands)
    284                         {
    285                                 //filtering for response
    286                                 if (dispatcher->needsResponse(colObj0,colObj1))
    287                                         m_islandmanifold.push_back(manifold);
    288                         }
     282#ifdef SPLIT_ISLANDS
     283        //              //filtering for response
     284                        if (dispatcher->needsResponse(colObj0,colObj1))
     285                                m_islandmanifold.push_back(manifold);
     286#endif //SPLIT_ISLANDS
    289287                }
    290288        }
    … …  
    306304        BT_PROFILE("processIslands");
    307305
    308         if(!m_splitIslands)
    309         {
    310                 btPersistentManifold** manifold = dispatcher->getInternalManifoldPointer();
    311                 int maxNumManifolds = dispatcher->getNumManifolds();
    312                 callback->ProcessIsland(&collisionObjects[0],collisionObjects.size(),manifold,maxNumManifolds, -1);
    313         }
    314         else
    315         {
    316                 // Sort manifolds, based on islands
    317                 // Sort the vector using predicate and std::sort
    318                 //std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate);
    319 
    320                 int numManifolds = int (m_islandmanifold.size());
    321 
    322                 //we should do radix sort, it it much faster (O(n) instead of O (n log2(n))
    323                 m_islandmanifold.quickSort(btPersistentManifoldSortPredicate());
    324 
    325                 //now process all active islands (sets of manifolds for now)
    326 
    327                 int startManifoldIndex = 0;
    328                 int endManifoldIndex = 1;
    329 
    330                 //int islandId;
    331 
    332                
    333 
    334         //      printf("Start Islands\n");
    335 
    336                 //traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated
    337                 for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
    338                 {
    339                         int islandId = getUnionFind().getElement(startIslandIndex).m_id;
    340 
    341 
    342                            bool islandSleeping = false;
    343                        
    344                                         for (endIslandIndex = startIslandIndex;(endIslandIndex<numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
    345                                         {
    346                                                         int i = getUnionFind().getElement(endIslandIndex).m_sz;
    347                                                         btCollisionObject* colObj0 = collisionObjects[i];
    348                                                         m_islandBodies.push_back(colObj0);
    349                                                         if (!colObj0->isActive())
    350                                                                         islandSleeping = true;
    351                                         }
    352                        
    353 
    354                         //find the accompanying contact manifold for this islandId
    355                         int numIslandManifolds = 0;
    356                         btPersistentManifold** startManifold = 0;
    357 
    358                         if (startManifoldIndex<numManifolds)
    359                         {
    360                                 int curIslandId = getIslandId(m_islandmanifold[startManifoldIndex]);
    361                                 if (curIslandId == islandId)
    362                                 {
    363                                         startManifold = &m_islandmanifold[startManifoldIndex];
    364                                
    365                                         for (endManifoldIndex = startManifoldIndex+1;(endManifoldIndex<numManifolds) && (islandId == getIslandId(m_islandmanifold[endManifoldIndex]));endManifoldIndex++)
    366                                         {
    367 
    368                                         }
    369                                         /// Process the actual simulation, only if not sleeping/deactivated
    370                                         numIslandManifolds = endManifoldIndex-startManifoldIndex;
    371                                 }
    372 
    373                         }
    374 
    375                         if (!islandSleeping)
    376                         {
    377                                 callback->ProcessIsland(&m_islandBodies[0],m_islandBodies.size(),startManifold,numIslandManifolds, islandId);
    378         //                      printf("Island callback of size:%d bodies, %d manifolds\n",islandBodies.size(),numIslandManifolds);
    379                         }
     306#ifndef SPLIT_ISLANDS
     307        btPersistentManifold** manifold = dispatcher->getInternalManifoldPointer();
     308       
     309        callback->ProcessIsland(&collisionObjects[0],collisionObjects.size(),manifold,maxNumManifolds, -1);
     310#else
     311        // Sort manifolds, based on islands
     312        // Sort the vector using predicate and std::sort
     313        //std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate);
     314
     315        int numManifolds = int (m_islandmanifold.size());
     316
     317        //we should do radix sort, it it much faster (O(n) instead of O (n log2(n))
     318        m_islandmanifold.quickSort(btPersistentManifoldSortPredicate());
     319
     320        //now process all active islands (sets of manifolds for now)
     321
     322        int startManifoldIndex = 0;
     323        int endManifoldIndex = 1;
     324
     325        //int islandId;
     326
     327       
     328
     329//      printf("Start Islands\n");
     330
     331        //traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated
     332        for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
     333        {
     334                int islandId = getUnionFind().getElement(startIslandIndex).m_id;
     335
     336
     337               bool islandSleeping = false;
     338               
     339                for (endIslandIndex = startIslandIndex;(endIslandIndex<numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
     340                {
     341                        int i = getUnionFind().getElement(endIslandIndex).m_sz;
     342                        btCollisionObject* colObj0 = collisionObjects[i];
     343                                                m_islandBodies.push_back(colObj0);
     344                        if (!colObj0->isActive())
     345                                islandSleeping = true;
     346                }
     347               
     348
     349                //find the accompanying contact manifold for this islandId
     350                int numIslandManifolds = 0;
     351                btPersistentManifold** startManifold = 0;
     352
     353                if (startManifoldIndex<numManifolds)
     354                {
     355                        int curIslandId = getIslandId(m_islandmanifold[startManifoldIndex]);
     356                        if (curIslandId == islandId)
     357                        {
     358                                startManifold = &m_islandmanifold[startManifoldIndex];
    380359                       
    381                         if (numIslandManifolds)
    382                         {
    383                                 startManifoldIndex = endManifoldIndex;
    384                         }
    385 
    386                         m_islandBodies.resize(0);
    387                 }
    388         } // else if(!splitIslands)
    389 
    390 }
     360                                for (endManifoldIndex = startManifoldIndex+1;(endManifoldIndex<numManifolds) && (islandId == getIslandId(m_islandmanifold[endManifoldIndex]));endManifoldIndex++)
     361                                {
     362
     363                                }
     364                                /// Process the actual simulation, only if not sleeping/deactivated
     365                                numIslandManifolds = endManifoldIndex-startManifoldIndex;
     366                        }
     367
     368                }
     369
     370                if (!islandSleeping)
     371                {
     372                        callback->ProcessIsland(&m_islandBodies[0],m_islandBodies.size(),startManifold,numIslandManifolds, islandId);
     373//                      printf("Island callback of size:%d bodies, %d manifolds\n",islandBodies.size(),numIslandManifolds);
     374                }
     375               
     376                if (numIslandManifolds)
     377                {
     378                        startManifoldIndex = endManifoldIndex;
     379                }
     380
     381                m_islandBodies.resize(0);
     382        }
     383#endif //SPLIT_ISLANDS
     384
     385
     386}

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.h

    r2907 r2908  
    3636        btAlignedObjectArray<btCollisionObject* >  m_islandBodies;
    3737       
    38         bool m_splitIslands;
    3938       
    4039public:
    … …  
    6766        void buildIslands(btDispatcher* dispatcher,btCollisionWorld* colWorld);
    6867
    69         bool getSplitIslands()
    70         {
    71                 return m_splitIslands;
    72         }
    73         void setSplitIslands(bool doSplitIslands)
    74         {
    75                 m_splitIslands = doSplitIslands;
    76         }
    77 
    7868};
    7969

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

    r2907 r2908  
    7979
    8080        ///point on A (worldspace)
    81         ///btVector3 pos0 = col0->getWorldTransform().getOrigin() - radius0 * normalOnSurfaceB;
     81        btVector3 pos0 = col0->getWorldTransform().getOrigin() - radius0 * normalOnSurfaceB;
    8282        ///point on B (worldspace)
    8383        btVector3 pos1 = col1->getWorldTransform().getOrigin() + radius1* normalOnSurfaceB;

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btUnionFind.cpp

    r2907 r2908  
    1515
    1616#include "btUnionFind.h"
     17#include <assert.h>
     18
    1719
    1820

  • code/branches/questsystem5/src/bullet/BulletCollision/CollisionDispatch/btUnionFind.h

    r2907 r2908  
    9999                int find(int x)
    100100                {
    101                         //btAssert(x < m_N);
    102                         //btAssert(x >= 0);
     101                        //assert(x < m_N);
     102                        //assert(x >= 0);
    103103
    104104                        while (x != m_elements[x].m_id)
    … …  
    111111                #endif //
    112112                                x = m_elements[x].m_id;
    113                                 //btAssert(x < m_N);
    114                                 //btAssert(x >= 0);
     113                                //assert(x < m_N);
     114                                //assert(x >= 0);
    115115
    116116                        }
Note: See TracChangeset for help on using the changeset viewer.