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)