40 #if (DBVT_MERGE_IMPL==DBVT_IMPL_SSE)    55         return( edges.
x()*edges.
y()*edges.
z()+
    56                 edges.
x()+edges.
y()+edges.
z());
    66         } 
else maxdepth=
btMax(maxdepth,depth);
   162                         } 
while(0!=(prev=node->
parent));
   201                         return(prev?prev:pdbvt->
m_root);
   240         for(
int i=0,ni=leaves.
size();i<ni;++i)
   242                 if(
btDot(axis,leaves[i]->volume.Center()-org)<0)
   252 #if DBVT_MERGE_IMPL==DBVT_IMPL_SSE   256         volume=leaves[0]->volume;
   260         for(
int i=1,ni=leaves.
size();i<ni;++i)
   262                 Merge(volume,leaves[i]->volume,volume);
   271         while(leaves.
size()>1)
   274                 int                     minidx[2]={-1,-1};
   275                 for(
int i=0;i<leaves.
size();++i)
   277                         for(
int j=i+1;j<leaves.
size();++j)
   288                 btDbvtNode*     n[]     =       {leaves[minidx[0]],leaves[minidx[1]]};
   294                 leaves[minidx[0]]       =       p;
   295                 leaves.
swap(minidx[1],leaves.
size()-1);
   310                 if(leaves.
size()>bu_treshold)
   316                         int                                             bestmidp=leaves.
size();
   317                         int                                             splitcount[3][2]={{0,0},{0,0},{0,0}};
   319                         for( i=0;i<leaves.
size();++i)
   321                                 const btVector3 x=leaves[i]->volume.Center()-org;
   324                                         ++splitcount[j][
btDot(x,axis[j])>0?1:0];
   329                                 if((splitcount[i][0]>0)&&(splitcount[i][1]>0))
   331                                         const int       midp=(int)
btFabs(
btScalar(splitcount[i][0]-splitcount[i][1]));
   341                                 sets[0].
reserve(splitcount[bestaxis][0]);
   342                                 sets[1].
reserve(splitcount[bestaxis][1]);
   343                                 split(leaves,sets[0],sets[1],org,axis[bestaxis]);
   349                                 for(
int i=0,ni=leaves.
size();i<ni;++i)
   401         while(n&&(count--)) n=n->
parent;
   460                 m_root=
topdown(
this,leaves,bu_treshold);
   467         if(passes<0) passes=m_leaves;
   468         if(m_root&&(passes>0))
   475                                 node=
sort(node,m_root)->
childs[(m_opath>>bit)&1];
   476                                 bit=(bit+1)&(
sizeof(
unsigned)*8-1);
   501                         for(
int i=0;(i<lookahead)&&root->
parent;++i)
   518                         for(
int i=0;(i<m_lkhd)&&root->
parent;++i)
   569         enumNodes(m_root,nodes);
   599                         const int               i=stack.
size()-1;
   616                 } 
while(stack.
size()>0);
   632                 return(countLeaves(node->
childs[0])+countLeaves(node->
childs[1]));
   642                 extractLeaves(node->
childs[0],leaves);
   643                 extractLeaves(node->
childs[1],leaves);
   652 #if DBVT_ENABLE_BENCHMARK   656 #include "LinearMath/btQuickProf.h"   693 struct btDbvtBenchmark
   697                 NilPolicy() : m_pcount(0),m_depth(-
SIMD_INFINITY),m_checksort(
true)             {}
   704                         { 
if(depth>=m_depth) m_depth=depth; 
else printf(
"wrong depth: %f (should be >= %f)\r\n",depth,m_depth); }
   723                 static int sortfnc(
const Node& a,
const Node& b)
   725                         if(a.depth<b.depth) 
return(+1);
   726                         if(a.depth>b.depth) 
return(-1);
   744                 static int sortfnc(
const Node& a,
const Node& b)
   746                         if(a.depth<b.depth) 
return(+1);
   747                         if(a.depth>b.depth) 
