Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Oct 20, 2008, 5:40:38 PM (16 years ago)
Author:
rgrieder
Message:

Downgraded Bullet to latest tagged version: 2.72
That should give us more stability.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1963 r1972  
    2727#if DBVT_BP_PROFILE
    2828struct  ProfileScope
    29 {
     29        {
    3030        __forceinline ProfileScope(btClock& clock,unsigned long& value) :
    31         m_clock(&clock),m_value(&value),m_base(clock.getTimeMicroseconds())
    32         {
    33         }
     31                m_clock(&clock),m_value(&value),m_base(clock.getTimeMicroseconds())
     32                {
     33                }
    3434        __forceinline ~ProfileScope()
    35         {
     35                {
    3636                (*m_value)+=m_clock->getTimeMicroseconds()-m_base;
    37         }
     37                }
    3838        btClock*                m_clock;
    3939        unsigned long*  m_value;
    4040        unsigned long   m_base;
    41 };
     41        };
    4242#define SPC(_value_)    ProfileScope    spc_scope(m_clock,_value_)
    4343#else
    … …  
    5353static inline void      listappend(T* item,T*& list)
    5454{
    55         item->links[0]=0;
    56         item->links[1]=list;
    57         if(list) list->links[0]=item;
    58         list=item;
     55item->links[0]=0;
     56item->links[1]=list;
     57if(list) list->links[0]=item;
     58list=item;
    5959}
    6060
    … …  
    6363static inline void      listremove(T* item,T*& list)
    6464{
    65         if(item->links[0]) item->links[0]->links[1]=item->links[1]; else list=item->links[1];
    66         if(item->links[1]) item->links[1]->links[0]=item->links[0];
     65if(item->links[0]) item->links[0]->links[1]=item->links[1]; else list=item->links[1];
     66if(item->links[1]) item->links[1]->links[0]=item->links[0];
    6767}
    6868
    … …  
    7171static inline int       listcount(T* root)
    7272{
    73         int     n=0;
    74         while(root) { ++n;root=root->links[1]; }
    75         return(n);
     73int     n=0;
     74while(root) { ++n;root=root->links[1]; }
     75return(n);
    7676}
    7777
    … …  
    8080static inline void      clear(T& value)
    8181{
    82         static const struct ZeroDummy : T {} zerodummy;
    83         value=zerodummy;
     82static const struct ZeroDummy : T {} zerodummy;
     83value=zerodummy;
    8484}
    8585
    … …  
    9191struct  btDbvtTreeCollider : btDbvt::ICollide
    9292{
    93         btDbvtBroadphase*       pbp;
    94         btDbvtProxy*            proxy;
    95         btDbvtTreeCollider(btDbvtBroadphase* p) : pbp(p) {}
    96         void    Process(const btDbvtNode* na,const btDbvtNode* nb)
    97         {
    98                 if(na!=nb)
    99                 {
    100                         btDbvtProxy*    pa=(btDbvtProxy*)na->data;
    101                         btDbvtProxy*    pb=(btDbvtProxy*)nb->data;
    102 #if DBVT_BP_SORTPAIRS
    103                         if(pa>pb) btSwap(pa,pb);
    104 #endif
    105                         pbp->m_paircache->addOverlappingPair(pa,pb);
    106                         ++pbp->m_newpairs;
    107                 }
    108         }
    109         void    Process(const btDbvtNode* n)
    110         {
    111                 Process(n,proxy->leaf);
     93btDbvtBroadphase*       pbp;
     94btDbvtProxy*            proxy;
     95                btDbvtTreeCollider(btDbvtBroadphase* p) : pbp(p) {}
     96void    Process(const btDbvtNode* na,const btDbvtNode* nb)
     97        {
     98        if(na!=nb)
     99                {
     100                btDbvtProxy*    pa=(btDbvtProxy*)na->data;
     101                btDbvtProxy*    pb=(btDbvtProxy*)nb->data;
     102                #if DBVT_BP_SORTPAIRS
     103                if(pa>pb) btSwap(pa,pb);
     104                #endif
     105                pbp->m_paircache->addOverlappingPair(pa,pb);
     106                ++pbp->m_newpairs;
     107                }
     108        }
     109void    Process(const btDbvtNode* n)
     110        {
     111        Process(n,proxy->leaf);
    112112        }
    113113};
    … …  
    120120btDbvtBroadphase::btDbvtBroadphase(btOverlappingPairCache* paircache)
    121121{
    122         m_deferedcollide        =       false;
    123         m_needcleanup           =       true;
    124         m_releasepaircache      =       (paircache!=0)?false:true;
    125         m_prediction            =       1/(btScalar)2;
    126         m_stageCurrent          =       0;
    127         m_fixedleft                     =       0;
    128         m_fupdates                      =       1;
    129         m_dupdates                      =       0;
    130         m_cupdates                      =       10;
    131         m_newpairs                      =       1;
    132         m_updates_call          =       0;
    133         m_updates_done          =       0;
    134         m_updates_ratio         =       0;
    135         m_paircache                     =       paircache?
    136 paircache       :
    137         new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
    138         m_gid                           =       0;
    139         m_pid                           =       0;
    140         m_cid                           =       0;
    141         for(int i=0;i<=STAGECOUNT;++i)
    142         {
    143                 m_stageRoots[i]=0;
     122m_deferedcollide        =       false;
     123m_needcleanup           =       true;
     124m_releasepaircache      =       (paircache!=0)?false:true;
     125m_prediction            =       1/(btScalar)2;
     126m_stageCurrent          =       0;
     127m_fixedleft                     =       0;
     128m_fupdates                      =       1;
     129m_dupdates                      =       0;
     130m_cupdates                      =       10;
     131m_newpairs                      =       1;
     132m_updates_call          =       0;
     133m_updates_done          =       0;
     134m_updates_ratio         =       0;
     135m_paircache                     =       paircache?
     136                                                paircache       :
     137                                                new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
     138m_gid                           =       0;
     139m_pid                           =       0;
     140m_cid                           =       0;
     141for(int i=0;i<=STAGECOUNT;++i)
     142        {
     143        m_stageRoots[i]=0;
    144144        }
    145145#if DBVT_BP_PROFILE
    146         clear(m_profiling);
     146clear(m_profiling);
    147147#endif
    148148}
    … …  
    151151btDbvtBroadphase::~btDbvtBroadphase()
    152152{
    153         if(m_releasepaircache)
    154         {
    155                 m_paircache->~btOverlappingPairCache();
    156                 btAlignedFree(m_paircache);
    157         }
     153if(m_releasepaircache)
     154{
     155        m_paircache->~btOverlappingPairCache();
     156        btAlignedFree(m_paircache);
     157}
    158158}
    159159
    160160//
    161161btBroadphaseProxy*                              btDbvtBroadphase::createProxy(  const btVector3& aabbMin,
    162                                                                                                                           const btVector3& aabbMax,
    163                                                                                                                           int /*shapeType*/,
    164                                                                                                                           void* userPtr,
    165                                                                                                                           short int collisionFilterGroup,
    166                                                                                                                           short int collisionFilterMask,
    167                                                                                                                           btDispatcher* /*dispatcher*/,
    168                                                                                                                           void* /*multiSapProxy*/)
    169 {
    170         btDbvtProxy*            proxy=new(btAlignedAlloc(sizeof(btDbvtProxy),16)) btDbvtProxy(  aabbMin,aabbMax,userPtr,
    171                 collisionFilterGroup,
    172                 collisionFilterMask);
    173 
    174         btDbvtAabbMm aabb = btDbvtVolume::FromMM(aabbMin,aabbMax);
    175 
    176         //bproxy->aabb                  =       btDbvtVolume::FromMM(aabbMin,aabbMax);
    177         proxy->stage            =       m_stageCurrent;
    178         proxy->m_uniqueId       =       ++m_gid;
    179         proxy->leaf                     =       m_sets[0].insert(aabb,proxy);
    180         listappend(proxy,m_stageRoots[m_stageCurrent]);
    181         if(!m_deferedcollide)
    182         {
    183                 btDbvtTreeCollider      collider(this);
    184                 collider.proxy=proxy;
    185                 btDbvt::collideTV(m_sets[0].m_root,aabb,collider);
    186                 btDbvt::collideTV(m_sets[1].m_root,aabb,collider);
    187         }
    188         return(proxy);
     162                                                                                                                                const btVector3& aabbMax,
     163                                                                                                                                int /*shapeType*/,
     164                                                                                                                                void* userPtr,
     165                                                                                                                                short int collisionFilterGroup,
     166                                                                                                                                short int collisionFilterMask,
     167                                                                                                                                btDispatcher* /*dispatcher*/,
     168                                                                                                                                void* /*multiSapProxy*/)
     169{
     170btDbvtProxy*            proxy=new(btAlignedAlloc(sizeof(btDbvtProxy),16)) btDbvtProxy(  userPtr,
     171                                                                                                                                                                        collisionFilterGroup,
     172                                                                                                                                                                        collisionFilterMask);
     173proxy->aabb                     =       btDbvtVolume::FromMM(aabbMin,aabbMax);
     174proxy->stage            =       m_stageCurrent;
     175proxy->m_uniqueId       =       ++m_gid;
     176proxy->leaf                     =       m_sets[0].insert(proxy->aabb,proxy);
     177listappend(proxy,m_stageRoots[m_stageCurrent]);
     178if(!m_deferedcollide)
     179        {
     180        btDbvtTreeCollider      collider(this);
     181        collider.proxy=proxy;
     182        btDbvt::collideTV(m_sets[0].m_root,proxy->aabb,collider);
     183        btDbvt::collideTV(m_sets[1].m_root,proxy->aabb,collider);
     184        }
     185return(proxy);
    189186}
    190187
    191188//
    192189void                                                    btDbvtBroadphase::destroyProxy( btBroadphaseProxy* absproxy,
    193                                                                                                                            btDispatcher* dispatcher)
    194 {
    195         btDbvtProxy*    proxy=(btDbvtProxy*)absproxy;
     190                                                                                                                                btDispatcher* dispatcher)
     191{
     192btDbvtProxy*    proxy=(btDbvtProxy*)absproxy;
     193if(proxy->stage==STAGECOUNT)
     194        m_sets[1].remove(proxy->leaf);
     195        else
     196        m_sets[0].remove(proxy->leaf);
     197listremove(proxy,m_stageRoots[proxy->stage]);
     198m_paircache->removeOverlappingPairsContainingProxy(proxy,dispatcher);
     199btAlignedFree(proxy);
     200m_needcleanup=true;
     201}
     202
     203//
     204void                                                    btDbvtBroadphase::setAabb(              btBroadphaseProxy* absproxy,
     205                                                                                                                                const btVector3& aabbMin,
     206                                                                                                                                const btVector3& aabbMax,
     207                                                                                                                                btDispatcher* /*dispatcher*/)
     208{
     209btDbvtProxy*                                            proxy=(btDbvtProxy*)absproxy;
     210ATTRIBUTE_ALIGNED16(btDbvtVolume)       aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
     211#if DBVT_BP_PREVENTFALSEUPDATE
     212if(NotEqual(aabb,proxy->leaf->volume))
     213#endif
     214        {
     215        bool    docollide=false;
    196216        if(proxy->stage==STAGECOUNT)
     217                {/* fixed -> dynamic set        */
    197218                m_sets[1].remove(proxy->leaf);
    198         else
    199                 m_sets[0].remove(proxy->leaf);
    200         listremove(proxy,m_stageRoots[proxy->stage]);
    201         m_paircache->removeOverlappingPairsContainingProxy(proxy,dispatcher);
    202         btAlignedFree(proxy);
    203         m_needcleanup=true;
    204 }
    205 
    206 void    btDbvtBroadphase::getAabb(btBroadphaseProxy* absproxy,btVector3& aabbMin, btVector3& aabbMax ) const
    207 {
    208         btDbvtProxy*                                            proxy=(btDbvtProxy*)absproxy;
    209         aabbMin = proxy->m_aabbMin;
    210         aabbMax = proxy->m_aabbMax;
    211 }
    212 
    213 void    btDbvtBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback)
    214 {
    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 
    230         BroadphaseRayTester callback(rayCallback);
    231 
    232         m_sets[0].rayTest(      m_sets[0].m_root,
    233                 rayFrom,
    234                 rayTo,
    235                 callback);
    236 
    237         m_sets[1].rayTest(      m_sets[1].m_root,
    238                 rayFrom,
    239                 rayTo,
    240                 callback);
    241 
    242 }
    243 
    244 //
    245 void                                                    btDbvtBroadphase::setAabb(              btBroadphaseProxy* absproxy,
    246                                                                                                                   const btVector3& aabbMin,
    247                                                                                                                   const btVector3& aabbMax,
    248                                                                                                                   btDispatcher* /*dispatcher*/)
    249 {
    250         btDbvtProxy*                                            proxy=(btDbvtProxy*)absproxy;
    251         ATTRIBUTE_ALIGNED16(btDbvtVolume)       aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
    252 #if DBVT_BP_PREVENTFALSEUPDATE
    253         if(NotEqual(aabb,proxy->leaf->volume))
    254 #endif
    255         {
    256                 bool    docollide=false;
    257                 if(proxy->stage==STAGECOUNT)
    258                 {/* fixed -> dynamic set        */
    259                         m_sets[1].remove(proxy->leaf);
    260                         proxy->leaf=m_sets[0].insert(aabb,proxy);
    261                         docollide=true;
     219                proxy->leaf=m_sets[0].insert(aabb,proxy);
     220                docollide=true;
    262221                }
    263222                else
    264223                {/* dynamic set                         */
    265                         ++m_updates_call;
    266                         if(Intersect(proxy->leaf->volume,aabb))
     224                ++m_updates_call;
     225                if(Intersect(proxy->leaf->volume,aabb))
    267226                        {/* Moving                              */
    268 
    269                                 const btVector3 delta=aabbMin-proxy->m_aabbMin;
    270                                 btVector3               velocity(((proxy->m_aabbMax-proxy->m_aabbMin)/2)*m_prediction);
    271                                 if(delta[0]<0) velocity[0]=-velocity[0];
    272                                 if(delta[1]<0) velocity[1]=-velocity[1];
    273                                 if(delta[2]<0) velocity[2]=-velocity[2];
    274                                 if      (
    275 #ifdef DBVT_BP_MARGIN                           
    276                                         m_sets[0].update(proxy->leaf,aabb,velocity,DBVT_BP_MARGIN)
    277 #else
    278                                         m_sets[0].update(proxy->leaf,aabb,velocity)
    279 #endif
    280                                         )
     227                        const btVector3 delta=aabbMin-proxy->aabb.Mins();
     228                        btVector3               velocity(aabb.Extents()*m_prediction);
     229                        if(delta[0]<0) velocity[0]=-velocity[0];
     230                        if(delta[1]<0) velocity[1]=-velocity[1];
     231                        if(delta[2]<0) velocity[2]=-velocity[2];
     232                        if      (
     233                                #ifdef DBVT_BP_MARGIN                           
     234                                m_sets[0].update(proxy->leaf,aabb,velocity,DBVT_BP_MARGIN)
     235                                #else
     236                                m_sets[0].update(proxy->leaf,aabb,velocity)
     237                                #endif
     238                                )
    281239                                {
    282                                         ++m_updates_done;
    283                                         docollide=true;
     240                                ++m_updates_done;
     241                                docollide=true;
    284242                                }
    285243                        }
    286244                        else
    287245                        {/* Teleporting                 */
    288                                 m_sets[0].update(proxy->leaf,aabb);
    289                                 ++m_updates_done;
    290                                 docollide=true;
     246                        m_sets[0].update(proxy->leaf,aabb);
     247                        ++m_updates_done;
     248                        docollide=true;
    291249                        }       
    292250                }
    293                 listremove(proxy,m_stageRoots[proxy->stage]);
    294                 proxy->m_aabbMin = aabbMin;
    295                 proxy->m_aabbMax = aabbMax;
    296                 proxy->stage    =       m_stageCurrent;
    297                 listappend(proxy,m_stageRoots[m_stageCurrent]);
    298                 if(docollide)
    299                 {
    300                         m_needcleanup=true;
    301                         if(!m_deferedcollide)
     251        listremove(proxy,m_stageRoots[proxy->stage]);
     252        proxy->aabb             =       aabb;
     253        proxy->stage    =       m_stageCurrent;
     254        listappend(proxy,m_stageRoots[m_stageCurrent]);
     255        if(docollide)
     256                {
     257                m_needcleanup=true;
     258                if(!m_deferedcollide)
    302259                        {
    303                                 btDbvtTreeCollider      collider(this);
    304                                 btDbvt::collideTT(m_sets[1].m_root,proxy->leaf,collider);
    305                                 btDbvt::collideTT(m_sets[0].m_root,proxy->leaf,collider);
     260                        btDbvtTreeCollider      collider(this);
     261                        btDbvt::collideTT(m_sets[1].m_root,proxy->leaf,collider);
     262                        btDbvt::collideTT(m_sets[0].m_root,proxy->leaf,collider);
    306263                        }
    307264                }       
    … …  
    312269void                                                    btDbvtBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
    313270{
    314         collide(dispatcher);
     271collide(dispatcher);
    315272#if DBVT_BP_PROFILE
    316         if(0==(m_pid%DBVT_BP_PROFILING_RATE))
     273if(0==(m_pid%DBVT_BP_PROFILING_RATE))
    317274        {       
    318                 printf("fixed(%u) dynamics(%u) pairs(%u)\r\n",m_sets[1].m_leaves,m_sets[0].m_leaves,m_paircache->getNumOverlappingPairs());
    319                 unsigned int    total=m_profiling.m_total;
    320                 if(total<=0) total=1;
    321                 printf("ddcollide: %u%% (%uus)\r\n",(50+m_profiling.m_ddcollide*100)/total,m_profiling.m_ddcollide/DBVT_BP_PROFILING_RATE);
    322                 printf("fdcollide: %u%% (%uus)\r\n",(50+m_profiling.m_fdcollide*100)/total,m_profiling.m_fdcollide/DBVT_BP_PROFILING_RATE);
    323                 printf("cleanup:   %u%% (%uus)\r\n",(50+m_profiling.m_cleanup*100)/total,m_profiling.m_cleanup/DBVT_BP_PROFILING_RATE);
    324                 printf("total:     %uus\r\n",total/DBVT_BP_PROFILING_RATE);
    325                 const unsigned long     sum=m_profiling.m_ddcollide+
    326                         m_profiling.m_fdcollide+
    327                         m_profiling.m_cleanup;
    328                 printf("leaked: %u%% (%uus)\r\n",100-((50+sum*100)/total),(total-sum)/DBVT_BP_PROFILING_RATE);
    329                 printf("job counts: %u%%\r\n",(m_profiling.m_jobcount*100)/((m_sets[0].m_leaves+m_sets[1].m_leaves)*DBVT_BP_PROFILING_RATE));
    330                 clear(m_profiling);
    331                 m_clock.reset();
     275        printf("fixed(%u) dynamics(%u) pairs(%u)\r\n",m_sets[1].m_leaves,m_sets[0].m_leaves,m_paircache->getNumOverlappingPairs());
     276        unsigned int    total=m_profiling.m_total;
     277        if(total<=0) total=1;
     278        printf("ddcollide: %u%% (%uus)\r\n",(50+m_profiling.m_ddcollide*100)/total,m_profiling.m_ddcollide/DBVT_BP_PROFILING_RATE);
     279        printf("fdcollide: %u%% (%uus)\r\n",(50+m_profiling.m_fdcollide*100)/total,m_profiling.m_fdcollide/DBVT_BP_PROFILING_RATE);
     280        printf("cleanup:   %u%% (%uus)\r\n",(50+m_profiling.m_cleanup*100)/total,m_profiling.m_cleanup/DBVT_BP_PROFILING_RATE);
     281        printf("total:     %uus\r\n",total/DBVT_BP_PROFILING_RATE);
     282        const unsigned long     sum=m_profiling.m_ddcollide+
     283                                                        m_profiling.m_fdcollide+
     284                                                        m_profiling.m_cleanup;
     285        printf("leaked: %u%% (%uus)\r\n",100-((50+sum*100)/total),(total-sum)/DBVT_BP_PROFILING_RATE);
     286        printf("job counts: %u%%\r\n",(m_profiling.m_jobcount*100)/((m_sets[0].m_leaves+m_sets[1].m_leaves)*DBVT_BP_PROFILING_RATE));
     287        clear(m_profiling);
     288        m_clock.reset();
    332289        }
    333290#endif
    … …  
    337294void                                                    btDbvtBroadphase::collide(btDispatcher* dispatcher)
    338295{
    339         SPC(m_profiling.m_total);
    340         /* optimize                             */
    341         m_sets[0].optimizeIncremental(1+(m_sets[0].m_leaves*m_dupdates)/100);
    342         if(m_fixedleft)
    343         {
    344                 const int count=1+(m_sets[1].m_leaves*m_fupdates)/100;
    345                 m_sets[1].optimizeIncremental(1+(m_sets[1].m_leaves*m_fupdates)/100);
    346                 m_fixedleft=btMax<int>(0,m_fixedleft-count);
    347         }
    348         /* dynamic -> fixed set */
    349         m_stageCurrent=(m_stageCurrent+1)%STAGECOUNT;
    350         btDbvtProxy*    current=m_stageRoots[m_stageCurrent];
    351         if(current)
    352         {
    353                 btDbvtTreeCollider      collider(this);
    354                 do      {
    355                         btDbvtProxy*    next=current->links[1];
    356                         listremove(current,m_stageRoots[current->stage]);
    357                         listappend(current,m_stageRoots[STAGECOUNT]);
    358 #if DBVT_BP_ACCURATESLEEPING
    359                         m_paircache->removeOverlappingPairsContainingProxy(current,dispatcher);
    360                         collider.proxy=current;
    361                         btDbvt::collideTV(m_sets[0].m_root,current->aabb,collider);
    362                         btDbvt::collideTV(m_sets[1].m_root,current->aabb,collider);
    363 #endif
    364                         m_sets[0].remove(current->leaf);
    365                         ATTRIBUTE_ALIGNED16(btDbvtVolume)       curAabb=btDbvtVolume::FromMM(current->m_aabbMin,current->m_aabbMax);
    366                         current->leaf   =       m_sets[1].insert(curAabb,current);
    367                         current->stage  =       STAGECOUNT;     
    368                         current                 =       next;
     296SPC(m_profiling.m_total);
     297/* optimize                             */
     298m_sets[0].optimizeIncremental(1+(m_sets[0].m_leaves*m_dupdates)/100);
     299if(m_fixedleft)
     300        {
     301        const int count=1+(m_sets[1].m_leaves*m_fupdates)/100;
     302        m_sets[1].optimizeIncremental(1+(m_sets[1].m_leaves*m_fupdates)/100);
     303        m_fixedleft=btMax<int>(0,m_fixedleft-count);
     304        }
     305/* dynamic -> fixed set */
     306m_stageCurrent=(m_stageCurrent+1)%STAGECOUNT;
     307btDbvtProxy*    current=m_stageRoots[m_stageCurrent];
     308if(current)
     309        {
     310        btDbvtTreeCollider      collider(this);
     311        do      {
     312                btDbvtProxy*    next=current->links[1];
     313                listremove(current,m_stageRoots[current->stage]);
     314                listappend(current,m_stageRoots[STAGECOUNT]);
     315                #if DBVT_BP_ACCURATESLEEPING
     316                m_paircache->removeOverlappingPairsContainingProxy(current,dispatcher);
     317                collider.proxy=current;
     318                btDbvt::collideTV(m_sets[0].m_root,current->aabb,collider);
     319                btDbvt::collideTV(m_sets[1].m_root,current->aabb,collider);
     320                #endif
     321                m_sets[0].remove(current->leaf);
     322                current->leaf   =       m_sets[1].insert(current->aabb,current);
     323                current->stage  =       STAGECOUNT;     
     324                current                 =       next;
    369325                } while(current);
    370                 m_fixedleft=m_sets[1].m_leaves;
    371                 m_needcleanup=true;
    372         }
    373         /* collide dynamics             */
    374         {
    375                 btDbvtTreeCollider      collider(this);
    376                 if(m_deferedcollide)
    377                 {
    378                         SPC(m_profiling.m_fdcollide);
    379                         btDbvt::collideTT(m_sets[0].m_root,m_sets[1].m_root,collider);
    380                 }
    381                 if(m_deferedcollide)
    382                 {
    383                         SPC(m_profiling.m_ddcollide);
    384                         btDbvt::collideTT(m_sets[0].m_root,m_sets[0].m_root,collider);
    385                 }
    386         }
    387         /* clean up                             */
    388         if(m_needcleanup)
    389         {
    390                 SPC(m_profiling.m_cleanup);
    391                 btBroadphasePairArray&  pairs=m_paircache->getOverlappingPairArray();
    392                 if(pairs.size()>0)
    393                 {
    394                         const int       ci=pairs.size();
    395                         int                     ni=btMin(ci,btMax<int>(m_newpairs,(ci*m_cupdates)/100));
    396                         for(int i=0;i<ni;++i)
     326        m_fixedleft=m_sets[1].m_leaves;
     327        m_needcleanup=true;
     328        }
     329/* collide dynamics             */
     330        {
     331        btDbvtTreeCollider      collider(this);
     332        if(m_deferedcollide)
     333                {
     334                SPC(m_profiling.m_fdcollide);
     335                btDbvt::collideTT(m_sets[0].m_root,m_sets[1].m_root,collider);
     336                }
     337        if(m_deferedcollide)
     338                {
     339                SPC(m_profiling.m_ddcollide);
     340                btDbvt::collideTT(m_sets[0].m_root,m_sets[0].m_root,collider);
     341                }
     342        }
     343/* clean up                             */
     344if(m_needcleanup)
     345        {
     346        SPC(m_profiling.m_cleanup);
     347        btBroadphasePairArray&  pairs=m_paircache->getOverlappingPairArray();
     348        if(pairs.size()>0)
     349                {
     350                const int       ci=pairs.size();
     351                int                     ni=btMin(ci,btMax<int>(m_newpairs,(ci*m_cupdates)/100));
     352                for(int i=0;i<ni;++i)
    397353                        {
    398                                 btBroadphasePair&       p=pairs[(m_cid+i)%ci];
    399                                 btDbvtProxy*            pa=(btDbvtProxy*)p.m_pProxy0;
    400                                 btDbvtProxy*            pb=(btDbvtProxy*)p.m_pProxy1;
    401                                 if(!Intersect(pa->leaf->volume,pb->leaf->volume))
     354                        btBroadphasePair&       p=pairs[(m_cid+i)%ci];
     355                        btDbvtProxy*            pa=(btDbvtProxy*)p.m_pProxy0;
     356                        btDbvtProxy*            pb=(btDbvtProxy*)p.m_pProxy1;
     357                        if(!Intersect(pa->leaf->volume,pb->leaf->volume))
    402358                                {
    403 #if DBVT_BP_SORTPAIRS
    404                                         if(pa>pb) btSwap(pa,pb);
    405 #endif
    406                                         m_paircache->removeOverlappingPair(pa,pb,dispatcher);
    407                                         --ni;--i;
     359                                #if DBVT_BP_SORTPAIRS
     360                                if(pa>pb) btSwap(pa,pb);
     361                                #endif
     362                                m_paircache->removeOverlappingPair(pa,pb,dispatcher);
     363                                --ni;--i;
    408364                                }
    409365                        }
    410                         if(pairs.size()>0) m_cid=(m_cid+ni)%pairs.size(); else m_cid=0;
    411                 }
    412         }
    413         ++m_pid;
    414         m_newpairs=1;
    415         m_needcleanup=false;
    416         if(m_updates_call>0)
     366                if(pairs.size()>0) m_cid=(m_cid+ni)%pairs.size(); else m_cid=0;
     367                }
     368        }
     369++m_pid;
     370m_newpairs=1;
     371m_needcleanup=false;
     372if(m_updates_call>0)
    417373        { m_updates_ratio=m_updates_done/(btScalar)m_updates_call; }
    418374        else
    419375        { m_updates_ratio=0; }
    420         m_updates_done/=2;
    421         m_updates_call/=2;
     376m_updates_done/=2;
     377m_updates_call/=2;
    422378}
    423379
    … …  
    425381void                                                    btDbvtBroadphase::optimize()
    426382{
    427         m_sets[0].optimizeTopDown();
    428         m_sets[1].optimizeTopDown();
     383m_sets[0].optimizeTopDown();
     384m_sets[1].optimizeTopDown();
    429385}
    430386
    … …  
    432388btOverlappingPairCache*                 btDbvtBroadphase::getOverlappingPairCache()
    433389{
    434         return(m_paircache);
     390return(m_paircache);
    435391}
    436392
    … …  
    438394const btOverlappingPairCache*   btDbvtBroadphase::getOverlappingPairCache() const
    439395{
    440         return(m_paircache);
     396return(m_paircache);
    441397}
    442398
    … …  
    447403        ATTRIBUTE_ALIGNED16(btDbvtVolume)       bounds;
    448404
    449         if(!m_sets[0].empty())
    450                 if(!m_sets[1].empty())  Merge(  m_sets[0].m_root->volume,
    451                         m_sets[1].m_root->volume,bounds);
    452                 else
    453                         bounds=m_sets[0].m_root->volume;
    454         else if(!m_sets[1].empty())     bounds=m_sets[1].m_root->volume;
    455         else
    456                 bounds=btDbvtVolume::FromCR(btVector3(0,0,0),0);
    457         aabbMin=bounds.Mins();
    458         aabbMax=bounds.Maxs();
     405if(!m_sets[0].empty())
     406        if(!m_sets[1].empty())  Merge(  m_sets[0].m_root->volume,
     407                                                                        m_sets[1].m_root->volume,bounds);
     408                                                        else
     409                                                        bounds=m_sets[0].m_root->volume;
     410else if(!m_sets[1].empty())     bounds=m_sets[1].m_root->volume;
     411                                                        else
     412                                                        bounds=btDbvtVolume::FromCR(btVector3(0,0,0),0);
     413aabbMin=bounds.Mins();
     414aabbMax=bounds.Maxs();
    459415}
    460416
    … …  
    467423
    468424struct  btBroadphaseBenchmark
    469 {
     425        {
    470426        struct  Experiment
    471         {
     427                {
    472428                const char*                     name;
    473429                int                                     object_count;
    … …  
    477433                btScalar                        speed;
    478434                btScalar                        amplitude;
    479         };
     435                };
    480436        struct  Object
    481         {
     437                {
    482438                btVector3                       center;
    483439                btVector3                       extents;
    … …  
    485441                btScalar                        time;
    486442                void                            update(btScalar speed,btScalar amplitude,btBroadphaseInterface* pbi)
    487                 {
     443                        {
    488444                        time            +=      speed;
    489445                        center[0]       =       btCos(time*(btScalar)2.17)*amplitude+
    490                                 btSin(time)*amplitude/2;
     446                                                        btSin(time)*amplitude/2;
    491447                        center[1]       =       btCos(time*(btScalar)1.38)*amplitude+
    492                                 btSin(time)*amplitude;
     448                                                        btSin(time)*amplitude;
    493449                        center[2]       =       btSin(time*(btScalar)0.777)*amplitude;
    494450                        pbi->setAabb(proxy,center-extents,center+extents,0);
    495                 }
    496         };
     451                        }
     452                };
    497453        static int              UnsignedRand(int range=RAND_MAX-1)      { return(rand()%(range+1)); }
    498454        static btScalar UnitRand()                                                      { return(UnsignedRand(16384)/(btScalar)16384); }
    499455        static void             OutputTime(const char* name,btClock& c,unsigned count=0)
    500         {
     456                {
    501457                const unsigned long     us=c.getTimeMicroseconds();
    502458                const unsigned long     ms=(us+500)/1000;
    … …  
    504460                if(count>0)
    505461                        printf("%s : %u us (%u ms), %.2f/s\r\n",name,us,ms,count/sec);
    506                 else
     462                        else
    507463                        printf("%s : %u us (%u ms)\r\n",name,us,ms);
    508         }
    509 };
     464                }
     465        };
    510466
    511467void                                                    btDbvtBroadphase::benchmark(btBroadphaseInterface* pbi)
    512468{
    513         static const btBroadphaseBenchmark::Experiment          experiments[]=
    514         {
    515                 {"1024o.10%",1024,10,0,8192,(btScalar)0.005,(btScalar)100},
    516                 /*{"4096o.10%",4096,10,0,8192,(btScalar)0.005,(btScalar)100},
    517                 {"8192o.10%",8192,10,0,8192,(btScalar)0.005,(btScalar)100},*/
     469static const btBroadphaseBenchmark::Experiment          experiments[]=
     470        {
     471        {"1024o.10%",1024,10,0,8192,(btScalar)0.005,(btScalar)100},
     472        /*{"4096o.10%",4096,10,0,8192,(btScalar)0.005,(btScalar)100},
     473        {"8192o.10%",8192,10,0,8192,(btScalar)0.005,(btScalar)100},*/
    518474        };
    519         static const int                                                                                nexperiments=sizeof(experiments)/sizeof(experiments[0]);
    520         btAlignedObjectArray<btBroadphaseBenchmark::Object*>    objects;
    521         btClock                                                                                                 wallclock;
    522         /* Begin                        */
    523         for(int iexp=0;iexp<nexperiments;++iexp)
    524         {
    525                 const btBroadphaseBenchmark::Experiment&        experiment=experiments[iexp];
    526                 const int                                                                       object_count=experiment.object_count;
    527                 const int                                                                       update_count=(object_count*experiment.update_count)/100;
    528                 const int                                                                       spawn_count=(object_count*experiment.spawn_count)/100;
    529                 const btScalar                                                          speed=experiment.speed;
    530                 const btScalar                                                          amplitude=experiment.amplitude;
    531                 printf("Experiment #%u '%s':\r\n",iexp,experiment.name);
    532                 printf("\tObjects: %u\r\n",object_count);
    533                 printf("\tUpdate: %u\r\n",update_count);
    534                 printf("\tSpawn: %u\r\n",spawn_count);
    535                 printf("\tSpeed: %f\r\n",speed);
    536                 printf("\tAmplitude: %f\r\n",amplitude);
    537                 srand(180673);
    538                 /* Create objects       */
    539                 wallclock.reset();
    540                 objects.reserve(object_count);
    541                 for(int i=0;i<object_count;++i)
    542                 {
    543                         btBroadphaseBenchmark::Object*  po=new btBroadphaseBenchmark::Object();
    544                         po->center[0]=btBroadphaseBenchmark::UnitRand()*50;
    545                         po->center[1]=btBroadphaseBenchmark::UnitRand()*50;
    546                         po->center[2]=btBroadphaseBenchmark::UnitRand()*50;
    547                         po->extents[0]=btBroadphaseBenchmark::UnitRand()*2+2;
    548                         po->extents[1]=btBroadphaseBenchmark::UnitRand()*2+2;
    549                         po->extents[2]=btBroadphaseBenchmark::UnitRand()*2+2;
    550                         po->time=btBroadphaseBenchmark::UnitRand()*2000;
    551                         po->proxy=pbi->createProxy(po->center-po->extents,po->center+po->extents,0,po,1,1,0,0);
    552                         objects.push_back(po);
    553                 }
    554                 btBroadphaseBenchmark::OutputTime("\tInitialization",wallclock);
    555                 /* First update         */
    556                 wallclock.reset();
    557                 for(int i=0;i<objects.size();++i)
    558                 {
    559                         objects[i]->update(speed,amplitude,pbi);
    560                 }
    561                 btBroadphaseBenchmark::OutputTime("\tFirst update",wallclock);
    562                 /* Updates                      */
    563                 wallclock.reset();
    564                 for(int i=0;i<experiment.iterations;++i)
    565                 {
    566                         for(int j=0;j<update_count;++j)
     475static const int                                                                                nexperiments=sizeof(experiments)/sizeof(experiments[0]);
     476btAlignedObjectArray<btBroadphaseBenchmark::Object*>    objects;
     477btClock                                                                                                 wallclock;
     478/* Begin                        */
     479for(int iexp=0;iexp<nexperiments;++iexp)
     480        {
     481        const btBroadphaseBenchmark::Experiment&        experiment=experiments[iexp];
     482        const int                                                                       object_count=experiment.object_count;
     483        const int                                                                       update_count=(object_count*experiment.update_count)/100;
     484        const int                                                                       spawn_count=(object_count*experiment.spawn_count)/100;
     485        const btScalar                                                          speed=experiment.speed;
     486        const btScalar                                                          amplitude=experiment.amplitude;
     487        printf("Experiment #%u '%s':\r\n",iexp,experiment.name);
     488        printf("\tObjects: %u\r\n",object_count);
     489        printf("\tUpdate: %u\r\n",update_count);
     490        printf("\tSpawn: %u\r\n",spawn_count);
     491        printf("\tSpeed: %f\r\n",speed);
     492        printf("\tAmplitude: %f\r\n",amplitude);
     493        srand(180673);
     494        /* Create objects       */
     495        wallclock.reset();
     496        objects.reserve(object_count);
     497        for(int i=0;i<object_count;++i)
     498                {
     499                btBroadphaseBenchmark::Object*  po=new btBroadphaseBenchmark::Object();
     500                po->center[0]=btBroadphaseBenchmark::UnitRand()*50;
     501                po->center[1]=btBroadphaseBenchmark::UnitRand()*50;
     502                po->center[2]=btBroadphaseBenchmark::UnitRand()*50;
     503                po->extents[0]=btBroadphaseBenchmark::UnitRand()*2+2;
     504                po->extents[1]=btBroadphaseBenchmark::UnitRand()*2+2;
     505                po->extents[2]=btBroadphaseBenchmark::UnitRand()*2+2;
     506                po->time=btBroadphaseBenchmark::UnitRand()*2000;
     507                po->proxy=pbi->createProxy(po->center-po->extents,po->center+po->extents,0,po,1,1,0,0);
     508                objects.push_back(po);
     509                }
     510        btBroadphaseBenchmark::OutputTime("\tInitialization",wallclock);
     511        /* First update         */
     512        wallclock.reset();
     513        for(int i=0;i<objects.size();++i)
     514                {
     515                objects[i]->update(speed,amplitude,pbi);
     516                }
     517        btBroadphaseBenchmark::OutputTime("\tFirst update",wallclock);
     518        /* Updates                      */
     519        wallclock.reset();
     520        for(int i=0;i<experiment.iterations;++i)
     521                {
     522                for(int j=0;j<update_count;++j)
    567523                        {                               
    568                                 objects[j]->update(speed,amplitude,pbi);
     524                        objects[j]->update(speed,amplitude,pbi);
    569525                        }
    570                         pbi->calculateOverlappingPairs(0);
    571                 }
    572                 btBroadphaseBenchmark::OutputTime("\tUpdate",wallclock,experiment.iterations);
    573                 /* Clean up                     */
    574                 wallclock.reset();
    575                 for(int i=0;i<objects.size();++i)
    576                 {
    577                         pbi->destroyProxy(objects[i]->proxy,0);
    578                         delete objects[i];
    579                 }
    580                 objects.resize(0);
    581                 btBroadphaseBenchmark::OutputTime("\tRelease",wallclock);
     526                pbi->calculateOverlappingPairs(0);
     527                }
     528        btBroadphaseBenchmark::OutputTime("\tUpdate",wallclock,experiment.iterations);
     529        /* Clean up                     */
     530        wallclock.reset();
     531        for(int i=0;i<objects.size();++i)
     532                {
     533                pbi->destroyProxy(objects[i]->proxy,0);
     534                delete objects[i];
     535                }
     536        objects.resize(0);
     537        btBroadphaseBenchmark::OutputTime("\tRelease",wallclock);
    582538        }
    583539
Note: See TracChangeset for help on using the changeset viewer.