Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 31, 2009, 8:05:51 PM (16 years ago)
Author:
rgrieder
Message:

Update from Bullet 2.73 to 2.74.

Location:
code/trunk/src/bullet/BulletCollision/BroadphaseCollision
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp

    r2662 r2882  
    2020#include "btAxisSweep3.h"
    2121
    22 #include <assert.h>
    2322
    2423btAxisSweep3::btAxisSweep3(const btVector3& worldAabbMin,const btVector3& worldAabbMax, unsigned short int maxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator)

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.h

    r2662 r2882  
    4343public:
    4444       
     45 BT_DECLARE_ALIGNED_ALLOCATOR();
    4546
    4647        class Edge
    … …  
    139140        SIMD_FORCE_INLINE Handle* getHandle(BP_FP_INT_TYPE index) const {return m_pHandles + index;}
    140141
    141         void resetPool();
     142        virtual void resetPool(btDispatcher* dispatcher);
    142143
    143144        void    processAllOverlappingPairs(btOverlapCallback* callback);
    … …  
    221222
    222223        if (checkCardinality)
    223                 assert(numEdges == m_numHandles*2+1);
     224                btAssert(numEdges == m_numHandles*2+1);
    224225}
    225226#endif //DEBUG_BROADPHASE
    … …  
    347348        }
    348349
    349         //assert(bounds.HasVolume());
     350        //btAssert(bounds.HasVolume());
    350351
    351352        // init bounds
    … …  
    453454BP_FP_INT_TYPE btAxisSweep3Internal<BP_FP_INT_TYPE>::allocHandle()
    454455{
    455         assert(m_firstFreeHandle);
     456        btAssert(m_firstFreeHandle);
    456457
    457458        BP_FP_INT_TYPE handle = m_firstFreeHandle;
    … …  
    465466void btAxisSweep3Internal<BP_FP_INT_TYPE>::freeHandle(BP_FP_INT_TYPE handle)
    466467{
    467         assert(handle > 0 && handle < m_maxHandles);
     468        btAssert(handle > 0 && handle < m_maxHandles);
    468469
    469470        getHandle(handle)->SetNextFree(m_firstFreeHandle);
    … …  
    588589
    589590template <typename BP_FP_INT_TYPE>
    590 void btAxisSweep3Internal<BP_FP_INT_TYPE>::resetPool()
     591void btAxisSweep3Internal<BP_FP_INT_TYPE>::resetPool(btDispatcher* dispatcher)
    591592{
    592593        if (m_numHandles == 0)
    … …  
    642643                        if (!isDuplicate)
    643644                        {
     645                                ///important to use an AABB test that is consistent with the broadphase
    644646                                bool hasOverlap = testAabbOverlap(pair.m_pProxy0,pair.m_pProxy1);
    645647
    … …  
    687689        }
    688690
    689 
    690 
    691        
    692 
    693691}
    694692
    … …  
    731729void btAxisSweep3Internal<BP_FP_INT_TYPE>::updateHandle(BP_FP_INT_TYPE handle, const btVector3& aabbMin,const btVector3& aabbMax,btDispatcher* dispatcher)
    732730{
    733 //      assert(bounds.IsFinite());
    734         //assert(bounds.HasVolume());
     731//      btAssert(bounds.IsFinite());
     732        //btAssert(bounds.HasVolume());
    735733
    736734        Handle* pHandle = getHandle(handle);

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h

    r2662 r2882  
    6565        virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const =0;
    6666
     67        ///reset broadphase internal structures, to ensure determinism/reproducability
     68        virtual void resetPool(btDispatcher* dispatcher) {};
     69
    6770        virtual void    printStats() = 0;
    6871

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h

    r2662 r2882  
    7070
    7171        SOFTBODY_SHAPE_PROXYTYPE,
    72 
     72        HFFLUID_SHAPE_PROXYTYPE,
     73        HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
    7374        INVALID_SHAPE_PROXYTYPE,
    7475
    … …  
    188189
    189190                //keep them sorted, so the std::set operations work
    190                 if (&proxy0 < &proxy1)
     191                if (proxy0.m_uniqueId < proxy1.m_uniqueId)
    191192        {
    192193            m_pProxy0 = &proxy0;
    … …  
    229230                bool operator() ( const btBroadphasePair& a, const btBroadphasePair& b )
    230231                {
    231                          return a.m_pProxy0 > b.m_pProxy0 ||
    232                                 (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 > b.m_pProxy1) ||
     232                        const int uidA0 = a.m_pProxy0 ? a.m_pProxy0->m_uniqueId : -1;
     233                        const int uidB0 = b.m_pProxy0 ? b.m_pProxy0->m_uniqueId : -1;
     234                        const int uidA1 = a.m_pProxy1 ? a.m_pProxy1->m_uniqueId : -1;
     235                        const int uidB1 = b.m_pProxy1 ? b.m_pProxy1->m_uniqueId : -1;
     236
     237                         return uidA0 > uidB0 ||
     238                                (a.m_pProxy0 == b.m_pProxy0 && uidA1 > uidB1) ||
    233239                                (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm);
    234240                }

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btDbvt.cpp

    r2662 r2882  
    394394}
    395395
    396 //
     396#if 0
    397397static DBVT_INLINE btDbvtNode*  walkup(btDbvtNode* n,int count)
    398398{
    … …  
    400400        return(n);
    401401}
     402#endif
    402403
    403404//
    … …  
    424425void                    btDbvt::clear()
    425426{
    426         if(m_root)      recursedeletenode(this,m_root);
     427        if(m_root)     
     428                recursedeletenode(this,m_root);
    427429        btAlignedFree(m_free);
    428430        m_free=0;
     431        m_lkhd          =       -1;
     432        m_stkStack.clear();
     433        m_opath         =       0;
     434       
    429435}
    430436

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btDbvt.h

    r2662 r2882  
    5858
    5959//SSE gives errors on a MSVC 7.1
    60 #if (defined (WIN32) && (_MSC_VER) && _MSC_VER >= 1400) && (!defined (BT_USE_DOUBLE_PRECISION))
     60#ifdef BT_USE_SSE
    6161#define DBVT_SELECT_IMPL                DBVT_IMPL_SSE
    6262#define DBVT_MERGE_IMPL                 DBVT_IMPL_SSE
    … …  
    8383#define DBVT_PREFIX                                     template <typename T>
    8484#define DBVT_IPOLICY                            T& policy
    85 #define DBVT_CHECKTYPE                          static const ICollide&  typechecker=*(T*)0;
     85#define DBVT_CHECKTYPE                          static const ICollide&  typechecker=*(T*)1;(void)typechecker;
    8686#else
    8787#define DBVT_VIRTUAL_DTOR(a)            virtual ~a() {}
    … …  
    147147        DBVT_INLINE friend bool                 Intersect(      const btDbvtAabbMm& a,
    148148                const btDbvtAabbMm& b);
    149         DBVT_INLINE friend bool                 Intersect(      const btDbvtAabbMm& a,
    150                 const btDbvtAabbMm& b,
    151                 const btTransform& xform);
     149       
    152150        DBVT_INLINE friend bool                 Intersect(      const btDbvtAabbMm& a,
    153151                const btVector3& b);
    … …  
    305303                  const btDbvtNode* root1,
    306304                  DBVT_IPOLICY);
    307 
     305#if 0
    308306        DBVT_PREFIX
    309307                void            collideTT(      const btDbvtNode* root0,
    … …  
    317315                const btTransform& xform1,
    318316                DBVT_IPOLICY);
     317#endif
     318
    319319        DBVT_PREFIX
    320320                void            collideTV(      const btDbvtNode* root,
    … …  
    531531}
    532532
    533 //
    534 DBVT_INLINE bool                Intersect(      const btDbvtAabbMm& a,
    535                                                                   const btDbvtAabbMm& b,
    536                                                                   const btTransform& xform)
    537 {
    538         const btVector3         d0=xform*b.Center()-a.Center();
    539         const btVector3         d1=d0*xform.getBasis();
    540         btScalar                        s0[2]={0,0};
    541         btScalar                        s1[2]={dot(xform.getOrigin(),d0),s1[0]};
    542         a.AddSpan(d0,s0[0],s0[1]);
    543         b.AddSpan(d1,s1[0],s1[1]);
    544         if(s0[0]>(s1[1])) return(false);
    545         if(s0[1]<(s1[0])) return(false);
    546         return(true);
    547 }
     533
    548534
    549535//
    … …  
    849835}
    850836
    851 
     837#if 0
    852838//
    853839DBVT_PREFIX
    … …  
    905891                }
    906892}
    907 
    908893//
    909894DBVT_PREFIX
    … …  
    917902        collideTT(root0,root1,xform,policy);
    918903}
     904#endif
    919905
    920906//

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp

    r2662 r2882  
    101101                        btDbvtProxy*    pb=(btDbvtProxy*)nb->data;
    102102#if DBVT_BP_SORTPAIRS
    103                         if(pa>pb) btSwap(pa,pb);
     103                        if(pa->m_uniqueId>pb->m_uniqueId)
     104                                btSwap(pa,pb);
    104105#endif
    105106                        pbp->m_paircache->addOverlappingPair(pa,pb);
    … …  
    133134        m_updates_done          =       0;
    134135        m_updates_ratio         =       0;
    135         m_paircache                     =       paircache?
    136 paircache       :
    137         new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
     136        m_paircache                     =       paircache? paircache    : new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
    138137        m_gid                           =       0;
    139138        m_pid                           =       0;
    … …  
    211210}
    212211
     212struct  BroadphaseRayTester : btDbvt::ICollide
     213{
     214        btBroadphaseRayCallback& m_rayCallback;
     215        BroadphaseRayTester(btBroadphaseRayCallback& orgCallback)
     216                :m_rayCallback(orgCallback)
     217        {
     218        }
     219        void                                    Process(const btDbvtNode* leaf)
     220        {
     221                btDbvtProxy*    proxy=(btDbvtProxy*)leaf->data;
     222                m_rayCallback.process(proxy);
     223        }
     224};     
     225
    213226void    btDbvtBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback,const btVector3& aabbMin,const btVector3& aabbMax)
    214227{
    215 
    216         struct  BroadphaseRayTester : btDbvt::ICollide
    217         {
    218                 btBroadphaseRayCallback& m_rayCallback;
    219                 BroadphaseRayTester(btBroadphaseRayCallback& orgCallback)
    220                         :m_rayCallback(orgCallback)
    221                 {
    222                 }
    223                 void                                    Process(const btDbvtNode* leaf)
    224                 {
    225                         btDbvtProxy*    proxy=(btDbvtProxy*)leaf->data;
    226                         m_rayCallback.process(proxy);
    227                 }
    228         };     
    229 
    230228        BroadphaseRayTester callback(rayCallback);
    231229
    … …  
    342340        }
    343341#endif
     342
     343        performDeferredRemoval(dispatcher);
     344
     345}
     346
     347void btDbvtBroadphase::performDeferredRemoval(btDispatcher* dispatcher)
     348{
     349
     350        if (m_paircache->hasDeferredRemoval())
     351        {
     352
     353                btBroadphasePairArray&  overlappingPairArray = m_paircache->getOverlappingPairArray();
     354
     355                //perform a sort, to find duplicates and to sort 'invalid' pairs to the end
     356                overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
     357
     358                int invalidPair = 0;
     359
     360               
     361                int i;
     362
     363                btBroadphasePair previousPair;
     364                previousPair.m_pProxy0 = 0;
     365                previousPair.m_pProxy1 = 0;
     366                previousPair.m_algorithm = 0;
     367               
     368               
     369                for (i=0;i<overlappingPairArray.size();i++)
     370                {
     371               
     372                        btBroadphasePair& pair = overlappingPairArray[i];
     373
     374                        bool isDuplicate = (pair == previousPair);
     375
     376                        previousPair = pair;
     377
     378                        bool needsRemoval = false;
     379
     380                        if (!isDuplicate)
     381                        {
     382                                //important to perform AABB check that is consistent with the broadphase
     383                                btDbvtProxy*            pa=(btDbvtProxy*)pair.m_pProxy0;
     384                                btDbvtProxy*            pb=(btDbvtProxy*)pair.m_pProxy1;
     385                                bool hasOverlap = Intersect(pa->leaf->volume,pb->leaf->volume);
     386
     387                                if (hasOverlap)
     388                                {
     389                                        needsRemoval = false;
     390                                } else
     391                                {
     392                                        needsRemoval = true;
     393                                }
     394                        } else
     395                        {
     396                                //remove duplicate
     397                                needsRemoval = true;
     398                                //should have no algorithm
     399                                btAssert(!pair.m_algorithm);
     400                        }
     401                       
     402                        if (needsRemoval)
     403                        {
     404                                m_paircache->cleanOverlappingPair(pair,dispatcher);
     405
     406                                pair.m_pProxy0 = 0;
     407                                pair.m_pProxy1 = 0;
     408                                invalidPair++;
     409                        }
     410                       
     411                }
     412
     413                //perform a sort, to sort 'invalid' pairs to the end
     414                overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
     415                overlappingPairArray.resize(overlappingPairArray.size() - invalidPair);
     416        }
    344417}
    345418
    … …  
    347420void                                                    btDbvtBroadphase::collide(btDispatcher* dispatcher)
    348421{
     422        /*printf("---------------------------------------------------------\n");
     423        printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves);
     424        printf("m_sets[1].m_leaves=%d\n",m_sets[1].m_leaves);
     425        printf("numPairs = %d\n",getOverlappingPairCache()->getNumOverlappingPairs());
     426        {
     427                int i;
     428                for (i=0;i<getOverlappingPairCache()->getNumOverlappingPairs();i++)
     429                {
     430                        printf("pair[%d]=(%d,%d),",i,getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy0->getUid(),
     431                                getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy1->getUid());
     432                }
     433                printf("\n");
     434        }
     435*/
     436
     437
     438
    349439        SPC(m_profiling.m_total);
    350440        /* optimize                             */
    … …  
    402492                if(pairs.size()>0)
    403493                {
    404                         const int       ci=pairs.size();
    405                         int                     ni=btMin(ci,btMax<int>(m_newpairs,(ci*m_cupdates)/100));
     494
     495                        int                     ni=btMin(pairs.size(),btMax<int>(m_newpairs,(pairs.size()*m_cupdates)/100));
    406496                        for(int i=0;i<ni;++i)
    407497                        {
    408                                 btBroadphasePair&       p=pairs[(m_cid+i)%ci];
     498                                btBroadphasePair&       p=pairs[(m_cid+i)%pairs.size()];
    409499                                btDbvtProxy*            pa=(btDbvtProxy*)p.m_pProxy0;
    410500                                btDbvtProxy*            pb=(btDbvtProxy*)p.m_pProxy1;
    … …  
    412502                                {
    413503#if DBVT_BP_SORTPAIRS
    414                                         if(pa>pb) btSwap(pa,pb);
     504                                        if(pa->m_uniqueId>pb->m_uniqueId)
     505                                                btSwap(pa,pb);
    415506#endif
    416507                                        m_paircache->removeOverlappingPair(pa,pb,dispatcher);
    … …  
    467558        aabbMin=bounds.Mins();
    468559        aabbMax=bounds.Maxs();
     560}
     561
     562void btDbvtBroadphase::resetPool(btDispatcher* dispatcher)
     563{
     564       
     565        int totalObjects = m_sets[0].m_leaves + m_sets[1].m_leaves;
     566        if (!totalObjects)
     567        {
     568                //reset internal dynamic tree data structures
     569                m_sets[0].clear();
     570                m_sets[1].clear();
     571               
     572                m_deferedcollide        =       false;
     573                m_needcleanup           =       true;
     574                m_prediction            =       1/(btScalar)2;
     575                m_stageCurrent          =       0;
     576                m_fixedleft                     =       0;
     577                m_fupdates                      =       1;
     578                m_dupdates                      =       0;
     579                m_cupdates                      =       10;
     580                m_newpairs                      =       1;
     581                m_updates_call          =       0;
     582                m_updates_done          =       0;
     583                m_updates_ratio         =       0;
     584               
     585                m_gid                           =       0;
     586                m_pid                           =       0;
     587                m_cid                           =       0;
     588                for(int i=0;i<=STAGECOUNT;++i)
     589                {
     590                        m_stageRoots[i]=0;
     591                }
     592        }
    469593}
    470594
    … …  
    601725#undef  SPC
    602726#endif
     727

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h

    r2662 r2882  
    2525
    2626#define DBVT_BP_PROFILE                                 0
    27 #define DBVT_BP_SORTPAIRS                               1
     27//#define DBVT_BP_SORTPAIRS                             1
    2828#define DBVT_BP_PREVENTFALSEUPDATE              0
    2929#define DBVT_BP_ACCURATESLEEPING                0
    … …  
    115115        void                                                    printStats();
    116116        static void                                             benchmark(btBroadphaseInterface*);
     117
     118
     119        void    performDeferredRemoval(btDispatcher* dispatcher);
     120
     121        ///reset broadphase internal structures, to ensure determinism/reproducability
     122        virtual void resetPool(btDispatcher* dispatcher);
     123
    117124};
    118125

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp

    r2662 r2882  
    483483
    484484}
     485
     486void btMultiSapBroadphase::resetPool(btDispatcher* dispatcher)
     487{
     488        // not yet
     489}

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.h

    r2662 r2882  
    144144        void quicksort (btBroadphasePairArray& a, int lo, int hi);
    145145
     146        ///reset broadphase internal structures, to ensure determinism/reproducability
     147        virtual void resetPool(btDispatcher* dispatcher);
     148
    146149};
    147150

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp

    r2662 r2882  
    2020#include "btDispatcher.h"
    2121#include "btCollisionAlgorithm.h"
     22#include "LinearMath/btAabbUtil2.h"
    2223
    2324#include <stdio.h>
    … …  
    136137{
    137138        gFindPairs++;
    138         if(proxy0>proxy1) btSwap(proxy0,proxy1);
     139        if(proxy0->m_uniqueId>proxy1->m_uniqueId)
     140                btSwap(proxy0,proxy1);
    139141        int proxyId1 = proxy0->getUid();
    140142        int proxyId2 = proxy1->getUid();
    … …  
    212214btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
    213215{
    214         if(proxy0>proxy1) btSwap(proxy0,proxy1);
     216        if(proxy0->m_uniqueId>proxy1->m_uniqueId)
     217                btSwap(proxy0,proxy1);
    215218        int proxyId1 = proxy0->getUid();
    216219        int proxyId2 = proxy1->getUid();
    … …  
    271274{
    272275        gRemovePairs++;
    273         if(proxy0>proxy1) btSwap(proxy0,proxy1);
     276        if(proxy0->m_uniqueId>proxy1->m_uniqueId)
     277                btSwap(proxy0,proxy1);
    274278        int proxyId1 = proxy0->getUid();
    275279        int proxyId2 = proxy1->getUid();
    … …  
    393397}
    394398
     399void    btHashedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
     400{
     401        ///need to keep hashmap in sync with pair address, so rebuild all
     402        btBroadphasePairArray tmpPairs;
     403        int i;
     404        for (i=0;i<m_overlappingPairArray.size();i++)
     405        {
     406                tmpPairs.push_back(m_overlappingPairArray[i]);
     407        }
     408
     409        for (i=0;i<tmpPairs.size();i++)
     410        {
     411                removeOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1,dispatcher);
     412        }
     413       
     414        for (i = 0; i < m_next.size(); i++)
     415        {
     416                m_next[i] = BT_NULL_PAIR;
     417        }
     418
     419        tmpPairs.quickSort(btBroadphasePairSortPredicate());
     420
     421        for (i=0;i<tmpPairs.size();i++)
     422        {
     423                addOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1);
     424        }
     425
     426       
     427}
    395428
    396429
    … …  
    430463{
    431464        //don't add overlap with own
    432         assert(proxy0 != proxy1);
     465        btAssert(proxy0 != proxy1);
    433466
    434467        if (!needsBroadphaseCollision(proxy0,proxy1))
    … …  
    461494        if (findIndex < m_overlappingPairArray.size())
    462495        {
    463                 //assert(it != m_overlappingPairSet.end());
     496                //btAssert(it != m_overlappingPairSet.end());
    464497                 btBroadphasePair* pair = &m_overlappingPairArray[findIndex];
    465498                return pair;
    … …  
    491524                {
    492525                        cleanOverlappingPair(*pair,dispatcher);
    493 
    494                         m_overlappingPairArray.swap(i,m_overlappingPairArray.capacity()-1);
     526                        pair->m_pProxy0 = 0;
     527                        pair->m_pProxy1 = 0;
     528                        m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
    495529                        m_overlappingPairArray.pop_back();
    496530                        gOverlappingPairs--;
    … …  
    592626        processAllOverlappingPairs(&removeCallback,dispatcher);
    593627}
     628
     629void    btSortedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
     630{
     631        //should already be sorted
     632}
     633

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h

    r2662 r2882  
    8484
    8585        virtual void    setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)=0;
     86
     87        virtual void    sortOverlappingPairs(btDispatcher* dispatcher) = 0;
     88
    8689
    8790};
    … …  
    260263        }
    261264
    262 public:
     265        virtual void    sortOverlappingPairs(btDispatcher* dispatcher);
     266       
     267
     268protected:
    263269       
    264270        btAlignedObjectArray<int>       m_hashTable;
    … …  
    370376                }
    371377
     378                virtual void    sortOverlappingPairs(btDispatcher* dispatcher);
     379               
    372380
    373381};
    … …  
    448456        }
    449457       
     458        virtual void    sortOverlappingPairs(btDispatcher* dispatcher)
     459        {
     460        }
    450461
    451462

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp

    r2662 r2882  
    470470
    471471#ifdef RAYAABB2
    472         btVector3 rayFrom = raySource;
    473472        btVector3 rayDir = (rayTarget-raySource);
    474473        rayDir.normalize ();
    … …  
    559558
    560559#ifdef RAYAABB2
    561         btVector3 rayFrom = raySource;
    562560        btVector3 rayDirection = (rayTarget-raySource);
    563561        rayDirection.normalize ();
    … …  
    818816#include <new>
    819817
     818#if 0
    820819//PCK: consts
    821820static const unsigned BVH_ALIGNMENT = 16;
    … …  
    823822
    824823static const unsigned BVH_ALIGNMENT_BLOCKS = 2;
    825 
     824#endif
    826825
    827826
    … …  
    11471146
    11481147
     1148

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp

    r2662 r2882  
    325325}
    326326
    327 
    328 
     327void    btSimpleBroadphase::resetPool(btDispatcher* dispatcher)
     328{
     329        //not yet
     330}

  • code/trunk/src/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h

    r2662 r2882  
    109109        }
    110110
     111        ///reset broadphase internal structures, to ensure determinism/reproducability
     112        virtual void resetPool(btDispatcher* dispatcher);
     113
    111114
    112115        void    validate();
Note: See TracChangeset for help on using the changeset viewer.