return(-1);
   759                 return(
btVector3(RandUnit(),RandUnit(),RandUnit()));
   763                 return(RandVector3()*cs-
btVector3(cs,cs,cs)/2);
   779                 for(
int i=0;i<leaves;++i)
   781                         dbvt.
insert(RandVolume(cs,eb,es),0);
   788         static const btScalar   cfgVolumeCenterScale            =       100;
   789         static const btScalar   cfgVolumeExentsBase                     =       1;
   790         static const btScalar   cfgVolumeExentsScale            =       4;
   791         static const int                cfgLeaves                                       =       8192;
   792         static const bool               cfgEnable                                       =       
true;
   795         bool                                    cfgBenchmark1_Enable            =       cfgEnable;
   796         static const int                cfgBenchmark1_Iterations        =       8;
   797         static const int                cfgBenchmark1_Reference         =       3499;
   799         bool                                    cfgBenchmark2_Enable            =       cfgEnable;
   800         static const int                cfgBenchmark2_Iterations        =       4;
   801         static const int                cfgBenchmark2_Reference         =       1945;
   803         bool                                    cfgBenchmark3_Enable            =       cfgEnable;
   804         static const int                cfgBenchmark3_Iterations        =       512;
   805         static const int                cfgBenchmark3_Reference         =       5485;
   807         bool                                    cfgBenchmark4_Enable            =       cfgEnable;
   808         static const int                cfgBenchmark4_Iterations        =       512;
   809         static const int                cfgBenchmark4_Reference         =       2814;
   811         bool                                    cfgBenchmark5_Enable            =       cfgEnable;
   812         static const int                cfgBenchmark5_Iterations        =       512;
   813         static const btScalar   cfgBenchmark5_OffsetScale       =       2;
   814         static const int                cfgBenchmark5_Reference         =       7379;
   816         bool                                    cfgBenchmark6_Enable            =       cfgEnable;
   817         static const int                cfgBenchmark6_Iterations        =       512;
   818         static const btScalar   cfgBenchmark6_OffsetScale       =       2;
   819         static const int                cfgBenchmark6_Reference         =       7270;
   821         bool                                    cfgBenchmark7_Enable            =       cfgEnable;
   822         static const int                cfgBenchmark7_Passes            =       32;
   823         static const int                cfgBenchmark7_Iterations        =       65536;
   824         static const int                cfgBenchmark7_Reference         =       6307;
   826         bool                                    cfgBenchmark8_Enable            =       cfgEnable;
   827         static const int                cfgBenchmark8_Passes            =       32;
   828         static const int                cfgBenchmark8_Iterations        =       65536;
   829         static const int                cfgBenchmark8_Reference         =       2105;
   831         bool                                    cfgBenchmark9_Enable            =       cfgEnable;
   832         static const int                cfgBenchmark9_Passes            =       32;
   833         static const int                cfgBenchmark9_Iterations        =       65536;
   834         static const int                cfgBenchmark9_Reference         =       1879;
   836         bool                                    cfgBenchmark10_Enable           =       cfgEnable;
   837         static const btScalar   cfgBenchmark10_Scale            =       cfgVolumeCenterScale/10000;
   838         static const int                cfgBenchmark10_Passes           =       32;
   839         static const int                cfgBenchmark10_Iterations       =       65536;
   840         static const int                cfgBenchmark10_Reference        =       1244;
   842         bool                                    cfgBenchmark11_Enable           =       cfgEnable;
   843         static const int                cfgBenchmark11_Passes           =       64;
   844         static const int                cfgBenchmark11_Iterations       =       65536;
   845         static const int                cfgBenchmark11_Reference        =       2510;
   847         bool                                    cfgBenchmark12_Enable           =       cfgEnable;
   848         static const int                cfgBenchmark12_Iterations       =       32;
   849         static const int                cfgBenchmark12_Reference        =       3677;
   851         bool                                    cfgBenchmark13_Enable           =       cfgEnable;
   852         static const int                cfgBenchmark13_Iterations       =       1024;
   853         static const int                cfgBenchmark13_Reference        =       2231;
   855         bool                                    cfgBenchmark14_Enable           =       cfgEnable;
   856         static const int                cfgBenchmark14_Iterations       =       8192;
   857         static const int                cfgBenchmark14_Reference        =       3500;
   859         bool                                    cfgBenchmark15_Enable           =       cfgEnable;
   860         static const int                cfgBenchmark15_Iterations       =       8192;
   861         static const int                cfgBenchmark15_Reference        =       1151;
   863         bool                                    cfgBenchmark16_Enable           =       cfgEnable;
   864         static const int                cfgBenchmark16_BatchCount       =       256;
   865         static const int                cfgBenchmark16_Passes           =       16384;
   866         static const int                cfgBenchmark16_Reference        =       5138;
   868         bool                                    cfgBenchmark17_Enable           =       cfgEnable;
   869         static const int                cfgBenchmark17_Iterations       =       4;
   870         static const int                cfgBenchmark17_Reference        =       3390;
   873         printf(
"Benchmarking dbvt...\r\n");
   874         printf(
"\tWorld scale: %f\r\n",cfgVolumeCenterScale);
   875         printf(
"\tExtents base: %f\r\n",cfgVolumeExentsBase);
   876         printf(
"\tExtents range: %f\r\n",cfgVolumeExentsScale);
   877         printf(
"\tLeaves: %u\r\n",cfgLeaves);
   878         printf(
"\tsizeof(btDbvtVolume): %u bytes\r\n",
sizeof(
btDbvtVolume));
   879         printf(
"\tsizeof(btDbvtNode):   %u bytes\r\n",
sizeof(
btDbvtNode));
   880         if(cfgBenchmark1_Enable)
   885                 volumes.
