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:
16 edited

Legend:

Unmodified
Added
Removed

  • code/branches/questsystem5

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp

    r2907 r2908  
    2020#include "btAxisSweep3.h"
    2121
     22#include <assert.h>
    2223
    2324btAxisSweep3::btAxisSweep3(const btVector3& worldAabbMin,const btVector3& worldAabbMax, unsigned short int maxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator)

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.h

    r2907 r2908  
    4343public:
    4444       
    45  BT_DECLARE_ALIGNED_ALLOCATOR();
    4645
    4746        class Edge
    … …  
    140139        SIMD_FORCE_INLINE Handle* getHandle(BP_FP_INT_TYPE index) const {return m_pHandles + index;}
    141140
    142         virtual void resetPool(btDispatcher* dispatcher);
     141        void resetPool();
    143142
    144143        void    processAllOverlappingPairs(btOverlapCallback* callback);
    … …  
    222221
    223222        if (checkCardinality)
    224                 btAssert(numEdges == m_numHandles*2+1);
     223                assert(numEdges == m_numHandles*2+1);
    225224}
    226225#endif //DEBUG_BROADPHASE
    … …  
    348347        }
    349348
    350         //btAssert(bounds.HasVolume());
     349        //assert(bounds.HasVolume());
    351350
    352351        // init bounds
    … …  
    454453BP_FP_INT_TYPE btAxisSweep3Internal<BP_FP_INT_TYPE>::allocHandle()
    455454{
    456         btAssert(m_firstFreeHandle);
     455        assert(m_firstFreeHandle);
    457456
    458457        BP_FP_INT_TYPE handle = m_firstFreeHandle;
    … …  
    466465void btAxisSweep3Internal<BP_FP_INT_TYPE>::freeHandle(BP_FP_INT_TYPE handle)
    467466{
    468         btAssert(handle > 0 && handle < m_maxHandles);
     467        assert(handle > 0 && handle < m_maxHandles);
    469468
    470469        getHandle(handle)->SetNextFree(m_firstFreeHandle);
    … …  
    589588
    590589template <typename BP_FP_INT_TYPE>
    591 void btAxisSweep3Internal<BP_FP_INT_TYPE>::resetPool(btDispatcher* dispatcher)
     590void btAxisSweep3Internal<BP_FP_INT_TYPE>::resetPool()
    592591{
    593592        if (m_numHandles == 0)
    … …  
    643642                        if (!isDuplicate)
    644643                        {
    645                                 ///important to use an AABB test that is consistent with the broadphase
    646644                                bool hasOverlap = testAabbOverlap(pair.m_pProxy0,pair.m_pProxy1);
    647645
    … …  
    689687        }
    690688
     689
     690
     691       
     692
    691693}
    692694
    … …  
    729731void btAxisSweep3Internal<BP_FP_INT_TYPE>::updateHandle(BP_FP_INT_TYPE handle, const btVector3& aabbMin,const btVector3& aabbMax,btDispatcher* dispatcher)
    730732{
    731 //      btAssert(bounds.IsFinite());
    732         //btAssert(bounds.HasVolume());
     733//      assert(bounds.IsFinite());
     734        //assert(bounds.HasVolume());
    733735
    734736        Handle* pHandle = getHandle(handle);

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h

    r2907 r2908  
    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 
    7067        virtual void    printStats() = 0;
    7168

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h

    r2907 r2908  
    7070
    7171        SOFTBODY_SHAPE_PROXYTYPE,
    72         HFFLUID_SHAPE_PROXYTYPE,
    73         HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
     72
    7473        INVALID_SHAPE_PROXYTYPE,
    7574
    … …  
    189188
    190189                //keep them sorted, so the std::set operations work
    191                 if (proxy0.m_uniqueId < proxy1.m_uniqueId)
     190                if (&proxy0 < &proxy1)
    192191        {
    193192            m_pProxy0 = &proxy0;
    … …  
    230229                bool operator() ( const btBroadphasePair& a, const btBroadphasePair& b )
    231230                {
    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) ||
     231                         return a.m_pProxy0 > b.m_pProxy0 ||
     232                                (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 > b.m_pProxy1) ||
    239233                                (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm);
    240234                }

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btDbvt.cpp

    r2907 r2908  
    394394}
    395395
    396 #if 0
     396//
    397397static DBVT_INLINE btDbvtNode*  walkup(btDbvtNode* n,int count)
    398398{
    … …  
    400400        return(n);
    401401}
    402 #endif
    403402
    404403//
    … …  
    425424void                    btDbvt::clear()
    426425{
    427         if(m_root)     
    428                 recursedeletenode(this,m_root);
     426        if(m_root)      recursedeletenode(this,m_root);
    429427        btAlignedFree(m_free);
    430428        m_free=0;
    431         m_lkhd          =       -1;
    432         m_stkStack.clear();
    433         m_opath         =       0;
    434        
    435429}
    436430

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btDbvt.h

    r2907 r2908  
    5858
    5959//SSE gives errors on a MSVC 7.1
    60 #ifdef BT_USE_SSE
     60#if (defined (WIN32) && (_MSC_VER) && _MSC_VER >= 1400) && (!defined (BT_USE_DOUBLE_PRECISION))
    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*)1;(void)typechecker;
     85#define DBVT_CHECKTYPE                          static const ICollide&  typechecker=*(T*)0;
    8686#else
    8787#define DBVT_VIRTUAL_DTOR(a)            virtual ~a() {}
    … …  
    147147        DBVT_INLINE friend bool                 Intersect(      const btDbvtAabbMm& a,
    148148                const btDbvtAabbMm& b);
    149        
     149        DBVT_INLINE friend bool                 Intersect(      const btDbvtAabbMm& a,
     150                const btDbvtAabbMm& b,
     151                const btTransform& xform);
    150152        DBVT_INLINE friend bool                 Intersect(      const btDbvtAabbMm& a,
    151153                const btVector3& b);
    … …  
    303305                  const btDbvtNode* root1,
    304306                  DBVT_IPOLICY);
    305 #if 0
     307
    306308        DBVT_PREFIX
    307309                void            collideTT(      const btDbvtNode* root0,
    … …  
    315317                const btTransform& xform1,
    316318                DBVT_IPOLICY);
    317 #endif
    318 
    319319        DBVT_PREFIX
    320320                void            collideTV(      const btDbvtNode* root,
    … …  
    531531}
    532532
    533 
     533//
     534DBVT_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}
    534548
    535549//
    … …  
    835849}
    836850
    837 #if 0
     851
    838852//
    839853DBVT_PREFIX
    … …  
    891905                }
    892906}
     907
    893908//
    894909DBVT_PREFIX
    … …  
    902917        collideTT(root0,root1,xform,policy);
    903918}
    904 #endif
    905919
    906920//

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp

    r2907 r2908  
    101101                        btDbvtProxy*    pb=(btDbvtProxy*)nb->data;
    102102#if DBVT_BP_SORTPAIRS
    103                         if(pa->m_uniqueId>pb->m_uniqueId)
    104                                 btSwap(pa,pb);
     103                        if(pa>pb) btSwap(pa,pb);
    105104#endif
    106105                        pbp->m_paircache->addOverlappingPair(pa,pb);
    … …  
    134133        m_updates_done          =       0;
    135134        m_updates_ratio         =       0;
    136         m_paircache                     =       paircache? paircache    : new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
     135        m_paircache                     =       paircache?
     136paircache       :
     137        new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
    137138        m_gid                           =       0;
    138139        m_pid                           =       0;
    … …  
    210211}
    211212
    212 struct  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 
    226213void    btDbvtBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback,const btVector3& aabbMin,const btVector3& aabbMax)
    227214{
     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
    228230        BroadphaseRayTester callback(rayCallback);
    229231
    … …  
    340342        }
    341343#endif
    342 
    343         performDeferredRemoval(dispatcher);
    344 
    345 }
    346 
    347 void 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         }
    417344}
    418345
    … …  
    420347void                                                    btDbvtBroadphase::collide(btDispatcher* dispatcher)
    421348{
    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 
    439349        SPC(m_profiling.m_total);
    440350        /* optimize                             */
    … …  
    492402                if(pairs.size()>0)
    493403                {
    494 
    495                         int                     ni=btMin(pairs.size(),btMax<int>(m_newpairs,(pairs.size()*m_cupdates)/100));
     404                        const int       ci=pairs.size();
     405                        int                     ni=btMin(ci,btMax<int>(m_newpairs,(ci*m_cupdates)/100));
    496406                        for(int i=0;i<ni;++i)
    497407                        {
    498                                 btBroadphasePair&       p=pairs[(m_cid+i)%pairs.size()];
     408                                btBroadphasePair&       p=pairs[(m_cid+i)%ci];
    499409                                btDbvtProxy*            pa=(btDbvtProxy*)p.m_pProxy0;
    500410                                btDbvtProxy*            pb=(btDbvtProxy*)p.m_pProxy1;
    … …  
    502412                                {
    503413#if DBVT_BP_SORTPAIRS
    504                                         if(pa->m_uniqueId>pb->m_uniqueId)
    505                                                 btSwap(pa,pb);
     414                                        if(pa>pb) btSwap(pa,pb);
    506415#endif
    507416                                        m_paircache->removeOverlappingPair(pa,pb,dispatcher);
    … …  
    558467        aabbMin=bounds.Mins();
    559468        aabbMax=bounds.Maxs();
    560 }
    561 
    562 void 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         }
    593469}
    594470
    … …  
    725601#undef  SPC
    726602#endif
    727 

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h

    r2907 r2908  
    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 
    124117};
    125118

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp

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

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.h

    r2907 r2908  
    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 
    149146};
    150147

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp

    r2907 r2908  
    2020#include "btDispatcher.h"
    2121#include "btCollisionAlgorithm.h"
    22 #include "LinearMath/btAabbUtil2.h"
    2322
    2423#include <stdio.h>
    … …  
    137136{
    138137        gFindPairs++;
    139         if(proxy0->m_uniqueId>proxy1->m_uniqueId)
    140                 btSwap(proxy0,proxy1);
     138        if(proxy0>proxy1) btSwap(proxy0,proxy1);
    141139        int proxyId1 = proxy0->getUid();
    142140        int proxyId2 = proxy1->getUid();
    … …  
    214212btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
    215213{
    216         if(proxy0->m_uniqueId>proxy1->m_uniqueId)
    217                 btSwap(proxy0,proxy1);
     214        if(proxy0>proxy1) btSwap(proxy0,proxy1);
    218215        int proxyId1 = proxy0->getUid();
    219216        int proxyId2 = proxy1->getUid();
    … …  
    274271{
    275272        gRemovePairs++;
    276         if(proxy0->m_uniqueId>proxy1->m_uniqueId)
    277                 btSwap(proxy0,proxy1);
     273        if(proxy0>proxy1) btSwap(proxy0,proxy1);
    278274        int proxyId1 = proxy0->getUid();
    279275        int proxyId2 = proxy1->getUid();
    … …  
    397393}
    398394
    399 void    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 }
    428395
    429396
    … …  
    463430{
    464431        //don't add overlap with own
    465         btAssert(proxy0 != proxy1);
     432        assert(proxy0 != proxy1);
    466433
    467434        if (!needsBroadphaseCollision(proxy0,proxy1))
    … …  
    494461        if (findIndex < m_overlappingPairArray.size())
    495462        {
    496                 //btAssert(it != m_overlappingPairSet.end());
     463                //assert(it != m_overlappingPairSet.end());
    497464                 btBroadphasePair* pair = &m_overlappingPairArray[findIndex];
    498465                return pair;
    … …  
    524491                {
    525492                        cleanOverlappingPair(*pair,dispatcher);
    526                         pair->m_pProxy0 = 0;
    527                         pair->m_pProxy1 = 0;
    528                         m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
     493
     494                        m_overlappingPairArray.swap(i,m_overlappingPairArray.capacity()-1);
    529495                        m_overlappingPairArray.pop_back();
    530496                        gOverlappingPairs--;
    … …  
    626592        processAllOverlappingPairs(&removeCallback,dispatcher);
    627593}
    628 
    629 void    btSortedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
    630 {
    631         //should already be sorted
    632 }
    633 

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h

    r2907 r2908  
    8484
    8585        virtual void    setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)=0;
    86 
    87         virtual void    sortOverlappingPairs(btDispatcher* dispatcher) = 0;
    88 
    8986
    9087};
    … …  
    263260        }
    264261
    265         virtual void    sortOverlappingPairs(btDispatcher* dispatcher);
    266        
    267 
    268 protected:
     262public:
    269263       
    270264        btAlignedObjectArray<int>       m_hashTable;
    … …  
    376370                }
    377371
    378                 virtual void    sortOverlappingPairs(btDispatcher* dispatcher);
    379                
    380372
    381373};
    … …  
    456448        }
    457449       
    458         virtual void    sortOverlappingPairs(btDispatcher* dispatcher)
    459         {
    460         }
    461450
    462451

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp

    r2907 r2908  
    470470
    471471#ifdef RAYAABB2
     472        btVector3 rayFrom = raySource;
    472473        btVector3 rayDir = (rayTarget-raySource);
    473474        rayDir.normalize ();
    … …  
    558559
    559560#ifdef RAYAABB2
     561        btVector3 rayFrom = raySource;
    560562        btVector3 rayDirection = (rayTarget-raySource);
    561563        rayDirection.normalize ();
    … …  
    816818#include <new>
    817819
    818 #if 0
    819820//PCK: consts
    820821static const unsigned BVH_ALIGNMENT = 16;
    … …  
    822823
    823824static const unsigned BVH_ALIGNMENT_BLOCKS = 2;
    824 #endif
     825
    825826
    826827
    … …  
    11461147
    11471148
    1148 

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp

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

  • code/branches/questsystem5/src/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h

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