40 #if (DBVT_MERGE_IMPL == DBVT_IMPL_SSE) 55 return (edges.
x() * edges.
y() * edges.
z() +
56 edges.
x() + edges.
y() + edges.
z());
68 maxdepth =
btMax(maxdepth, depth);
155 }
while (!root->
isleaf());
173 }
while (0 != (prev = node->
parent));
190 if (leaf == pdbvt->
m_root)
216 return (prev ? prev : pdbvt->
m_root);
266 while (begin != end &&
leftOfAxis(leaves[begin], org, axis))
276 while (begin != end && !
leftOfAxis(leaves[end - 1], org, axis))
289 leaves[begin] = leaves[end];
301 #if DBVT_MERGE_IMPL == DBVT_IMPL_SSE 305 volume = leaves[0]->
volume;
309 for (
int i = 1, ni = count; i < ni; ++i)
311 Merge(volume, leaves[i]->volume, volume);
324 int minidx[2] = {-1, -1};
325 for (
int i = 0; i < count; ++i)
327 for (
int j = i + 1; j < count; ++j)
338 btDbvtNode* n[] = {leaves[minidx[0]], leaves[minidx[1]]};
344 leaves[minidx[0]] = p;
345 leaves[minidx[1]] = leaves[count - 1];
362 if (count > bu_treshold)
368 int bestmidp = count;
369 int splitcount[3][2] = {{0, 0}, {0, 0}, {0, 0}};
371 for (i = 0; i < count; ++i)
374 for (
int j = 0; j < 3; ++j)
376 ++splitcount[j][
btDot(x, axis[j]) > 0 ? 1 : 0];
379 for (i = 0; i < 3; ++i)
381 if ((splitcount[i][0] > 0) && (splitcount[i][1] > 0))
383 const int midp = (int)
btFabs(
btScalar(splitcount[i][0] - splitcount[i][1]));
393 partition =
split(leaves, count, org, axis[bestaxis]);
394 btAssert(partition != 0 && partition != count);
398 partition = count / 2 + 1;
401 node->
childs[0] =
topdown(pdbvt, &leaves[0], partition, bu_treshold);
402 node->
childs[1] =
topdown(pdbvt, &leaves[partition], count - partition, bu_treshold);
450 while(n&&(count--)) n=n->
parent;
516 if (
m_root && (passes > 0))
525 bit = (bit + 1) & (
sizeof(
unsigned) * 8 - 1);
550 for (
int i = 0; (i < lookahead) && root->
parent; ++i)
624 for (
int i = 0; i < nodes.
nodes.
size(); ++i)
653 const int i = stack.
size() - 1;
670 }
while (stack.
size() > 0);
706 #if DBVT_ENABLE_BENCHMARK 710 #include "LinearMath/btQuickProf.h" 747 struct btDbvtBenchmark
751 NilPolicy() : m_pcount(0), m_depth(-
SIMD_INFINITY), m_checksort(true) {}
753 void Process(
const btDbvtNode*) { ++m_pcount; }
759 if (depth >= m_depth)
762 printf(
"wrong depth: %f (should be >= %f)\r\n", depth, m_depth);
782 static int sortfnc(
const Node& a,
const Node& b)
784 if (a.depth < b.depth)
return (+1);
785 if (a.depth > b.depth)
return (-1);
803 static int sortfnc(
const Node& a,
const Node& b)
805 if (a.depth < b.depth)
return (+1);
806 if (a.depth > b.depth)
return (-1);
814 return (rand() / (
btScalar)RAND_MAX);
818 return (
btVector3(RandUnit(), RandUnit(), RandUnit()));
822 return (RandVector3() * cs -
btVector3(cs, cs, cs) / 2);
838 for (
int i = 0; i < leaves; ++i)
840 dbvt.
insert(RandVolume(cs, eb, es), 0);
847 static const btScalar cfgVolumeCenterScale = 100;
848 static const btScalar cfgVolumeExentsBase = 1;
849 static const btScalar cfgVolumeExentsScale = 4;
850 static const int cfgLeaves = 8192;
851 static const bool cfgEnable =
true;
854 bool cfgBenchmark1_Enable = cfgEnable;
855 static const int cfgBenchmark1_Iterations = 8;
856 static const int cfgBenchmark1_Reference = 3499;
858 bool cfgBenchmark2_Enable = cfgEnable;
859 static const int cfgBenchmark2_Iterations = 4;
860 static const int cfgBenchmark2_Reference = 1945;
862 bool cfgBenchmark3_Enable = cfgEnable;
863 static const int cfgBenchmark3_Iterations = 512;
864 static const int cfgBenchmark3_Reference = 5485;
866 bool cfgBenchmark4_Enable = cfgEnable;
867 static const int cfgBenchmark4_Iterations = 512;
868 static const int cfgBenchmark4_Reference = 2814;
870 bool cfgBenchmark5_Enable = cfgEnable;
871 static const int cfgBenchmark5_Iterations = 512;
872 static const btScalar cfgBenchmark5_OffsetScale = 2;
873 static const int cfgBenchmark5_Reference = 7379;
875 bool cfgBenchmark6_Enable = cfgEnable;
876 static const int cfgBenchmark6_Iterations = 512;
877 static const btScalar cfgBenchmark6_OffsetScale = 2;
878 static const int cfgBenchmark6_Reference = 7270;
880 bool cfgBenchmark7_Enable = cfgEnable;
881 static const int cfgBenchmark7_Passes = 32;
882 static const int cfgBenchmark7_Iterations = 65536;
883 static const int cfgBenchmark7_Reference = 6307;
885 bool cfgBenchmark8_Enable = cfgEnable;
886 static const int cfgBenchmark8_Passes = 32;
887 static const int cfgBenchmark8_Iterations = 65536;
888 static const int cfgBenchmark8_Reference = 2105;
890 bool cfgBenchmark9_Enable = cfgEnable;
891 static const int cfgBenchmark9_Passes = 32;
892 static const int cfgBenchmark9_Iterations = 65536;
893 static const int cfgBenchmark9_Reference = 1879;
895 bool cfgBenchmark10_Enable = cfgEnable;
896 static const btScalar cfgBenchmark10_Scale = cfgVolumeCenterScale / 10000;
897 static const int cfgBenchmark10_Passes = 32;
898 static const int cfgBenchmark10_Iterations = 65536;
899 static const int cfgBenchmark10_Reference = 1244;
901 bool cfgBenchmark11_Enable = cfgEnable;
902 static const int cfgBenchmark11_Passes = 64;
903 static const int cfgBenchmark11_Iterations = 65536;
904 static const int cfgBenchmark11_Reference = 2510;
906 bool cfgBenchmark12_Enable = cfgEnable;
907 static const int cfgBenchmark12_Iterations = 32;
908 static const int cfgBenchmark12_Reference = 3677;
910 bool cfgBenchmark13_Enable = cfgEnable;
911 static const int cfgBenchmark13_Iterations = 1024;
912 static const int cfgBenchmark13_Reference = 2231;
914 bool cfgBenchmark14_Enable = cfgEnable;
915 static const int cfgBenchmark14_Iterations = 8192;
916 static const int cfgBenchmark14_Reference = 3500;
918 bool cfgBenchmark15_Enable = cfgEnable;
919 static const int cfgBenchmark15_Iterations = 8192;
920 static const int cfgBenchmark15_Reference = 1151;
922 bool cfgBenchmark16_Enable = cfgEnable;
923 static const int cfgBenchmark16_BatchCount = 256;
924 static const int cfgBenchmark16_Passes = 16384;
925 static const int cfgBenchmark16_Reference = 5138;
927 bool cfgBenchmark17_Enable = cfgEnable;
928 static const int cfgBenchmark17_Iterations = 4;
929 static const int cfgBenchmark17_Reference = 3390;
932 printf(
"Benchmarking dbvt...\r\n");
933 printf(
"\tWorld scale: %f\r\n", cfgVolumeCenterScale);
934 printf(
"\tExtents base: %f\r\n", cfgVolumeExentsBase);
935 printf(
"\tExtents range: %f\r\n", cfgVolumeExentsScale);
936 printf(
"\tLeaves: %u\r\n", cfgLeaves);
937 printf(
"\tsizeof(btDbvtVolume): %u bytes\r\n",
sizeof(
btDbvtVolume));
938 printf(
"\tsizeof(btDbvtNode): %u bytes\r\n",
sizeof(
btDbvtNode));
939 if (cfgBenchmark1_Enable)
944 volumes.
resize(cfgLeaves);
945 results.
resize(cfgLeaves);
946 for (
int i = 0; i < cfgLeaves; ++i)
948 volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
950 printf(
"[1] btDbvtVolume intersections: ");
952 for (
int i = 0; i < cfgBenchmark1_Iterations; ++i)
954 for (
int j = 0; j < cfgLeaves; ++j)
956 for (
int k = 0; k < cfgLeaves; ++k)
958 results[k] =
Intersect(volumes[j], volumes[k]);
963 printf(
"%u ms (%i%%)\r\n", time, (time - cfgBenchmark1_Reference) * 100 / time);
965 if (cfgBenchmark2_Enable)
970 volumes.
resize(cfgLeaves);
971 results.
resize(cfgLeaves);
972 for (
int i = 0; i < cfgLeaves; ++i)
974 volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
976 printf(
"[2] btDbvtVolume merges: ");
978 for (
int i = 0; i < cfgBenchmark2_Iterations; ++i)
980 for (
int j = 0; j < cfgLeaves; ++j)
982 for (
int k = 0; k < cfgLeaves; ++k)
984 Merge(volumes[j], volumes[k], results[k]);
989 printf(
"%u ms (%i%%)\r\n", time, (time - cfgBenchmark2_Reference) * 100 / time);
991 if (cfgBenchmark3_Enable)
995 btDbvtBenchmark::NilPolicy policy;
996 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[0]);
997 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[1]);
1000 printf(
"[3] btDbvt::collideTT: ");
1002 for (
int i = 0; i < cfgBenchmark3_Iterations; ++i)
1007 printf(
"%u ms (%i%%)\r\n", time, (time - cfgBenchmark3_Reference) * 100 / time);
1009 if (cfgBenchmark4_Enable)
1013 btDbvtBenchmark::NilPolicy policy;
1014 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1016 printf(
"[4] btDbvt::collideTT self: ");
1018 for (
int i = 0; i < cfgBenchmark4_Iterations; ++i)
1023 printf(
"%u ms (%i%%)\r\n", time, (time - cfgBenchmark4_Reference) * 100 / time);
1025 if (cfgBenchmark5_Enable)
1030 btDbvtBenchmark::NilPolicy policy;
1031 transforms.
resize(cfgBenchmark5_Iterations);
1032 for (
int i = 0; i < transforms.
size(); ++i)
1034 transforms[i] = btDbvtBenchmark::RandTransform(cfgVolumeCenterScale * cfgBenchmark5_OffsetScale);
1036 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[0]);
1037 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[1]);
1040 printf(
"[5] btDbvt::collideTT xform: ");
1042 for (
int i = 0; i < cfgBenchmark5_Iterations; ++i)
1047 printf(
"%u ms (%i%%)\r\n", time, (time - cfgBenchmark5_Reference) * 100 / time);
1049 if (cfgBenchmark6_Enable)
1054 btDbvtBenchmark::NilPolicy policy;
1055 transforms.
resize(cfgBenchmark6_Iterations);
1056 for (
int i = 0; i < transforms.
size(); ++i)
1058 transforms[i] = btDbvtBenchmark::RandTransform(cfgVolumeCenterScale * cfgBenchmark6_OffsetScale);
1060 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1062 printf(
"[6] btDbvt::collideTT xform,self: ");
1064 for (
int i = 0; i < cfgBenchmark6_Iterations; ++i)
1069 printf(
"%u ms (%i%%)\r\n", time, (time - cfgBenchmark6_Reference) * 100 / time);
1071 if (cfgBenchmark7_Enable)
1077 btDbvtBenchmark::NilPolicy policy;
1078 rayorg.
resize(cfgBenchmark7_Iterations);
1079 raydir.
resize(cfgBenchmark7_Iterations);
1080 for (
int i = 0; i < rayorg.
size(); ++i)
1082 rayorg[i] = btDbvtBenchmark::RandVector3(cfgVolumeCenterScale * 2);
1083 raydir[i] = btDbvtBenchmark::RandVector3(cfgVolumeCenterScale * 2);
1085 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1087 printf(
"[7] btDbvt::rayTest: ");
1089 for (
int i = 0; i < cfgBenchmark7_Passes; ++i)
1091 for (
int j = 0; j < cfgBenchmark7_Iterations; ++j)
1097 unsigned rays = cfgBenchmark7_Passes * cfgBenchmark7_Iterations;
1098 printf(
"%u ms (%i%%),(%u r/s)\r\n", time, (time - cfgBenchmark7_Reference) * 100 / time, (rays * 1000) / time);
1100 if (cfgBenchmark8_Enable)
1104 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1106 printf(
"[8] insert/remove: ");
1108 for (
int i = 0; i < cfgBenchmark8_Passes; ++i)
1110 for (
int j = 0; j < cfgBenchmark8_Iterations; ++j)
1112 dbvt.
remove(dbvt.
insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale), 0));
1116 const int ir = cfgBenchmark8_Passes * cfgBenchmark8_Iterations;
1117 printf(
"%u ms (%i%%),(%u ir/s)\r\n", time, (time - cfgBenchmark8_Reference) * 100 / time, ir * 1000 / time);
1119 if (cfgBenchmark9_Enable)
1124 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1127 printf(
"[9] updates (teleport): ");
1129 for (
int i = 0; i < cfgBenchmark9_Passes; ++i)
1131 for (
int j = 0; j < cfgBenchmark9_Iterations; ++j)
1133 dbvt.
update(const_cast<btDbvtNode*>(leaves[rand() % cfgLeaves]),
1134 btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale));
1138 const int up = cfgBenchmark9_Passes * cfgBenchmark9_Iterations;
1139 printf(
"%u ms (%i%%),(%u u/s)\r\n", time, (time - cfgBenchmark9_Reference) * 100 / time, up * 1000 / time);
1141 if (cfgBenchmark10_Enable)
1147 vectors.
resize(cfgBenchmark10_Iterations);
1148 for (
int i = 0; i < vectors.
size(); ++i)
1150 vectors[i] = (btDbvtBenchmark::RandVector3() * 2 -
btVector3(1, 1, 1)) * cfgBenchmark10_Scale;
1152 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1155 printf(
"[10] updates (jitter): ");
1158 for (
int i = 0; i < cfgBenchmark10_Passes; ++i)
1160 for (
int j = 0; j < cfgBenchmark10_Iterations; ++j)
1169 const int up = cfgBenchmark10_Passes * cfgBenchmark10_Iterations;
1170 printf(
"%u ms (%i%%),(%u u/s)\r\n", time, (time - cfgBenchmark10_Reference) * 100 / time, up * 1000 / time);
1172 if (cfgBenchmark11_Enable)
1176 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1178 printf(
"[11] optimize (incremental): ");
1180 for (
int i = 0; i < cfgBenchmark11_Passes; ++i)
1185 const int op = cfgBenchmark11_Passes * cfgBenchmark11_Iterations;
1186 printf(
"%u ms (%i%%),(%u o/s)\r\n", time, (time - cfgBenchmark11_Reference) * 100 / time, op / time * 1000);
1188 if (cfgBenchmark12_Enable)
1193 volumes.
resize(cfgLeaves);
1194 results.
resize(cfgLeaves);
1195 for (
int i = 0; i < cfgLeaves; ++i)
1197 volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
1199 printf(
"[12] btDbvtVolume notequal: ");
1201 for (
int i = 0; i < cfgBenchmark12_Iterations; ++i)
1203 for (
int j = 0; j < cfgLeaves; ++j)
1205 for (
int k = 0; k < cfgLeaves; ++k)
1207 results[k] =
NotEqual(volumes[j], volumes[k]);
1212 printf(
"%u ms (%i%%)\r\n", time, (time - cfgBenchmark12_Reference) * 100 / time);
1214 if (cfgBenchmark13_Enable)
1219 btDbvtBenchmark::NilPolicy policy;
1220 vectors.
resize(cfgBenchmark13_Iterations);
1221 for (
int i = 0; i < vectors.
size(); ++i)
1223 vectors[i] = (btDbvtBenchmark::RandVector3() * 2 -
btVector3(1, 1, 1)).normalized();
1225 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1227 printf(
"[13] culling(OCL+fullsort): ");
1229 for (
int i = 0; i < cfgBenchmark13_Iterations; ++i)
1236 const int t = cfgBenchmark13_Iterations;
1237 printf(
"%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark13_Reference) * 100 / time, (t * 1000) / time);
1239 if (cfgBenchmark14_Enable)
1244 btDbvtBenchmark::P14 policy;
1245 vectors.
resize(cfgBenchmark14_Iterations);
1246 for (
int i = 0; i < vectors.
size(); ++i)
1248 vectors[i] = (btDbvtBenchmark::RandVector3() * 2 -
btVector3(1, 1, 1)).normalized();
1250 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1252 policy.m_nodes.reserve(cfgLeaves);
1253 printf(
"[14] culling(OCL+qsort): ");
1255 for (
int i = 0; i < cfgBenchmark14_Iterations; ++i)
1258 policy.m_nodes.resize(0);
1259 dbvt.
collideOCL(dbvt.
m_root, &vectors[i], &offset, vectors[i], 1, policy,
false);
1260 policy.m_nodes.quickSort(btDbvtBenchmark::P14::sortfnc);
1263 const int t = cfgBenchmark14_Iterations;
1264 printf(
"%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark14_Reference) * 100 / time, (t * 1000) / time);
1266 if (cfgBenchmark15_Enable)
1271 btDbvtBenchmark::P15 policy;
1272 vectors.
resize(cfgBenchmark15_Iterations);
1273 for (
int i = 0; i < vectors.
size(); ++i)
1275 vectors[i] = (btDbvtBenchmark::RandVector3() * 2 -
btVector3(1, 1, 1)).normalized();
1277 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1279 policy.m_nodes.reserve(cfgLeaves);
1280 printf(
"[15] culling(KDOP+qsort): ");
1282 for (
int i = 0; i < cfgBenchmark15_Iterations; ++i)
1285 policy.m_nodes.resize(0);
1286 policy.m_axis = vectors[i];
1288 policy.m_nodes.quickSort(btDbvtBenchmark::P15::sortfnc);
1291 const int t = cfgBenchmark15_Iterations;
1292 printf(
"%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark15_Reference) * 100 / time, (t * 1000) / time);
1294 if (cfgBenchmark16_Enable)
1299 btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
1301 batch.
reserve(cfgBenchmark16_BatchCount);
1302 printf(
"[16] insert/remove batch(%u): ", cfgBenchmark16_BatchCount);
1304 for (
int i = 0; i < cfgBenchmark16_Passes; ++i)
1306 for (
int j = 0; j < cfgBenchmark16_BatchCount; ++j)
1308 batch.
push_back(dbvt.
insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale), 0));
1310 for (
int j = 0; j < cfgBenchmark16_BatchCount; ++j)
1317 const int ir = cfgBenchmark16_Passes * cfgBenchmark16_BatchCount;
1318 printf(
"%u ms (%i%%),(%u bir/s)\r\n", time, (time - cfgBenchmark16_Reference) * 100 / time,
int(ir * 1000.0 / time));
1320 if (cfgBenchmark17_Enable)
1326 volumes.
resize(cfgLeaves);
1327 results.
resize(cfgLeaves);
1328 indices.
resize(cfgLeaves);
1329 for (
int i = 0; i < cfgLeaves; ++i)
1332 volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
1334 for (
int i = 0; i < cfgLeaves; ++i)
1336 btSwap(indices[i], indices[rand() % cfgLeaves]);
1338 printf(
"[17] btDbvtVolume select: ");
1340 for (
int i = 0; i < cfgBenchmark17_Iterations; ++i)
1342 for (
int j = 0; j < cfgLeaves; ++j)
1344 for (
int k = 0; k < cfgLeaves; ++k)
1346 const int idx = indices[k];
1347 results[idx] =
Select(volumes[idx], volumes[j], volumes[k]);
1352 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 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 bool leftOfAxis(const btDbvtNode *node, const btVector3 &org, const btVector3 &axis)
static void getmaxdepth(const btDbvtNode *node, int depth, int &maxdepth)
static void recursedeletenode(btDbvt *pdbvt, btDbvtNode *node)
static int split(btDbvtNode **leaves, int count, const btVector3 &org, const btVector3 &axis)
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...
static btDbvtNode * topdown(btDbvt *pdbvt, btDbvtNode **leaves, int count, int bu_treshold)
DBVT_INLINE int Select(const btDbvtAabbMm &o, const btDbvtAabbMm &a, const btDbvtAabbMm &b)
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)
btAlignedObjectArray< sStkNN > m_stkStack
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
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)
#define btAlignedAlloc(size, alignment)
static btDbvtVolume bounds(btDbvtNode **leaves, int count)
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
static DBVT_PREFIX void enumNodes(const btDbvtNode *root, DBVT_IPOLICY)
DBVT_INLINE void SignedExpand(const btVector3 &e)
static DBVT_INLINE btDbvtNode * sort(btDbvtNode *n, btDbvtNode *&r)
void remove(btDbvtNode *leaf)
static void bottomup(btDbvt *pdbvt, btDbvtNode **leaves, int count)
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)
DBVT_INLINE bool NotEqual(const btDbvtAabbMm &a, const btDbvtAabbMm &b)
btScalar btFabs(btScalar x)