resize(cfgLeaves);
   886                 results.
resize(cfgLeaves);
   887                 for(
int i=0;i<cfgLeaves;++i)
   889                         volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
   891                 printf(
"[1] btDbvtVolume intersections: ");
   893                 for(
int i=0;i<cfgBenchmark1_Iterations;++i)
   895                         for(
int j=0;j<cfgLeaves;++j)
   897                                 for(
int k=0;k<cfgLeaves;++k)
   899                                         results[k]=
Intersect(volumes[j],volumes[k]);
   904                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark1_Reference)*100/time);
   906         if(cfgBenchmark2_Enable)
   911                 volumes.
resize(cfgLeaves);
   912                 results.
resize(cfgLeaves);
   913                 for(
int i=0;i<cfgLeaves;++i)
   915                         volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
   917                 printf(
"[2] btDbvtVolume merges: ");
   919                 for(
int i=0;i<cfgBenchmark2_Iterations;++i)
   921                         for(
int j=0;j<cfgLeaves;++j)
   923                                 for(
int k=0;k<cfgLeaves;++k)
   925                                         Merge(volumes[j],volumes[k],results[k]);
   930                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark2_Reference)*100/time);
   932         if(cfgBenchmark3_Enable)
   936                 btDbvtBenchmark::NilPolicy      policy;
   937                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[0]);
   938                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[1]);
   941                 printf(
"[3] btDbvt::collideTT: ");
   943                 for(
int i=0;i<cfgBenchmark3_Iterations;++i)
   948                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark3_Reference)*100/time);
   950         if(cfgBenchmark4_Enable)
   954                 btDbvtBenchmark::NilPolicy      policy;
   955                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
   957                 printf(
"[4] btDbvt::collideTT self: ");
   959                 for(
int i=0;i<cfgBenchmark4_Iterations;++i)
   964                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark4_Reference)*100/time);
   966         if(cfgBenchmark5_Enable)
   971                 btDbvtBenchmark::NilPolicy                      policy;
   972                 transforms.
resize(cfgBenchmark5_Iterations);
   973                 for(
int i=0;i<transforms.
size();++i)
   975                         transforms[i]=btDbvtBenchmark::RandTransform(cfgVolumeCenterScale*cfgBenchmark5_OffsetScale);
   977                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[0]);
   978                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[1]);
   981                 printf(
"[5] btDbvt::collideTT xform: ");
   983                 for(
int i=0;i<cfgBenchmark5_Iterations;++i)
   988                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark5_Reference)*100/time);
   990         if(cfgBenchmark6_Enable)
   995                 btDbvtBenchmark::NilPolicy                      policy;
   996                 transforms.
resize(cfgBenchmark6_Iterations);
   997                 for(
int i=0;i<transforms.
size();++i)
   999                         transforms[i]=btDbvtBenchmark::RandTransform(cfgVolumeCenterScale*cfgBenchmark6_OffsetScale);
  1001                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1003                 printf(
"[6] btDbvt::collideTT xform,self: ");
  1005                 for(
int i=0;i<cfgBenchmark6_Iterations;++i)
  1010                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark6_Reference)*100/time);
  1012         if(cfgBenchmark7_Enable)
  1018                 btDbvtBenchmark::NilPolicy                      policy;
  1019                 rayorg.
resize(cfgBenchmark7_Iterations);
  1020                 raydir.
resize(cfgBenchmark7_Iterations);
  1021                 for(
int i=0;i<rayorg.
size();++i)
  1023                         rayorg[i]=btDbvtBenchmark::RandVector3(cfgVolumeCenterScale*2);
  1024                         raydir[i]=btDbvtBenchmark::RandVector3(cfgVolumeCenterScale*2);
  1026                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1028                 printf(
"[7] btDbvt::rayTest: ");
  1030                 for(
int i=0;i<cfgBenchmark7_Passes;++i)
  1032                         for(
int j=0;j<cfgBenchmark7_Iterations;++j)
  1038                 unsigned        rays=cfgBenchmark7_Passes*cfgBenchmark7_Iterations;
  1039                 printf(
"%u ms (%i%%),(%u r/s)\r\n",time,(time-cfgBenchmark7_Reference)*100/time,(rays*1000)/time);
  1041         if(cfgBenchmark8_Enable)
  1045                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1047                 printf(
"[8] insert/remove: ");
  1049                 for(
int i=0;i<cfgBenchmark8_Passes;++i)
  1051                         for(
int j=0;j<cfgBenchmark8_Iterations;++j)
  1053                                 dbvt.
remove(dbvt.
insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale),0));
  1057                 const int       ir=cfgBenchmark8_Passes*cfgBenchmark8_Iterations;
  1058                 printf(
"%u ms (%i%%),(%u ir/s)\r\n",time,(time-cfgBenchmark8_Reference)*100/time,ir*1000/time);
  1060         if(cfgBenchmark9_Enable)
  1065                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1068                 printf(
"[9] updates (teleport): ");
  1070                 for(
int i=0;i<cfgBenchmark9_Passes;++i)
  1072                         for(
int j=0;j<cfgBenchmark9_Iterations;++j)
  1074                                 dbvt.
update(const_cast<btDbvtNode*>(leaves[rand()%cfgLeaves]),
  1075                                         btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale));
  1079                 const int       up=cfgBenchmark9_Passes*cfgBenchmark9_Iterations;
  1080                 printf(
"%u ms (%i%%),(%u u/s)\r\n",time,(time-cfgBenchmark9_Reference)*100/time,up*1000/time);
  1082         if(cfgBenchmark10_Enable)
  1088                 vectors.
resize(cfgBenchmark10_Iterations);
  1089                 for(
int i=0;i<vectors.
size();++i)
  1091                         vectors[i]=(btDbvtBenchmark::RandVector3()*2-
btVector3(1,1,1))*cfgBenchmark10_Scale;
  1093                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1096                 printf(
"[10] updates (jitter): ");
  1099                 for(
int i=0;i<cfgBenchmark10_Passes;++i)
  1101                         for(
int j=0;j<cfgBenchmark10_Iterations;++j)
  1110                 const int       up=cfgBenchmark10_Passes*cfgBenchmark10_Iterations;
  1111                 printf(
"%u ms (%i%%),(%u u/s)\r\n",time,(time-cfgBenchmark10_Reference)*100/time,up*1000/time);
  1113         if(cfgBenchmark11_Enable)
  1117                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1119                 printf(
"[11] optimize (incremental): ");
  1121                 for(
int i=0;i<cfgBenchmark11_Passes;++i)
  1126                 const int       op=cfgBenchmark11_Passes*cfgBenchmark11_Iterations;
  1127                 printf(
"%u ms (%i%%),(%u o/s)\r\n",time,(time-cfgBenchmark11_Reference)*100/time,op/time*1000);
  1129         if(cfgBenchmark12_Enable)
  1134                 volumes.
resize(cfgLeaves);
  1135                 results.
resize(cfgLeaves);
  1136                 for(
int i=0;i<cfgLeaves;++i)
  1138                         volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
  1140                 printf(
"[12] btDbvtVolume notequal: ");
  1142                 for(
int i=0;i<cfgBenchmark12_Iterations;++i)
  1144                         for(
int j=0;j<cfgLeaves;++j)
  1146                                 for(
int k=0;k<cfgLeaves;++k)
  1148                                         results[k]=
NotEqual(volumes[j],volumes[k]);
  1153                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark12_Reference)*100/time);
  1155         if(cfgBenchmark13_Enable)
  1160                 btDbvtBenchmark::NilPolicy                      policy;
  1161                 vectors.
resize(cfgBenchmark13_Iterations);
  1162                 for(
int i=0;i<vectors.
size();++i)
  1164                         vectors[i]=(btDbvtBenchmark::RandVector3()*2-
btVector3(1,1,1)).normalized();
  1166                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1168                 printf(
"[13] culling(OCL+fullsort): ");
  1170                 for(
int i=0;i<cfgBenchmark13_Iterations;++i)
  1177                 const int       t=cfgBenchmark13_Iterations;
  1178                 printf(
"%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark13_Reference)*100/time,(t*1000)/time);
  1180         if(cfgBenchmark14_Enable)
  1185                 btDbvtBenchmark::P14                            policy;
  1186                 vectors.
resize(cfgBenchmark14_Iterations);
  1187                 for(
int i=0;i<vectors.
size();++i)
  1189                         vectors[i]=(btDbvtBenchmark::RandVector3()*2-
btVector3(1,1,1)).normalized();
  1191                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1193                 policy.m_nodes.reserve(cfgLeaves);
  1194                 printf(
"[14] culling(OCL+qsort): ");
  1196                 for(
int i=0;i<cfgBenchmark14_Iterations;++i)
  1199                         policy.m_nodes.resize(0);
  1200                         dbvt.
collideOCL(dbvt.
m_root,&vectors[i],&offset,vectors[i],1,policy,
false);
  1201                         policy.m_nodes.quickSort(btDbvtBenchmark::P14::sortfnc);
  1204                 const int       t=cfgBenchmark14_Iterations;
  1205                 printf(
"%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark14_Reference)*100/time,(t*1000)/time);
  1207         if(cfgBenchmark15_Enable)
  1212                 btDbvtBenchmark::P15                            policy;
  1213                 vectors.
resize(cfgBenchmark15_Iterations);
  1214                 for(
int i=0;i<vectors.
size();++i)
  1216                         vectors[i]=(btDbvtBenchmark::RandVector3()*2-
btVector3(1,1,1)).normalized();
  1218                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1220                 policy.m_nodes.reserve(cfgLeaves);
  1221                 printf(
"[15] culling(KDOP+qsort): ");
  1223                 for(
int i=0;i<cfgBenchmark15_Iterations;++i)
  1226                         policy.m_nodes.resize(0);
  1227                         policy.m_axis=vectors[i];
  1229                         policy.m_nodes.quickSort(btDbvtBenchmark::P15::sortfnc);
  1232                 const int       t=cfgBenchmark15_Iterations;
  1233                 printf(
"%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark15_Reference)*100/time,(t*1000)/time);
  1235         if(cfgBenchmark16_Enable)
  1240                 btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
  1242                 batch.
reserve(cfgBenchmark16_BatchCount);
  1243                 printf(
"[16] insert/remove batch(%u): ",cfgBenchmark16_BatchCount);
  1245                 for(
int i=0;i<cfgBenchmark16_Passes;++i)
  1247                         for(
int j=0;j<cfgBenchmark16_BatchCount;++j)
  1249                                 batch.
push_back(dbvt.
insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale),0));
  1251                         for(
int j=0;j<cfgBenchmark16_BatchCount;++j)
  1258                 const int       ir=cfgBenchmark16_Passes*cfgBenchmark16_BatchCount;
  1259                 printf(
"%u ms (%i%%),(%u bir/s)\r\n",time,(time-cfgBenchmark16_Reference)*100/time,
int(ir*1000.0/time));
  1261         if(cfgBenchmark17_Enable)
  1267                 volumes.
resize(cfgLeaves);
  1268                 results.
resize(cfgLeaves);
  1269                 indices.
resize(cfgLeaves);
  1270                 for(
int i=0;i<cfgLeaves;++i)
  1273                         volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
  1275                 for(
int i=0;i<cfgLeaves;++i)
  1277                         btSwap(indices[i],indices[rand()%cfgLeaves]);
  1279                 printf(
"[17] btDbvtVolume select: ");
  1281                 for(
int i=0;i<cfgBenchmark17_Iterations;++i)
  1283                         for(
int j=0;j<cfgLeaves;++j)
  1285                                 for(
int k=0;k<cfgLeaves;++k)
  1287                                         const int idx=indices[k];
  1288                                         results[idx]=
Select(volumes[idx],volumes[j],volumes[k]);
  1293                 printf(
"%u ms (%i%%)\r\n",time,(time-cfgBenchmark17_Reference)*100/time);
 
static DBVT_PREFIX void collideKDOP(const btDbvtNode *root, const btVector3 *normals, const btScalar *offsets, int count, DBVT_IPOLICY)
DBVT_INLINE void Merge(const btDbvtAabbMm &a, const btDbvtAabbMm &b, btDbvtAabbMm &r)
void push_back(const T &_Val)
DBVT_INLINE const btVector3 & Mins() const
static void bottomup(btDbvt *pdbvt, tNodeArray &leaves)
static DBVT_PREFIX void collideOCL(const btDbvtNode *root, const btVector3 *normals, const btScalar *offsets, const btVector3 &sortaxis, int count, DBVT_IPOLICY, bool fullsort=true)
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
static void fetchleaves(btDbvt *pdbvt, btDbvtNode *root, tNodeArray &leaves, int depth=-1)
int findLinearSearch(const T &key) const
static void getmaxdepth(const btDbvtNode *node, int depth, int &maxdepth)
static void recursedeletenode(btDbvt *pdbvt, btDbvtNode *node)
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes ...
DBVT_INLINE btVector3 Center() const
btDbvtNode * insert(const btDbvtVolume &box, void *data)
The btClock is a portable basic clock that measures accurate time in seconds, use for profiling...
virtual void WriteNode(const btDbvtNode *, int index, int parent, int child0, int child1)=0
void reset()
Resets the initial reference time. 
DBVT_INLINE btVector3 Lengths() const
static DBVT_PREFIX void rayTest(const btDbvtNode *root, const btVector3 &rayFrom, const btVector3 &rayTo, DBVT_IPOLICY)
rayTest is a re-entrant ray test, and can be called in parallel as long as the btAlignedAlloc is thre...
DBVT_INLINE int Select(const btDbvtAabbMm &o, const btDbvtAabbMm &a, const btDbvtAabbMm &b)
void swap(int index0, int index1)
void write(IWriter *iwriter) const
void Process(const btDbvtNode *n)
DBVT_INLINE const btVector3 & Maxs() const
void update(btDbvtNode *leaf, int lookahead=-1)
btAlignedObjectArray< const btDbvtNode * > tConstNodeArray
static int countLeaves(const btDbvtNode *node)
void optimizeIncremental(int passes)
static DBVT_INLINE btDbvtNode * createnode(btDbvt *pdbvt, btDbvtNode *parent, void *data)
static btDbvtAabbMm FromCE(const btVector3 &c, const btVector3 &e)
const btScalar & x() const
Return the x value. 
static DBVT_INLINE btDbvtVolume merge(const btDbvtVolume &a, const btDbvtVolume &b)
static int maxdepth(const btDbvtNode *node)
static btDbvtAabbMm FromMM(const btVector3 &mi, const btVector3 &mx)
static void insertleaf(btDbvt *pdbvt, btDbvtNode *root, btDbvtNode *leaf)
#define btAlignedFree(ptr)
const btScalar & y() const
Return the y value. 
const btScalar & z() const
Return the z value. 
DBVT_INLINE void Expand(const btVector3 &e)
void optimizeTopDown(int bu_treshold=128)
btVector3 can be used to represent 3D points and vectors. 
#define ATTRIBUTE_ALIGNED16(a)
int size() const
return the number of elements in the array 
unsigned long long int getTimeMilliseconds()
Returns the time in ms since the last call to reset or since the btClock was created. 
DBVT_INLINE bool isleaf() const
virtual void Prepare(const btDbvtNode *root, int numnodes)=0
static void clear(T &value)
static void split(const tNodeArray &leaves, tNodeArray &left, tNodeArray &right, const btVector3 &org, const btVector3 &axis)
void resize(int newsize, const T &fillData=T())
DBVT_INLINE bool isinternal() const
virtual void WriteLeaf(const btDbvtNode *, int index, int parent)=0
static btDbvtNode * removeleaf(btDbvt *pdbvt, btDbvtNode *leaf)
const T & btMax(const T &a, const T &b)
DBVT_INLINE bool Contain(const btDbvtAabbMm &a) const
DBVT_INLINE bool Intersect(const btDbvtAabbMm &a, const btDbvtAabbMm &b)
static btDbvtNode * topdown(btDbvt *pdbvt, tNodeArray &leaves, int bu_treshold)
#define btAlignedAlloc(size, alignment)
static DBVT_INLINE int indexof(const btDbvtNode *node)
btScalar dot(const btQuaternion &q1, const btQuaternion &q2)
Calculate the dot product between two quaternions. 
btAlignedObjectArray< btDbvtNode * > tNodeArray
btDbvt implementation by Nathanael Presson 
DBVT_PREFIX void collideTT(const btDbvtNode *root0, const btDbvtNode *root1, DBVT_IPOLICY)
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
btScalar btDot(const btVector3 &v1, const btVector3 &v2)
Return the dot product between two vectors. 
static DBVT_INLINE void deletenode(btDbvt *pdbvt, btDbvtNode *node)
void clone(btDbvt &dest, IClone *iclone=0) const
DBVT_INLINE void SignedExpand(const btVector3 &e)
static DBVT_INLINE btDbvtNode * sort(btDbvtNode *n, btDbvtNode *&r)
void remove(btDbvtNode *leaf)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
virtual void CloneLeaf(btDbvtNode *)
static void extractLeaves(const btDbvtNode *node, btAlignedObjectArray< const btDbvtNode *> &leaves)
static btDbvtVolume bounds(const tNodeArray &leaves)
DBVT_INLINE bool NotEqual(const btDbvtAabbMm &a, const btDbvtAabbMm &b)
btScalar btFabs(btScalar x)