summaryrefslogtreecommitdiff
path: root/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp')
-rw-r--r--thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp1393
1 files changed, 710 insertions, 683 deletions
diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp
index 0f04efe331..a0dc1da95d 100644
--- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp
+++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp
@@ -17,209 +17,224 @@ subject to the following restrictions:
#include "b3DynamicBvh.h"
//
-typedef b3AlignedObjectArray<b3DbvtNode*> b3NodeArray;
-typedef b3AlignedObjectArray<const b3DbvtNode*> b3ConstNodeArray;
+typedef b3AlignedObjectArray<b3DbvtNode*> b3NodeArray;
+typedef b3AlignedObjectArray<const b3DbvtNode*> b3ConstNodeArray;
//
struct b3DbvtNodeEnumerator : b3DynamicBvh::ICollide
{
- b3ConstNodeArray nodes;
+ b3ConstNodeArray nodes;
void Process(const b3DbvtNode* n) { nodes.push_back(n); }
};
//
-static B3_DBVT_INLINE int b3IndexOf(const b3DbvtNode* node)
+static B3_DBVT_INLINE int b3IndexOf(const b3DbvtNode* node)
{
- return(node->parent->childs[1]==node);
+ return (node->parent->childs[1] == node);
}
//
-static B3_DBVT_INLINE b3DbvtVolume b3Merge( const b3DbvtVolume& a,
- const b3DbvtVolume& b)
+static B3_DBVT_INLINE b3DbvtVolume b3Merge(const b3DbvtVolume& a,
+ const b3DbvtVolume& b)
{
-#if (B3_DBVT_MERGE_IMPL==B3_DBVT_IMPL_SSE)
+#if (B3_DBVT_MERGE_IMPL == B3_DBVT_IMPL_SSE)
B3_ATTRIBUTE_ALIGNED16(char locals[sizeof(b3DbvtAabbMm)]);
- b3DbvtVolume& res=*(b3DbvtVolume*)locals;
+ b3DbvtVolume& res = *(b3DbvtVolume*)locals;
#else
- b3DbvtVolume res;
+ b3DbvtVolume res;
#endif
- b3Merge(a,b,res);
- return(res);
+ b3Merge(a, b, res);
+ return (res);
}
// volume+edge lengths
-static B3_DBVT_INLINE b3Scalar b3Size(const b3DbvtVolume& a)
+static B3_DBVT_INLINE b3Scalar b3Size(const b3DbvtVolume& a)
{
- const b3Vector3 edges=a.Lengths();
- return( edges.x*edges.y*edges.z+
- edges.x+edges.y+edges.z);
+ const b3Vector3 edges = a.Lengths();
+ return (edges.x * edges.y * edges.z +
+ edges.x + edges.y + edges.z);
}
//
-static void b3GetMaxDepth(const b3DbvtNode* node,int depth,int& maxdepth)
+static void b3GetMaxDepth(const b3DbvtNode* node, int depth, int& maxdepth)
{
- if(node->isinternal())
+ if (node->isinternal())
{
- b3GetMaxDepth(node->childs[0],depth+1,maxdepth);
- b3GetMaxDepth(node->childs[1],depth+1,maxdepth);
- } else maxdepth=b3Max(maxdepth,depth);
+ b3GetMaxDepth(node->childs[0], depth + 1, maxdepth);
+ b3GetMaxDepth(node->childs[1], depth + 1, maxdepth);
+ }
+ else
+ maxdepth = b3Max(maxdepth, depth);
}
//
-static B3_DBVT_INLINE void b3DeleteNode( b3DynamicBvh* pdbvt,
- b3DbvtNode* node)
+static B3_DBVT_INLINE void b3DeleteNode(b3DynamicBvh* pdbvt,
+ b3DbvtNode* node)
{
b3AlignedFree(pdbvt->m_free);
- pdbvt->m_free=node;
+ pdbvt->m_free = node;
}
//
-static void b3RecurseDeleteNode( b3DynamicBvh* pdbvt,
- b3DbvtNode* node)
+static void b3RecurseDeleteNode(b3DynamicBvh* pdbvt,
+ b3DbvtNode* node)
{
- if(!node->isleaf())
+ if (!node->isleaf())
{
- b3RecurseDeleteNode(pdbvt,node->childs[0]);
- b3RecurseDeleteNode(pdbvt,node->childs[1]);
+ b3RecurseDeleteNode(pdbvt, node->childs[0]);
+ b3RecurseDeleteNode(pdbvt, node->childs[1]);
}
- if(node==pdbvt->m_root) pdbvt->m_root=0;
- b3DeleteNode(pdbvt,node);
+ if (node == pdbvt->m_root) pdbvt->m_root = 0;
+ b3DeleteNode(pdbvt, node);
}
//
-static B3_DBVT_INLINE b3DbvtNode* b3CreateNode( b3DynamicBvh* pdbvt,
- b3DbvtNode* parent,
- void* data)
+static B3_DBVT_INLINE b3DbvtNode* b3CreateNode(b3DynamicBvh* pdbvt,
+ b3DbvtNode* parent,
+ void* data)
{
- b3DbvtNode* node;
- if(pdbvt->m_free)
- { node=pdbvt->m_free;pdbvt->m_free=0; }
+ b3DbvtNode* node;
+ if (pdbvt->m_free)
+ {
+ node = pdbvt->m_free;
+ pdbvt->m_free = 0;
+ }
else
- { node=new(b3AlignedAlloc(sizeof(b3DbvtNode),16)) b3DbvtNode(); }
- node->parent = parent;
- node->data = data;
- node->childs[1] = 0;
- return(node);
+ {
+ node = new (b3AlignedAlloc(sizeof(b3DbvtNode), 16)) b3DbvtNode();
+ }
+ node->parent = parent;
+ node->data = data;
+ node->childs[1] = 0;
+ return (node);
}
//
-static B3_DBVT_INLINE b3DbvtNode* b3CreateNode( b3DynamicBvh* pdbvt,
- b3DbvtNode* parent,
- const b3DbvtVolume& volume,
- void* data)
+static B3_DBVT_INLINE b3DbvtNode* b3CreateNode(b3DynamicBvh* pdbvt,
+ b3DbvtNode* parent,
+ const b3DbvtVolume& volume,
+ void* data)
{
- b3DbvtNode* node=b3CreateNode(pdbvt,parent,data);
- node->volume=volume;
- return(node);
+ b3DbvtNode* node = b3CreateNode(pdbvt, parent, data);
+ node->volume = volume;
+ return (node);
}
//
-static B3_DBVT_INLINE b3DbvtNode* b3CreateNode( b3DynamicBvh* pdbvt,
- b3DbvtNode* parent,
- const b3DbvtVolume& volume0,
- const b3DbvtVolume& volume1,
- void* data)
+static B3_DBVT_INLINE b3DbvtNode* b3CreateNode(b3DynamicBvh* pdbvt,
+ b3DbvtNode* parent,
+ const b3DbvtVolume& volume0,
+ const b3DbvtVolume& volume1,
+ void* data)
{
- b3DbvtNode* node=b3CreateNode(pdbvt,parent,data);
- b3Merge(volume0,volume1,node->volume);
- return(node);
+ b3DbvtNode* node = b3CreateNode(pdbvt, parent, data);
+ b3Merge(volume0, volume1, node->volume);
+ return (node);
}
//
-static void b3InsertLeaf( b3DynamicBvh* pdbvt,
- b3DbvtNode* root,
- b3DbvtNode* leaf)
+static void b3InsertLeaf(b3DynamicBvh* pdbvt,
+ b3DbvtNode* root,
+ b3DbvtNode* leaf)
{
- if(!pdbvt->m_root)
+ if (!pdbvt->m_root)
{
- pdbvt->m_root = leaf;
- leaf->parent = 0;
+ pdbvt->m_root = leaf;
+ leaf->parent = 0;
}
else
{
- if(!root->isleaf())
+ if (!root->isleaf())
{
- do {
- root=root->childs[b3Select( leaf->volume,
- root->childs[0]->volume,
- root->childs[1]->volume)];
- } while(!root->isleaf());
+ do
+ {
+ root = root->childs[b3Select(leaf->volume,
+ root->childs[0]->volume,
+ root->childs[1]->volume)];
+ } while (!root->isleaf());
}
- b3DbvtNode* prev=root->parent;
- b3DbvtNode* node=b3CreateNode(pdbvt,prev,leaf->volume,root->volume,0);
- if(prev)
+ b3DbvtNode* prev = root->parent;
+ b3DbvtNode* node = b3CreateNode(pdbvt, prev, leaf->volume, root->volume, 0);
+ if (prev)
{
- prev->childs[b3IndexOf(root)] = node;
- node->childs[0] = root;root->parent=node;
- node->childs[1] = leaf;leaf->parent=node;
- do {
- if(!prev->volume.Contain(node->volume))
- b3Merge(prev->childs[0]->volume,prev->childs[1]->volume,prev->volume);
+ prev->childs[b3IndexOf(root)] = node;
+ node->childs[0] = root;
+ root->parent = node;
+ node->childs[1] = leaf;
+ leaf->parent = node;
+ do
+ {
+ if (!prev->volume.Contain(node->volume))
+ b3Merge(prev->childs[0]->volume, prev->childs[1]->volume, prev->volume);
else
break;
- node=prev;
- } while(0!=(prev=node->parent));
+ node = prev;
+ } while (0 != (prev = node->parent));
}
else
{
- node->childs[0] = root;root->parent=node;
- node->childs[1] = leaf;leaf->parent=node;
- pdbvt->m_root = node;
+ node->childs[0] = root;
+ root->parent = node;
+ node->childs[1] = leaf;
+ leaf->parent = node;
+ pdbvt->m_root = node;
}
}
}
//
-static b3DbvtNode* b3RemoveLeaf( b3DynamicBvh* pdbvt,
- b3DbvtNode* leaf)
+static b3DbvtNode* b3RemoveLeaf(b3DynamicBvh* pdbvt,
+ b3DbvtNode* leaf)
{
- if(leaf==pdbvt->m_root)
+ if (leaf == pdbvt->m_root)
{
- pdbvt->m_root=0;
- return(0);
+ pdbvt->m_root = 0;
+ return (0);
}
else
{
- b3DbvtNode* parent=leaf->parent;
- b3DbvtNode* prev=parent->parent;
- b3DbvtNode* sibling=parent->childs[1-b3IndexOf(leaf)];
- if(prev)
+ b3DbvtNode* parent = leaf->parent;
+ b3DbvtNode* prev = parent->parent;
+ b3DbvtNode* sibling = parent->childs[1 - b3IndexOf(leaf)];
+ if (prev)
{
- prev->childs[b3IndexOf(parent)]=sibling;
- sibling->parent=prev;
- b3DeleteNode(pdbvt,parent);
- while(prev)
+ prev->childs[b3IndexOf(parent)] = sibling;
+ sibling->parent = prev;
+ b3DeleteNode(pdbvt, parent);
+ while (prev)
{
- const b3DbvtVolume pb=prev->volume;
- b3Merge(prev->childs[0]->volume,prev->childs[1]->volume,prev->volume);
- if(b3NotEqual(pb,prev->volume))
+ const b3DbvtVolume pb = prev->volume;
+ b3Merge(prev->childs[0]->volume, prev->childs[1]->volume, prev->volume);
+ if (b3NotEqual(pb, prev->volume))
{
- prev=prev->parent;
- } else break;
+ prev = prev->parent;
+ }
+ else
+ break;
}
- return(prev?prev:pdbvt->m_root);
+ return (prev ? prev : pdbvt->m_root);
}
else
- {
- pdbvt->m_root=sibling;
- sibling->parent=0;
- b3DeleteNode(pdbvt,parent);
- return(pdbvt->m_root);
- }
+ {
+ pdbvt->m_root = sibling;
+ sibling->parent = 0;
+ b3DeleteNode(pdbvt, parent);
+ return (pdbvt->m_root);
+ }
}
}
//
-static void b3FetchLeaves(b3DynamicBvh* pdbvt,
- b3DbvtNode* root,
- b3NodeArray& leaves,
- int depth=-1)
+static void b3FetchLeaves(b3DynamicBvh* pdbvt,
+ b3DbvtNode* root,
+ b3NodeArray& leaves,
+ int depth = -1)
{
- if(root->isinternal()&&depth)
+ if (root->isinternal() && depth)
{
- b3FetchLeaves(pdbvt,root->childs[0],leaves,depth-1);
- b3FetchLeaves(pdbvt,root->childs[1],leaves,depth-1);
- b3DeleteNode(pdbvt,root);
+ b3FetchLeaves(pdbvt, root->childs[0], leaves, depth - 1);
+ b3FetchLeaves(pdbvt, root->childs[1], leaves, depth - 1);
+ b3DeleteNode(pdbvt, root);
}
else
{
@@ -227,50 +242,50 @@ static void b3FetchLeaves(b3DynamicBvh* pdbvt,
}
}
-static bool b3LeftOfAxis( const b3DbvtNode* node,
- const b3Vector3& org,
- const b3Vector3& axis)
+static bool b3LeftOfAxis(const b3DbvtNode* node,
+ const b3Vector3& org,
+ const b3Vector3& axis)
{
- return b3Dot(axis,node->volume.Center()-org) <= 0;
+ return b3Dot(axis, node->volume.Center() - org) <= 0;
}
// Partitions leaves such that leaves[0, n) are on the
// left of axis, and leaves[n, count) are on the right
// of axis. returns N.
-static int b3Split( b3DbvtNode** leaves,
- int count,
- const b3Vector3& org,
- const b3Vector3& axis)
+static int b3Split(b3DbvtNode** leaves,
+ int count,
+ const b3Vector3& org,
+ const b3Vector3& axis)
{
- int begin=0;
- int end=count;
- for(;;)
+ int begin = 0;
+ int end = count;
+ for (;;)
{
- while(begin!=end && b3LeftOfAxis(leaves[begin],org,axis))
+ while (begin != end && b3LeftOfAxis(leaves[begin], org, axis))
{
++begin;
}
- if(begin==end)
+ if (begin == end)
{
break;
}
- while(begin!=end && !b3LeftOfAxis(leaves[end-1],org,axis))
+ while (begin != end && !b3LeftOfAxis(leaves[end - 1], org, axis))
{
--end;
}
- if(begin==end)
+ if (begin == end)
{
break;
}
// swap out of place nodes
--end;
- b3DbvtNode* temp=leaves[begin];
- leaves[begin]=leaves[end];
- leaves[end]=temp;
+ b3DbvtNode* temp = leaves[begin];
+ leaves[begin] = leaves[end];
+ leaves[end] = temp;
++begin;
}
@@ -278,149 +293,152 @@ static int b3Split( b3DbvtNode** leaves,
}
//
-static b3DbvtVolume b3Bounds( b3DbvtNode** leaves,
- int count)
+static b3DbvtVolume b3Bounds(b3DbvtNode** leaves,
+ int count)
{
-#if B3_DBVT_MERGE_IMPL==B3_DBVT_IMPL_SSE
- B3_ATTRIBUTE_ALIGNED16(char locals[sizeof(b3DbvtVolume)]);
- b3DbvtVolume& volume=*(b3DbvtVolume*)locals;
- volume=leaves[0]->volume;
+#if B3_DBVT_MERGE_IMPL == B3_DBVT_IMPL_SSE
+ B3_ATTRIBUTE_ALIGNED16(char locals[sizeof(b3DbvtVolume)]);
+ b3DbvtVolume& volume = *(b3DbvtVolume*)locals;
+ volume = leaves[0]->volume;
#else
- b3DbvtVolume volume=leaves[0]->volume;
+ b3DbvtVolume volume = leaves[0]->volume;
#endif
- for(int i=1,ni=count;i<ni;++i)
+ for (int i = 1, ni = count; i < ni; ++i)
{
- b3Merge(volume,leaves[i]->volume,volume);
+ b3Merge(volume, leaves[i]->volume, volume);
}
- return(volume);
+ return (volume);
}
//
-static void b3BottomUp( b3DynamicBvh* pdbvt,
- b3DbvtNode** leaves,
- int count)
+static void b3BottomUp(b3DynamicBvh* pdbvt,
+ b3DbvtNode** leaves,
+ int count)
{
- while(count>1)
+ while (count > 1)
{
- b3Scalar minsize=B3_INFINITY;
- int minidx[2]={-1,-1};
- for(int i=0;i<count;++i)
+ b3Scalar minsize = B3_INFINITY;
+ int minidx[2] = {-1, -1};
+ for (int i = 0; i < count; ++i)
{
- for(int j=i+1;j<count;++j)
+ for (int j = i + 1; j < count; ++j)
{
- const b3Scalar sz=b3Size(b3Merge(leaves[i]->volume,leaves[j]->volume));
- if(sz<minsize)
+ const b3Scalar sz = b3Size(b3Merge(leaves[i]->volume, leaves[j]->volume));
+ if (sz < minsize)
{
- minsize = sz;
- minidx[0] = i;
- minidx[1] = j;
+ minsize = sz;
+ minidx[0] = i;
+ minidx[1] = j;
}
}
}
- b3DbvtNode* n[] = {leaves[minidx[0]],leaves[minidx[1]]};
- b3DbvtNode* p = b3CreateNode(pdbvt,0,n[0]->volume,n[1]->volume,0);
- p->childs[0] = n[0];
- p->childs[1] = n[1];
- n[0]->parent = p;
- n[1]->parent = p;
- leaves[minidx[0]] = p;
- leaves[minidx[1]] = leaves[count-1];
+ b3DbvtNode* n[] = {leaves[minidx[0]], leaves[minidx[1]]};
+ b3DbvtNode* p = b3CreateNode(pdbvt, 0, n[0]->volume, n[1]->volume, 0);
+ p->childs[0] = n[0];
+ p->childs[1] = n[1];
+ n[0]->parent = p;
+ n[1]->parent = p;
+ leaves[minidx[0]] = p;
+ leaves[minidx[1]] = leaves[count - 1];
--count;
}
}
//
-static b3DbvtNode* b3TopDown(b3DynamicBvh* pdbvt,
- b3DbvtNode** leaves,
- int count,
- int bu_treshold)
+static b3DbvtNode* b3TopDown(b3DynamicBvh* pdbvt,
+ b3DbvtNode** leaves,
+ int count,
+ int bu_treshold)
{
- static const b3Vector3 axis[]={b3MakeVector3(1,0,0),
- b3MakeVector3(0,1,0),
- b3MakeVector3(0,0,1)};
- b3Assert(bu_treshold>1);
- if(count>1)
+ static const b3Vector3 axis[] = {b3MakeVector3(1, 0, 0),
+ b3MakeVector3(0, 1, 0),
+ b3MakeVector3(0, 0, 1)};
+ b3Assert(bu_treshold > 1);
+ if (count > 1)
{
- if(count>bu_treshold)
+ if (count > bu_treshold)
{
- const b3DbvtVolume vol=b3Bounds(leaves,count);
- const b3Vector3 org=vol.Center();
- int partition;
- int bestaxis=-1;
- int bestmidp=count;
- int splitcount[3][2]={{0,0},{0,0},{0,0}};
+ const b3DbvtVolume vol = b3Bounds(leaves, count);
+ const b3Vector3 org = vol.Center();
+ int partition;
+ int bestaxis = -1;
+ int bestmidp = count;
+ int splitcount[3][2] = {{0, 0}, {0, 0}, {0, 0}};
int i;
- for( i=0;i<count;++i)
+ for (i = 0; i < count; ++i)
{
- const b3Vector3 x=leaves[i]->volume.Center()-org;
- for(int j=0;j<3;++j)
+ const b3Vector3 x = leaves[i]->volume.Center() - org;
+ for (int j = 0; j < 3; ++j)
{
- ++splitcount[j][b3Dot(x,axis[j])>0?1:0];
+ ++splitcount[j][b3Dot(x, axis[j]) > 0 ? 1 : 0];
}
}
- for( i=0;i<3;++i)
+ for (i = 0; i < 3; ++i)
{
- if((splitcount[i][0]>0)&&(splitcount[i][1]>0))
+ if ((splitcount[i][0] > 0) && (splitcount[i][1] > 0))
{
- const int midp=(int)b3Fabs(b3Scalar(splitcount[i][0]-splitcount[i][1]));
- if(midp<bestmidp)
+ const int midp = (int)b3Fabs(b3Scalar(splitcount[i][0] - splitcount[i][1]));
+ if (midp < bestmidp)
{
- bestaxis=i;
- bestmidp=midp;
+ bestaxis = i;
+ bestmidp = midp;
}
}
}
- if(bestaxis>=0)
+ if (bestaxis >= 0)
{
- partition=b3Split(leaves,count,org,axis[bestaxis]);
- b3Assert(partition!=0 && partition!=count);
+ partition = b3Split(leaves, count, org, axis[bestaxis]);
+ b3Assert(partition != 0 && partition != count);
}
else
{
- partition=count/2+1;
+ partition = count / 2 + 1;
}
- b3DbvtNode* node=b3CreateNode(pdbvt,0,vol,0);
- node->childs[0]=b3TopDown(pdbvt,&leaves[0],partition,bu_treshold);
- node->childs[1]=b3TopDown(pdbvt,&leaves[partition],count-partition,bu_treshold);
- node->childs[0]->parent=node;
- node->childs[1]->parent=node;
- return(node);
+ b3DbvtNode* node = b3CreateNode(pdbvt, 0, vol, 0);
+ node->childs[0] = b3TopDown(pdbvt, &leaves[0], partition, bu_treshold);
+ node->childs[1] = b3TopDown(pdbvt, &leaves[partition], count - partition, bu_treshold);
+ node->childs[0]->parent = node;
+ node->childs[1]->parent = node;
+ return (node);
}
else
{
- b3BottomUp(pdbvt,leaves,count);
- return(leaves[0]);
+ b3BottomUp(pdbvt, leaves, count);
+ return (leaves[0]);
}
}
- return(leaves[0]);
+ return (leaves[0]);
}
//
-static B3_DBVT_INLINE b3DbvtNode* b3Sort(b3DbvtNode* n,b3DbvtNode*& r)
+static B3_DBVT_INLINE b3DbvtNode* b3Sort(b3DbvtNode* n, b3DbvtNode*& r)
{
- b3DbvtNode* p=n->parent;
+ b3DbvtNode* p = n->parent;
b3Assert(n->isinternal());
- if(p>n)
+ if (p > n)
{
- const int i=b3IndexOf(n);
- const int j=1-i;
- b3DbvtNode* s=p->childs[j];
- b3DbvtNode* q=p->parent;
- b3Assert(n==p->childs[i]);
- if(q) q->childs[b3IndexOf(p)]=n; else r=n;
- s->parent=n;
- p->parent=n;
- n->parent=q;
- p->childs[0]=n->childs[0];
- p->childs[1]=n->childs[1];
- n->childs[0]->parent=p;
- n->childs[1]->parent=p;
- n->childs[i]=p;
- n->childs[j]=s;
- b3Swap(p->volume,n->volume);
- return(p);
+ const int i = b3IndexOf(n);
+ const int j = 1 - i;
+ b3DbvtNode* s = p->childs[j];
+ b3DbvtNode* q = p->parent;
+ b3Assert(n == p->childs[i]);
+ if (q)
+ q->childs[b3IndexOf(p)] = n;
+ else
+ r = n;
+ s->parent = n;
+ p->parent = n;
+ n->parent = q;
+ p->childs[0] = n->childs[0];
+ p->childs[1] = n->childs[1];
+ n->childs[0]->parent = p;
+ n->childs[1]->parent = p;
+ n->childs[i] = p;
+ n->childs[j] = s;
+ b3Swap(p->volume, n->volume);
+ return (p);
}
- return(n);
+ return (n);
}
#if 0
@@ -438,11 +456,11 @@ static B3_DBVT_INLINE b3DbvtNode* walkup(b3DbvtNode* n,int count)
//
b3DynamicBvh::b3DynamicBvh()
{
- m_root = 0;
- m_free = 0;
- m_lkhd = -1;
- m_leaves = 0;
- m_opath = 0;
+ m_root = 0;
+ m_free = 0;
+ m_lkhd = -1;
+ m_leaves = 0;
+ m_opath = 0;
}
//
@@ -452,228 +470,233 @@ b3DynamicBvh::~b3DynamicBvh()
}
//
-void b3DynamicBvh::clear()
+void b3DynamicBvh::clear()
{
- if(m_root)
- b3RecurseDeleteNode(this,m_root);
+ if (m_root)
+ b3RecurseDeleteNode(this, m_root);
b3AlignedFree(m_free);
- m_free=0;
- m_lkhd = -1;
+ m_free = 0;
+ m_lkhd = -1;
m_stkStack.clear();
- m_opath = 0;
-
+ m_opath = 0;
}
//
-void b3DynamicBvh::optimizeBottomUp()
+void b3DynamicBvh::optimizeBottomUp()
{
- if(m_root)
+ if (m_root)
{
b3NodeArray leaves;
leaves.reserve(m_leaves);
- b3FetchLeaves(this,m_root,leaves);
- b3BottomUp(this,&leaves[0],leaves.size());
- m_root=leaves[0];
+ b3FetchLeaves(this, m_root, leaves);
+ b3BottomUp(this, &leaves[0], leaves.size());
+ m_root = leaves[0];
}
}
//
-void b3DynamicBvh::optimizeTopDown(int bu_treshold)
+void b3DynamicBvh::optimizeTopDown(int bu_treshold)
{
- if(m_root)
+ if (m_root)
{
- b3NodeArray leaves;
+ b3NodeArray leaves;
leaves.reserve(m_leaves);
- b3FetchLeaves(this,m_root,leaves);
- m_root=b3TopDown(this,&leaves[0],leaves.size(),bu_treshold);
+ b3FetchLeaves(this, m_root, leaves);
+ m_root = b3TopDown(this, &leaves[0], leaves.size(), bu_treshold);
}
}
//
-void b3DynamicBvh::optimizeIncremental(int passes)
+void b3DynamicBvh::optimizeIncremental(int passes)
{
- if(passes<0) passes=m_leaves;
- if(m_root&&(passes>0))
+ if (passes < 0) passes = m_leaves;
+ if (m_root && (passes > 0))
{
- do {
- b3DbvtNode* node=m_root;
- unsigned bit=0;
- while(node->isinternal())
+ do
+ {
+ b3DbvtNode* node = m_root;
+ unsigned bit = 0;
+ while (node->isinternal())
{
- node=b3Sort(node,m_root)->childs[(m_opath>>bit)&1];
- bit=(bit+1)&(sizeof(unsigned)*8-1);
+ node = b3Sort(node, m_root)->childs[(m_opath >> bit) & 1];
+ bit = (bit + 1) & (sizeof(unsigned) * 8 - 1);
}
update(node);
++m_opath;
- } while(--passes);
+ } while (--passes);
}
}
//
-b3DbvtNode* b3DynamicBvh::insert(const b3DbvtVolume& volume,void* data)
+b3DbvtNode* b3DynamicBvh::insert(const b3DbvtVolume& volume, void* data)
{
- b3DbvtNode* leaf=b3CreateNode(this,0,volume,data);
- b3InsertLeaf(this,m_root,leaf);
+ b3DbvtNode* leaf = b3CreateNode(this, 0, volume, data);
+ b3InsertLeaf(this, m_root, leaf);
++m_leaves;
- return(leaf);
+ return (leaf);
}
//
-void b3DynamicBvh::update(b3DbvtNode* leaf,int lookahead)
+void b3DynamicBvh::update(b3DbvtNode* leaf, int lookahead)
{
- b3DbvtNode* root=b3RemoveLeaf(this,leaf);
- if(root)
+ b3DbvtNode* root = b3RemoveLeaf(this, leaf);
+ if (root)
{
- if(lookahead>=0)
+ if (lookahead >= 0)
{
- for(int i=0;(i<lookahead)&&root->parent;++i)
+ for (int i = 0; (i < lookahead) && root->parent; ++i)
{
- root=root->parent;
+ root = root->parent;
}
- } else root=m_root;
+ }
+ else
+ root = m_root;
}
- b3InsertLeaf(this,root,leaf);
+ b3InsertLeaf(this, root, leaf);
}
//
-void b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume)
+void b3DynamicBvh::update(b3DbvtNode* leaf, b3DbvtVolume& volume)
{
- b3DbvtNode* root=b3RemoveLeaf(this,leaf);
- if(root)
+ b3DbvtNode* root = b3RemoveLeaf(this, leaf);
+ if (root)
{
- if(m_lkhd>=0)
+ if (m_lkhd >= 0)
{
- for(int i=0;(i<m_lkhd)&&root->parent;++i)
+ for (int i = 0; (i < m_lkhd) && root->parent; ++i)
{
- root=root->parent;
+ root = root->parent;
}
- } else root=m_root;
+ }
+ else
+ root = m_root;
}
- leaf->volume=volume;
- b3InsertLeaf(this,root,leaf);
+ leaf->volume = volume;
+ b3InsertLeaf(this, root, leaf);
}
//
-bool b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume,const b3Vector3& velocity,b3Scalar margin)
+bool b3DynamicBvh::update(b3DbvtNode* leaf, b3DbvtVolume& volume, const b3Vector3& velocity, b3Scalar margin)
{
- if(leaf->volume.Contain(volume)) return(false);
- volume.Expand(b3MakeVector3(margin,margin,margin));
+ if (leaf->volume.Contain(volume)) return (false);
+ volume.Expand(b3MakeVector3(margin, margin, margin));
volume.SignedExpand(velocity);
- update(leaf,volume);
- return(true);
+ update(leaf, volume);
+ return (true);
}
//
-bool b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume,const b3Vector3& velocity)
+bool b3DynamicBvh::update(b3DbvtNode* leaf, b3DbvtVolume& volume, const b3Vector3& velocity)
{
- if(leaf->volume.Contain(volume)) return(false);
+ if (leaf->volume.Contain(volume)) return (false);
volume.SignedExpand(velocity);
- update(leaf,volume);
- return(true);
+ update(leaf, volume);
+ return (true);
}
//
-bool b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume,b3Scalar margin)
+bool b3DynamicBvh::update(b3DbvtNode* leaf, b3DbvtVolume& volume, b3Scalar margin)
{
- if(leaf->volume.Contain(volume)) return(false);
- volume.Expand(b3MakeVector3(margin,margin,margin));
- update(leaf,volume);
- return(true);
+ if (leaf->volume.Contain(volume)) return (false);
+ volume.Expand(b3MakeVector3(margin, margin, margin));
+ update(leaf, volume);
+ return (true);
}
//
-void b3DynamicBvh::remove(b3DbvtNode* leaf)
+void b3DynamicBvh::remove(b3DbvtNode* leaf)
{
- b3RemoveLeaf(this,leaf);
- b3DeleteNode(this,leaf);
+ b3RemoveLeaf(this, leaf);
+ b3DeleteNode(this, leaf);
--m_leaves;
}
//
-void b3DynamicBvh::write(IWriter* iwriter) const
+void b3DynamicBvh::write(IWriter* iwriter) const
{
- b3DbvtNodeEnumerator nodes;
- nodes.nodes.reserve(m_leaves*2);
- enumNodes(m_root,nodes);
- iwriter->Prepare(m_root,nodes.nodes.size());
- for(int i=0;i<nodes.nodes.size();++i)
+ b3DbvtNodeEnumerator nodes;
+ nodes.nodes.reserve(m_leaves * 2);
+ enumNodes(m_root, nodes);
+ iwriter->Prepare(m_root, nodes.nodes.size());
+ for (int i = 0; i < nodes.nodes.size(); ++i)
{
- const b3DbvtNode* n=nodes.nodes[i];
- int p=-1;
- if(n->parent) p=nodes.nodes.findLinearSearch(n->parent);
- if(n->isinternal())
+ const b3DbvtNode* n = nodes.nodes[i];
+ int p = -1;
+ if (n->parent) p = nodes.nodes.findLinearSearch(n->parent);
+ if (n->isinternal())
{
- const int c0=nodes.nodes.findLinearSearch(n->childs[0]);
- const int c1=nodes.nodes.findLinearSearch(n->childs[1]);
- iwriter->WriteNode(n,i,p,c0,c1);
+ const int c0 = nodes.nodes.findLinearSearch(n->childs[0]);
+ const int c1 = nodes.nodes.findLinearSearch(n->childs[1]);
+ iwriter->WriteNode(n, i, p, c0, c1);
}
else
{
- iwriter->WriteLeaf(n,i,p);
- }
+ iwriter->WriteLeaf(n, i, p);
+ }
}
}
//
-void b3DynamicBvh::clone(b3DynamicBvh& dest,IClone* iclone) const
+void b3DynamicBvh::clone(b3DynamicBvh& dest, IClone* iclone) const
{
dest.clear();
- if(m_root!=0)
- {
- b3AlignedObjectArray<sStkCLN> stack;
+ if (m_root != 0)
+ {
+ b3AlignedObjectArray<sStkCLN> stack;
stack.reserve(m_leaves);
- stack.push_back(sStkCLN(m_root,0));
- do {
- const int i=stack.size()-1;
- const sStkCLN e=stack[i];
- b3DbvtNode* n=b3CreateNode(&dest,e.parent,e.node->volume,e.node->data);
+ stack.push_back(sStkCLN(m_root, 0));
+ do
+ {
+ const int i = stack.size() - 1;
+ const sStkCLN e = stack[i];
+ b3DbvtNode* n = b3CreateNode(&dest, e.parent, e.node->volume, e.node->data);
stack.pop_back();
- if(e.parent!=0)
- e.parent->childs[i&1]=n;
+ if (e.parent != 0)
+ e.parent->childs[i & 1] = n;
else
- dest.m_root=n;
- if(e.node->isinternal())
+ dest.m_root = n;
+ if (e.node->isinternal())
{
- stack.push_back(sStkCLN(e.node->childs[0],n));
- stack.push_back(sStkCLN(e.node->childs[1],n));
+ stack.push_back(sStkCLN(e.node->childs[0], n));
+ stack.push_back(sStkCLN(e.node->childs[1], n));
}
else
{
iclone->CloneLeaf(n);
}
- } while(stack.size()>0);
+ } while (stack.size() > 0);
}
}
//
-int b3DynamicBvh::maxdepth(const b3DbvtNode* node)
+int b3DynamicBvh::maxdepth(const b3DbvtNode* node)
{
- int depth=0;
- if(node) b3GetMaxDepth(node,1,depth);
- return(depth);
+ int depth = 0;
+ if (node) b3GetMaxDepth(node, 1, depth);
+ return (depth);
}
//
-int b3DynamicBvh::countLeaves(const b3DbvtNode* node)
+int b3DynamicBvh::countLeaves(const b3DbvtNode* node)
{
- if(node->isinternal())
- return(countLeaves(node->childs[0])+countLeaves(node->childs[1]));
+ if (node->isinternal())
+ return (countLeaves(node->childs[0]) + countLeaves(node->childs[1]));
else
- return(1);
+ return (1);
}
//
-void b3DynamicBvh::extractLeaves(const b3DbvtNode* node,b3AlignedObjectArray<const b3DbvtNode*>& leaves)
+void b3DynamicBvh::extractLeaves(const b3DbvtNode* node, b3AlignedObjectArray<const b3DbvtNode*>& leaves)
{
- if(node->isinternal())
+ if (node->isinternal())
{
- extractLeaves(node->childs[0],leaves);
- extractLeaves(node->childs[1],leaves);
+ extractLeaves(node->childs[0], leaves);
+ extractLeaves(node->childs[1], leaves);
}
else
{
leaves.push_back(node);
- }
+ }
}
//
@@ -682,7 +705,6 @@ void b3DynamicBvh::extractLeaves(const b3DbvtNode* node,b3AlignedObjectArray<c
#include <stdio.h>
#include <stdlib.h>
-
/*
q6600,2.4ghz
@@ -722,603 +744,608 @@ struct b3DbvtBenchmark
{
struct NilPolicy : b3DynamicBvh::ICollide
{
- NilPolicy() : m_pcount(0),m_depth(-B3_INFINITY),m_checksort(true) {}
- void Process(const b3DbvtNode*,const b3DbvtNode*) { ++m_pcount; }
- void Process(const b3DbvtNode*) { ++m_pcount; }
- void Process(const b3DbvtNode*,b3Scalar depth)
+ NilPolicy() : m_pcount(0), m_depth(-B3_INFINITY), m_checksort(true) {}
+ void Process(const b3DbvtNode*, const b3DbvtNode*) { ++m_pcount; }
+ void Process(const b3DbvtNode*) { ++m_pcount; }
+ void Process(const b3DbvtNode*, b3Scalar depth)
{
++m_pcount;
- if(m_checksort)
- { if(depth>=m_depth) m_depth=depth; else printf("wrong depth: %f (should be >= %f)\r\n",depth,m_depth); }
+ if (m_checksort)
+ {
+ if (depth >= m_depth)
+ m_depth = depth;
+ else
+ printf("wrong depth: %f (should be >= %f)\r\n", depth, m_depth);
+ }
}
- int m_pcount;
- b3Scalar m_depth;
- bool m_checksort;
+ int m_pcount;
+ b3Scalar m_depth;
+ bool m_checksort;
};
struct P14 : b3DynamicBvh::ICollide
{
struct Node
{
- const b3DbvtNode* leaf;
- b3Scalar depth;
+ const b3DbvtNode* leaf;
+ b3Scalar depth;
};
- void Process(const b3DbvtNode* leaf,b3Scalar depth)
+ void Process(const b3DbvtNode* leaf, b3Scalar depth)
{
- Node n;
- n.leaf = leaf;
- n.depth = depth;
+ Node n;
+ n.leaf = leaf;
+ n.depth = depth;
}
- static int sortfnc(const Node& a,const Node& b)
+ static int sortfnc(const Node& a, const Node& b)
{
- if(a.depth<b.depth) return(+1);
- if(a.depth>b.depth) return(-1);
- return(0);
+ if (a.depth < b.depth) return (+1);
+ if (a.depth > b.depth) return (-1);
+ return (0);
}
- b3AlignedObjectArray<Node> m_nodes;
+ b3AlignedObjectArray<Node> m_nodes;
};
struct P15 : b3DynamicBvh::ICollide
{
struct Node
{
- const b3DbvtNode* leaf;
- b3Scalar depth;
+ const b3DbvtNode* leaf;
+ b3Scalar depth;
};
void Process(const b3DbvtNode* leaf)
{
- Node n;
- n.leaf = leaf;
- n.depth = dot(leaf->volume.Center(),m_axis);
+ Node n;
+ n.leaf = leaf;
+ n.depth = dot(leaf->volume.Center(), m_axis);
}
- static int sortfnc(const Node& a,const Node& b)
+ static int sortfnc(const Node& a, const Node& b)
{
- if(a.depth<b.depth) return(+1);
- if(a.depth>b.depth) return(-1);
- return(0);
+ if (a.depth < b.depth) return (+1);
+ if (a.depth > b.depth) return (-1);
+ return (0);
}
- b3AlignedObjectArray<Node> m_nodes;
- b3Vector3 m_axis;
+ b3AlignedObjectArray<Node> m_nodes;
+ b3Vector3 m_axis;
};
- static b3Scalar RandUnit()
+ static b3Scalar RandUnit()
{
- return(rand()/(b3Scalar)RAND_MAX);
+ return (rand() / (b3Scalar)RAND_MAX);
}
- static b3Vector3 RandVector3()
+ static b3Vector3 RandVector3()
{
- return(b3Vector3(RandUnit(),RandUnit(),RandUnit()));
+ return (b3Vector3(RandUnit(), RandUnit(), RandUnit()));
}
- static b3Vector3 RandVector3(b3Scalar cs)
+ static b3Vector3 RandVector3(b3Scalar cs)
{
- return(RandVector3()*cs-b3Vector3(cs,cs,cs)/2);
+ return (RandVector3() * cs - b3Vector3(cs, cs, cs) / 2);
}
- static b3DbvtVolume RandVolume(b3Scalar cs,b3Scalar eb,b3Scalar es)
+ static b3DbvtVolume RandVolume(b3Scalar cs, b3Scalar eb, b3Scalar es)
{
- return(b3DbvtVolume::FromCE(RandVector3(cs),b3Vector3(eb,eb,eb)+RandVector3()*es));
+ return (b3DbvtVolume::FromCE(RandVector3(cs), b3Vector3(eb, eb, eb) + RandVector3() * es));
}
- static b3Transform RandTransform(b3Scalar cs)
+ static b3Transform RandTransform(b3Scalar cs)
{
- b3Transform t;
+ b3Transform t;
t.setOrigin(RandVector3(cs));
- t.setRotation(b3Quaternion(RandUnit()*B3_PI*2,RandUnit()*B3_PI*2,RandUnit()*B3_PI*2).normalized());
- return(t);
+ t.setRotation(b3Quaternion(RandUnit() * B3_PI * 2, RandUnit() * B3_PI * 2, RandUnit() * B3_PI * 2).normalized());
+ return (t);
}
- static void RandTree(b3Scalar cs,b3Scalar eb,b3Scalar es,int leaves,b3DynamicBvh& dbvt)
+ static void RandTree(b3Scalar cs, b3Scalar eb, b3Scalar es, int leaves, b3DynamicBvh& dbvt)
{
dbvt.clear();
- for(int i=0;i<leaves;++i)
+ for (int i = 0; i < leaves; ++i)
{
- dbvt.insert(RandVolume(cs,eb,es),0);
+ dbvt.insert(RandVolume(cs, eb, es), 0);
}
}
};
-void b3DynamicBvh::benchmark()
+void b3DynamicBvh::benchmark()
{
- static const b3Scalar cfgVolumeCenterScale = 100;
- static const b3Scalar cfgVolumeExentsBase = 1;
- static const b3Scalar cfgVolumeExentsScale = 4;
- static const int cfgLeaves = 8192;
- static const bool cfgEnable = true;
+ static const b3Scalar cfgVolumeCenterScale = 100;
+ static const b3Scalar cfgVolumeExentsBase = 1;
+ static const b3Scalar cfgVolumeExentsScale = 4;
+ static const int cfgLeaves = 8192;
+ static const bool cfgEnable = true;
//[1] b3DbvtVolume intersections
- bool cfgBenchmark1_Enable = cfgEnable;
- static const int cfgBenchmark1_Iterations = 8;
- static const int cfgBenchmark1_Reference = 3499;
+ bool cfgBenchmark1_Enable = cfgEnable;
+ static const int cfgBenchmark1_Iterations = 8;
+ static const int cfgBenchmark1_Reference = 3499;
//[2] b3DbvtVolume merges
- bool cfgBenchmark2_Enable = cfgEnable;
- static const int cfgBenchmark2_Iterations = 4;
- static const int cfgBenchmark2_Reference = 1945;
+ bool cfgBenchmark2_Enable = cfgEnable;
+ static const int cfgBenchmark2_Iterations = 4;
+ static const int cfgBenchmark2_Reference = 1945;
//[3] b3DynamicBvh::collideTT
- bool cfgBenchmark3_Enable = cfgEnable;
- static const int cfgBenchmark3_Iterations = 512;
- static const int cfgBenchmark3_Reference = 5485;
+ bool cfgBenchmark3_Enable = cfgEnable;
+ static const int cfgBenchmark3_Iterations = 512;
+ static const int cfgBenchmark3_Reference = 5485;
//[4] b3DynamicBvh::collideTT self
- bool cfgBenchmark4_Enable = cfgEnable;
- static const int cfgBenchmark4_Iterations = 512;
- static const int cfgBenchmark4_Reference = 2814;
+ bool cfgBenchmark4_Enable = cfgEnable;
+ static const int cfgBenchmark4_Iterations = 512;
+ static const int cfgBenchmark4_Reference = 2814;
//[5] b3DynamicBvh::collideTT xform
- bool cfgBenchmark5_Enable = cfgEnable;
- static const int cfgBenchmark5_Iterations = 512;
- static const b3Scalar cfgBenchmark5_OffsetScale = 2;
- static const int cfgBenchmark5_Reference = 7379;
+ bool cfgBenchmark5_Enable = cfgEnable;
+ static const int cfgBenchmark5_Iterations = 512;
+ static const b3Scalar cfgBenchmark5_OffsetScale = 2;
+ static const int cfgBenchmark5_Reference = 7379;
//[6] b3DynamicBvh::collideTT xform,self
- bool cfgBenchmark6_Enable = cfgEnable;
- static const int cfgBenchmark6_Iterations = 512;
- static const b3Scalar cfgBenchmark6_OffsetScale = 2;
- static const int cfgBenchmark6_Reference = 7270;
+ bool cfgBenchmark6_Enable = cfgEnable;
+ static const int cfgBenchmark6_Iterations = 512;
+ static const b3Scalar cfgBenchmark6_OffsetScale = 2;
+ static const int cfgBenchmark6_Reference = 7270;
//[7] b3DynamicBvh::rayTest
- bool cfgBenchmark7_Enable = cfgEnable;
- static const int cfgBenchmark7_Passes = 32;
- static const int cfgBenchmark7_Iterations = 65536;
- static const int cfgBenchmark7_Reference = 6307;
+ bool cfgBenchmark7_Enable = cfgEnable;
+ static const int cfgBenchmark7_Passes = 32;
+ static const int cfgBenchmark7_Iterations = 65536;
+ static const int cfgBenchmark7_Reference = 6307;
//[8] insert/remove
- bool cfgBenchmark8_Enable = cfgEnable;
- static const int cfgBenchmark8_Passes = 32;
- static const int cfgBenchmark8_Iterations = 65536;
- static const int cfgBenchmark8_Reference = 2105;
+ bool cfgBenchmark8_Enable = cfgEnable;
+ static const int cfgBenchmark8_Passes = 32;
+ static const int cfgBenchmark8_Iterations = 65536;
+ static const int cfgBenchmark8_Reference = 2105;
//[9] updates (teleport)
- bool cfgBenchmark9_Enable = cfgEnable;
- static const int cfgBenchmark9_Passes = 32;
- static const int cfgBenchmark9_Iterations = 65536;
- static const int cfgBenchmark9_Reference = 1879;
+ bool cfgBenchmark9_Enable = cfgEnable;
+ static const int cfgBenchmark9_Passes = 32;
+ static const int cfgBenchmark9_Iterations = 65536;
+ static const int cfgBenchmark9_Reference = 1879;
//[10] updates (jitter)
- bool cfgBenchmark10_Enable = cfgEnable;
- static const b3Scalar cfgBenchmark10_Scale = cfgVolumeCenterScale/10000;
- static const int cfgBenchmark10_Passes = 32;
- static const int cfgBenchmark10_Iterations = 65536;
- static const int cfgBenchmark10_Reference = 1244;
+ bool cfgBenchmark10_Enable = cfgEnable;
+ static const b3Scalar cfgBenchmark10_Scale = cfgVolumeCenterScale / 10000;
+ static const int cfgBenchmark10_Passes = 32;
+ static const int cfgBenchmark10_Iterations = 65536;
+ static const int cfgBenchmark10_Reference = 1244;
//[11] optimize (incremental)
- bool cfgBenchmark11_Enable = cfgEnable;
- static const int cfgBenchmark11_Passes = 64;
- static const int cfgBenchmark11_Iterations = 65536;
- static const int cfgBenchmark11_Reference = 2510;
+ bool cfgBenchmark11_Enable = cfgEnable;
+ static const int cfgBenchmark11_Passes = 64;
+ static const int cfgBenchmark11_Iterations = 65536;
+ static const int cfgBenchmark11_Reference = 2510;
//[12] b3DbvtVolume notequal
- bool cfgBenchmark12_Enable = cfgEnable;
- static const int cfgBenchmark12_Iterations = 32;
- static const int cfgBenchmark12_Reference = 3677;
+ bool cfgBenchmark12_Enable = cfgEnable;
+ static const int cfgBenchmark12_Iterations = 32;
+ static const int cfgBenchmark12_Reference = 3677;
//[13] culling(OCL+fullsort)
- bool cfgBenchmark13_Enable = cfgEnable;
- static const int cfgBenchmark13_Iterations = 1024;
- static const int cfgBenchmark13_Reference = 2231;
+ bool cfgBenchmark13_Enable = cfgEnable;
+ static const int cfgBenchmark13_Iterations = 1024;
+ static const int cfgBenchmark13_Reference = 2231;
//[14] culling(OCL+qsort)
- bool cfgBenchmark14_Enable = cfgEnable;
- static const int cfgBenchmark14_Iterations = 8192;
- static const int cfgBenchmark14_Reference = 3500;
+ bool cfgBenchmark14_Enable = cfgEnable;
+ static const int cfgBenchmark14_Iterations = 8192;
+ static const int cfgBenchmark14_Reference = 3500;
//[15] culling(KDOP+qsort)
- bool cfgBenchmark15_Enable = cfgEnable;
- static const int cfgBenchmark15_Iterations = 8192;
- static const int cfgBenchmark15_Reference = 1151;
+ bool cfgBenchmark15_Enable = cfgEnable;
+ static const int cfgBenchmark15_Iterations = 8192;
+ static const int cfgBenchmark15_Reference = 1151;
//[16] insert/remove batch
- bool cfgBenchmark16_Enable = cfgEnable;
- static const int cfgBenchmark16_BatchCount = 256;
- static const int cfgBenchmark16_Passes = 16384;
- static const int cfgBenchmark16_Reference = 5138;
+ bool cfgBenchmark16_Enable = cfgEnable;
+ static const int cfgBenchmark16_BatchCount = 256;
+ static const int cfgBenchmark16_Passes = 16384;
+ static const int cfgBenchmark16_Reference = 5138;
//[17] select
- bool cfgBenchmark17_Enable = cfgEnable;
- static const int cfgBenchmark17_Iterations = 4;
- static const int cfgBenchmark17_Reference = 3390;
+ bool cfgBenchmark17_Enable = cfgEnable;
+ static const int cfgBenchmark17_Iterations = 4;
+ static const int cfgBenchmark17_Reference = 3390;
- b3Clock wallclock;
+ b3Clock wallclock;
printf("Benchmarking dbvt...\r\n");
- printf("\tWorld scale: %f\r\n",cfgVolumeCenterScale);
- printf("\tExtents base: %f\r\n",cfgVolumeExentsBase);
- printf("\tExtents range: %f\r\n",cfgVolumeExentsScale);
- printf("\tLeaves: %u\r\n",cfgLeaves);
- printf("\tsizeof(b3DbvtVolume): %u bytes\r\n",sizeof(b3DbvtVolume));
- printf("\tsizeof(b3DbvtNode): %u bytes\r\n",sizeof(b3DbvtNode));
- if(cfgBenchmark1_Enable)
- {// Benchmark 1
+ printf("\tWorld scale: %f\r\n", cfgVolumeCenterScale);
+ printf("\tExtents base: %f\r\n", cfgVolumeExentsBase);
+ printf("\tExtents range: %f\r\n", cfgVolumeExentsScale);
+ printf("\tLeaves: %u\r\n", cfgLeaves);
+ printf("\tsizeof(b3DbvtVolume): %u bytes\r\n", sizeof(b3DbvtVolume));
+ printf("\tsizeof(b3DbvtNode): %u bytes\r\n", sizeof(b3DbvtNode));
+ if (cfgBenchmark1_Enable)
+ { // Benchmark 1
srand(380843);
- b3AlignedObjectArray<b3DbvtVolume> volumes;
- b3AlignedObjectArray<bool> results;
+ b3AlignedObjectArray<b3DbvtVolume> volumes;
+ b3AlignedObjectArray<bool> results;
volumes.resize(cfgLeaves);
results.resize(cfgLeaves);
- for(int i=0;i<cfgLeaves;++i)
+ for (int i = 0; i < cfgLeaves; ++i)
{
- volumes[i]=b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
+ volumes[i] = b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
}
printf("[1] b3DbvtVolume intersections: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark1_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark1_Iterations; ++i)
{
- for(int j=0;j<cfgLeaves;++j)
+ for (int j = 0; j < cfgLeaves; ++j)
{
- for(int k=0;k<cfgLeaves;++k)
+ for (int k = 0; k < cfgLeaves; ++k)
{
- results[k]=Intersect(volumes[j],volumes[k]);
+ results[k] = Intersect(volumes[j], volumes[k]);
}
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark1_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark1_Reference) * 100 / time);
}
- if(cfgBenchmark2_Enable)
- {// Benchmark 2
+ if (cfgBenchmark2_Enable)
+ { // Benchmark 2
srand(380843);
- b3AlignedObjectArray<b3DbvtVolume> volumes;
- b3AlignedObjectArray<b3DbvtVolume> results;
+ b3AlignedObjectArray<b3DbvtVolume> volumes;
+ b3AlignedObjectArray<b3DbvtVolume> results;
volumes.resize(cfgLeaves);
results.resize(cfgLeaves);
- for(int i=0;i<cfgLeaves;++i)
+ for (int i = 0; i < cfgLeaves; ++i)
{
- volumes[i]=b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
+ volumes[i] = b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
}
printf("[2] b3DbvtVolume merges: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark2_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark2_Iterations; ++i)
{
- for(int j=0;j<cfgLeaves;++j)
+ for (int j = 0; j < cfgLeaves; ++j)
{
- for(int k=0;k<cfgLeaves;++k)
+ for (int k = 0; k < cfgLeaves; ++k)
{
- Merge(volumes[j],volumes[k],results[k]);
+ Merge(volumes[j], volumes[k], results[k]);
}
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark2_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark2_Reference) * 100 / time);
}
- if(cfgBenchmark3_Enable)
- {// Benchmark 3
+ if (cfgBenchmark3_Enable)
+ { // Benchmark 3
srand(380843);
- b3DynamicBvh dbvt[2];
- b3DbvtBenchmark::NilPolicy policy;
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[0]);
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[1]);
+ b3DynamicBvh dbvt[2];
+ b3DbvtBenchmark::NilPolicy policy;
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[0]);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[1]);
dbvt[0].optimizeTopDown();
dbvt[1].optimizeTopDown();
printf("[3] b3DynamicBvh::collideTT: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark3_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark3_Iterations; ++i)
{
- b3DynamicBvh::collideTT(dbvt[0].m_root,dbvt[1].m_root,policy);
+ b3DynamicBvh::collideTT(dbvt[0].m_root, dbvt[1].m_root, policy);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark3_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark3_Reference) * 100 / time);
}
- if(cfgBenchmark4_Enable)
- {// Benchmark 4
+ if (cfgBenchmark4_Enable)
+ { // Benchmark 4
srand(380843);
- b3DynamicBvh dbvt;
- b3DbvtBenchmark::NilPolicy policy;
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DynamicBvh dbvt;
+ b3DbvtBenchmark::NilPolicy policy;
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
printf("[4] b3DynamicBvh::collideTT self: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark4_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark4_Iterations; ++i)
{
- b3DynamicBvh::collideTT(dbvt.m_root,dbvt.m_root,policy);
+ b3DynamicBvh::collideTT(dbvt.m_root, dbvt.m_root, policy);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark4_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark4_Reference) * 100 / time);
}
- if(cfgBenchmark5_Enable)
- {// Benchmark 5
+ if (cfgBenchmark5_Enable)
+ { // Benchmark 5
srand(380843);
- b3DynamicBvh dbvt[2];
- b3AlignedObjectArray<b3Transform> transforms;
- b3DbvtBenchmark::NilPolicy policy;
+ b3DynamicBvh dbvt[2];
+ b3AlignedObjectArray<b3Transform> transforms;
+ b3DbvtBenchmark::NilPolicy policy;
transforms.resize(cfgBenchmark5_Iterations);
- for(int i=0;i<transforms.size();++i)
+ for (int i = 0; i < transforms.size(); ++i)
{
- transforms[i]=b3DbvtBenchmark::RandTransform(cfgVolumeCenterScale*cfgBenchmark5_OffsetScale);
+ transforms[i] = b3DbvtBenchmark::RandTransform(cfgVolumeCenterScale * cfgBenchmark5_OffsetScale);
}
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[0]);
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[1]);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[0]);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[1]);
dbvt[0].optimizeTopDown();
dbvt[1].optimizeTopDown();
printf("[5] b3DynamicBvh::collideTT xform: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark5_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark5_Iterations; ++i)
{
- b3DynamicBvh::collideTT(dbvt[0].m_root,dbvt[1].m_root,transforms[i],policy);
+ b3DynamicBvh::collideTT(dbvt[0].m_root, dbvt[1].m_root, transforms[i], policy);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark5_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark5_Reference) * 100 / time);
}
- if(cfgBenchmark6_Enable)
- {// Benchmark 6
+ if (cfgBenchmark6_Enable)
+ { // Benchmark 6
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<b3Transform> transforms;
- b3DbvtBenchmark::NilPolicy policy;
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<b3Transform> transforms;
+ b3DbvtBenchmark::NilPolicy policy;
transforms.resize(cfgBenchmark6_Iterations);
- for(int i=0;i<transforms.size();++i)
+ for (int i = 0; i < transforms.size(); ++i)
{
- transforms[i]=b3DbvtBenchmark::RandTransform(cfgVolumeCenterScale*cfgBenchmark6_OffsetScale);
+ transforms[i] = b3DbvtBenchmark::RandTransform(cfgVolumeCenterScale * cfgBenchmark6_OffsetScale);
}
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
printf("[6] b3DynamicBvh::collideTT xform,self: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark6_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark6_Iterations; ++i)
{
- b3DynamicBvh::collideTT(dbvt.m_root,dbvt.m_root,transforms[i],policy);
+ b3DynamicBvh::collideTT(dbvt.m_root, dbvt.m_root, transforms[i], policy);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark6_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark6_Reference) * 100 / time);
}
- if(cfgBenchmark7_Enable)
- {// Benchmark 7
+ if (cfgBenchmark7_Enable)
+ { // Benchmark 7
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<b3Vector3> rayorg;
- b3AlignedObjectArray<b3Vector3> raydir;
- b3DbvtBenchmark::NilPolicy policy;
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<b3Vector3> rayorg;
+ b3AlignedObjectArray<b3Vector3> raydir;
+ b3DbvtBenchmark::NilPolicy policy;
rayorg.resize(cfgBenchmark7_Iterations);
raydir.resize(cfgBenchmark7_Iterations);
- for(int i=0;i<rayorg.size();++i)
+ for (int i = 0; i < rayorg.size(); ++i)
{
- rayorg[i]=b3DbvtBenchmark::RandVector3(cfgVolumeCenterScale*2);
- raydir[i]=b3DbvtBenchmark::RandVector3(cfgVolumeCenterScale*2);
+ rayorg[i] = b3DbvtBenchmark::RandVector3(cfgVolumeCenterScale * 2);
+ raydir[i] = b3DbvtBenchmark::RandVector3(cfgVolumeCenterScale * 2);
}
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
printf("[7] b3DynamicBvh::rayTest: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark7_Passes;++i)
+ for (int i = 0; i < cfgBenchmark7_Passes; ++i)
{
- for(int j=0;j<cfgBenchmark7_Iterations;++j)
+ for (int j = 0; j < cfgBenchmark7_Iterations; ++j)
{
- b3DynamicBvh::rayTest(dbvt.m_root,rayorg[j],rayorg[j]+raydir[j],policy);
+ b3DynamicBvh::rayTest(dbvt.m_root, rayorg[j], rayorg[j] + raydir[j], policy);
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- unsigned rays=cfgBenchmark7_Passes*cfgBenchmark7_Iterations;
- printf("%u ms (%i%%),(%u r/s)\r\n",time,(time-cfgBenchmark7_Reference)*100/time,(rays*1000)/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ unsigned rays = cfgBenchmark7_Passes * cfgBenchmark7_Iterations;
+ printf("%u ms (%i%%),(%u r/s)\r\n", time, (time - cfgBenchmark7_Reference) * 100 / time, (rays * 1000) / time);
}
- if(cfgBenchmark8_Enable)
- {// Benchmark 8
+ if (cfgBenchmark8_Enable)
+ { // Benchmark 8
srand(380843);
- b3DynamicBvh dbvt;
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DynamicBvh dbvt;
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
printf("[8] insert/remove: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark8_Passes;++i)
+ for (int i = 0; i < cfgBenchmark8_Passes; ++i)
{
- for(int j=0;j<cfgBenchmark8_Iterations;++j)
+ for (int j = 0; j < cfgBenchmark8_Iterations; ++j)
{
- dbvt.remove(dbvt.insert(b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale),0));
+ dbvt.remove(dbvt.insert(b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale), 0));
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int ir=cfgBenchmark8_Passes*cfgBenchmark8_Iterations;
- printf("%u ms (%i%%),(%u ir/s)\r\n",time,(time-cfgBenchmark8_Reference)*100/time,ir*1000/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int ir = cfgBenchmark8_Passes * cfgBenchmark8_Iterations;
+ printf("%u ms (%i%%),(%u ir/s)\r\n", time, (time - cfgBenchmark8_Reference) * 100 / time, ir * 1000 / time);
}
- if(cfgBenchmark9_Enable)
- {// Benchmark 9
+ if (cfgBenchmark9_Enable)
+ { // Benchmark 9
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<const b3DbvtNode*> leaves;
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<const b3DbvtNode*> leaves;
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
- dbvt.extractLeaves(dbvt.m_root,leaves);
+ dbvt.extractLeaves(dbvt.m_root, leaves);
printf("[9] updates (teleport): ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark9_Passes;++i)
+ for (int i = 0; i < cfgBenchmark9_Passes; ++i)
{
- for(int j=0;j<cfgBenchmark9_Iterations;++j)
+ for (int j = 0; j < cfgBenchmark9_Iterations; ++j)
{
- dbvt.update(const_cast<b3DbvtNode*>(leaves[rand()%cfgLeaves]),
- b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale));
+ dbvt.update(const_cast<b3DbvtNode*>(leaves[rand() % cfgLeaves]),
+ b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale));
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int up=cfgBenchmark9_Passes*cfgBenchmark9_Iterations;
- printf("%u ms (%i%%),(%u u/s)\r\n",time,(time-cfgBenchmark9_Reference)*100/time,up*1000/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int up = cfgBenchmark9_Passes * cfgBenchmark9_Iterations;
+ printf("%u ms (%i%%),(%u u/s)\r\n", time, (time - cfgBenchmark9_Reference) * 100 / time, up * 1000 / time);
}
- if(cfgBenchmark10_Enable)
- {// Benchmark 10
+ if (cfgBenchmark10_Enable)
+ { // Benchmark 10
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<const b3DbvtNode*> leaves;
- b3AlignedObjectArray<b3Vector3> vectors;
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<const b3DbvtNode*> leaves;
+ b3AlignedObjectArray<b3Vector3> vectors;
vectors.resize(cfgBenchmark10_Iterations);
- for(int i=0;i<vectors.size();++i)
+ for (int i = 0; i < vectors.size(); ++i)
{
- vectors[i]=(b3DbvtBenchmark::RandVector3()*2-b3Vector3(1,1,1))*cfgBenchmark10_Scale;
+ vectors[i] = (b3DbvtBenchmark::RandVector3() * 2 - b3Vector3(1, 1, 1)) * cfgBenchmark10_Scale;
}
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
- dbvt.extractLeaves(dbvt.m_root,leaves);
+ dbvt.extractLeaves(dbvt.m_root, leaves);
printf("[10] updates (jitter): ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark10_Passes;++i)
+ for (int i = 0; i < cfgBenchmark10_Passes; ++i)
{
- for(int j=0;j<cfgBenchmark10_Iterations;++j)
- {
- const b3Vector3& d=vectors[j];
- b3DbvtNode* l=const_cast<b3DbvtNode*>(leaves[rand()%cfgLeaves]);
- b3DbvtVolume v=b3DbvtVolume::FromMM(l->volume.Mins()+d,l->volume.Maxs()+d);
- dbvt.update(l,v);
+ for (int j = 0; j < cfgBenchmark10_Iterations; ++j)
+ {
+ const b3Vector3& d = vectors[j];
+ b3DbvtNode* l = const_cast<b3DbvtNode*>(leaves[rand() % cfgLeaves]);
+ b3DbvtVolume v = b3DbvtVolume::FromMM(l->volume.Mins() + d, l->volume.Maxs() + d);
+ dbvt.update(l, v);
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int up=cfgBenchmark10_Passes*cfgBenchmark10_Iterations;
- printf("%u ms (%i%%),(%u u/s)\r\n",time,(time-cfgBenchmark10_Reference)*100/time,up*1000/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int up = cfgBenchmark10_Passes * cfgBenchmark10_Iterations;
+ printf("%u ms (%i%%),(%u u/s)\r\n", time, (time - cfgBenchmark10_Reference) * 100 / time, up * 1000 / time);
}
- if(cfgBenchmark11_Enable)
- {// Benchmark 11
+ if (cfgBenchmark11_Enable)
+ { // Benchmark 11
srand(380843);
- b3DynamicBvh dbvt;
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DynamicBvh dbvt;
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
printf("[11] optimize (incremental): ");
- wallclock.reset();
- for(int i=0;i<cfgBenchmark11_Passes;++i)
+ wallclock.reset();
+ for (int i = 0; i < cfgBenchmark11_Passes; ++i)
{
dbvt.optimizeIncremental(cfgBenchmark11_Iterations);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int op=cfgBenchmark11_Passes*cfgBenchmark11_Iterations;
- printf("%u ms (%i%%),(%u o/s)\r\n",time,(time-cfgBenchmark11_Reference)*100/time,op/time*1000);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int op = cfgBenchmark11_Passes * cfgBenchmark11_Iterations;
+ printf("%u ms (%i%%),(%u o/s)\r\n", time, (time - cfgBenchmark11_Reference) * 100 / time, op / time * 1000);
}
- if(cfgBenchmark12_Enable)
- {// Benchmark 12
+ if (cfgBenchmark12_Enable)
+ { // Benchmark 12
srand(380843);
- b3AlignedObjectArray<b3DbvtVolume> volumes;
- b3AlignedObjectArray<bool> results;
+ b3AlignedObjectArray<b3DbvtVolume> volumes;
+ b3AlignedObjectArray<bool> results;
volumes.resize(cfgLeaves);
results.resize(cfgLeaves);
- for(int i=0;i<cfgLeaves;++i)
+ for (int i = 0; i < cfgLeaves; ++i)
{
- volumes[i]=b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
+ volumes[i] = b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
}
printf("[12] b3DbvtVolume notequal: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark12_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark12_Iterations; ++i)
{
- for(int j=0;j<cfgLeaves;++j)
+ for (int j = 0; j < cfgLeaves; ++j)
{
- for(int k=0;k<cfgLeaves;++k)
+ for (int k = 0; k < cfgLeaves; ++k)
{
- results[k]=NotEqual(volumes[j],volumes[k]);
+ results[k] = NotEqual(volumes[j], volumes[k]);
}
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark12_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark12_Reference) * 100 / time);
}
- if(cfgBenchmark13_Enable)
- {// Benchmark 13
+ if (cfgBenchmark13_Enable)
+ { // Benchmark 13
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<b3Vector3> vectors;
- b3DbvtBenchmark::NilPolicy policy;
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<b3Vector3> vectors;
+ b3DbvtBenchmark::NilPolicy policy;
vectors.resize(cfgBenchmark13_Iterations);
- for(int i=0;i<vectors.size();++i)
+ for (int i = 0; i < vectors.size(); ++i)
{
- vectors[i]=(b3DbvtBenchmark::RandVector3()*2-b3Vector3(1,1,1)).normalized();
+ vectors[i] = (b3DbvtBenchmark::RandVector3() * 2 - b3Vector3(1, 1, 1)).normalized();
}
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
printf("[13] culling(OCL+fullsort): ");
- wallclock.reset();
- for(int i=0;i<cfgBenchmark13_Iterations;++i)
+ wallclock.reset();
+ for (int i = 0; i < cfgBenchmark13_Iterations; ++i)
{
- static const b3Scalar offset=0;
- policy.m_depth=-B3_INFINITY;
- dbvt.collideOCL(dbvt.m_root,&vectors[i],&offset,vectors[i],1,policy);
+ static const b3Scalar offset = 0;
+ policy.m_depth = -B3_INFINITY;
+ dbvt.collideOCL(dbvt.m_root, &vectors[i], &offset, vectors[i], 1, policy);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int t=cfgBenchmark13_Iterations;
- printf("%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark13_Reference)*100/time,(t*1000)/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int t = cfgBenchmark13_Iterations;
+ printf("%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark13_Reference) * 100 / time, (t * 1000) / time);
}
- if(cfgBenchmark14_Enable)
- {// Benchmark 14
+ if (cfgBenchmark14_Enable)
+ { // Benchmark 14
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<b3Vector3> vectors;
- b3DbvtBenchmark::P14 policy;
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<b3Vector3> vectors;
+ b3DbvtBenchmark::P14 policy;
vectors.resize(cfgBenchmark14_Iterations);
- for(int i=0;i<vectors.size();++i)
+ for (int i = 0; i < vectors.size(); ++i)
{
- vectors[i]=(b3DbvtBenchmark::RandVector3()*2-b3Vector3(1,1,1)).normalized();
+ vectors[i] = (b3DbvtBenchmark::RandVector3() * 2 - b3Vector3(1, 1, 1)).normalized();
}
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
policy.m_nodes.reserve(cfgLeaves);
printf("[14] culling(OCL+qsort): ");
- wallclock.reset();
- for(int i=0;i<cfgBenchmark14_Iterations;++i)
+ wallclock.reset();
+ for (int i = 0; i < cfgBenchmark14_Iterations; ++i)
{
- static const b3Scalar offset=0;
+ static const b3Scalar offset = 0;
policy.m_nodes.resize(0);
- dbvt.collideOCL(dbvt.m_root,&vectors[i],&offset,vectors[i],1,policy,false);
+ dbvt.collideOCL(dbvt.m_root, &vectors[i], &offset, vectors[i], 1, policy, false);
policy.m_nodes.quickSort(b3DbvtBenchmark::P14::sortfnc);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int t=cfgBenchmark14_Iterations;
- printf("%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark14_Reference)*100/time,(t*1000)/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int t = cfgBenchmark14_Iterations;
+ printf("%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark14_Reference) * 100 / time, (t * 1000) / time);
}
- if(cfgBenchmark15_Enable)
- {// Benchmark 15
+ if (cfgBenchmark15_Enable)
+ { // Benchmark 15
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<b3Vector3> vectors;
- b3DbvtBenchmark::P15 policy;
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<b3Vector3> vectors;
+ b3DbvtBenchmark::P15 policy;
vectors.resize(cfgBenchmark15_Iterations);
- for(int i=0;i<vectors.size();++i)
+ for (int i = 0; i < vectors.size(); ++i)
{
- vectors[i]=(b3DbvtBenchmark::RandVector3()*2-b3Vector3(1,1,1)).normalized();
+ vectors[i] = (b3DbvtBenchmark::RandVector3() * 2 - b3Vector3(1, 1, 1)).normalized();
}
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
policy.m_nodes.reserve(cfgLeaves);
printf("[15] culling(KDOP+qsort): ");
- wallclock.reset();
- for(int i=0;i<cfgBenchmark15_Iterations;++i)
+ wallclock.reset();
+ for (int i = 0; i < cfgBenchmark15_Iterations; ++i)
{
- static const b3Scalar offset=0;
+ static const b3Scalar offset = 0;
policy.m_nodes.resize(0);
- policy.m_axis=vectors[i];
- dbvt.collideKDOP(dbvt.m_root,&vectors[i],&offset,1,policy);
+ policy.m_axis = vectors[i];
+ dbvt.collideKDOP(dbvt.m_root, &vectors[i], &offset, 1, policy);
policy.m_nodes.quickSort(b3DbvtBenchmark::P15::sortfnc);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int t=cfgBenchmark15_Iterations;
- printf("%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark15_Reference)*100/time,(t*1000)/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int t = cfgBenchmark15_Iterations;
+ printf("%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark15_Reference) * 100 / time, (t * 1000) / time);
}
- if(cfgBenchmark16_Enable)
- {// Benchmark 16
+ if (cfgBenchmark16_Enable)
+ { // Benchmark 16
srand(380843);
- b3DynamicBvh dbvt;
- b3AlignedObjectArray<b3DbvtNode*> batch;
- b3DbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
+ b3DynamicBvh dbvt;
+ b3AlignedObjectArray<b3DbvtNode*> batch;
+ b3DbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt);
dbvt.optimizeTopDown();
batch.reserve(cfgBenchmark16_BatchCount);
- printf("[16] insert/remove batch(%u): ",cfgBenchmark16_BatchCount);
+ printf("[16] insert/remove batch(%u): ", cfgBenchmark16_BatchCount);
wallclock.reset();
- for(int i=0;i<cfgBenchmark16_Passes;++i)
+ for (int i = 0; i < cfgBenchmark16_Passes; ++i)
{
- for(int j=0;j<cfgBenchmark16_BatchCount;++j)
+ for (int j = 0; j < cfgBenchmark16_BatchCount; ++j)
{
- batch.push_back(dbvt.insert(b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale),0));
+ batch.push_back(dbvt.insert(b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale), 0));
}
- for(int j=0;j<cfgBenchmark16_BatchCount;++j)
+ for (int j = 0; j < cfgBenchmark16_BatchCount; ++j)
{
dbvt.remove(batch[j]);
}
batch.resize(0);
}
- const int time=(int)wallclock.getTimeMilliseconds();
- const int ir=cfgBenchmark16_Passes*cfgBenchmark16_BatchCount;
- printf("%u ms (%i%%),(%u bir/s)\r\n",time,(time-cfgBenchmark16_Reference)*100/time,int(ir*1000.0/time));
+ const int time = (int)wallclock.getTimeMilliseconds();
+ const int ir = cfgBenchmark16_Passes * cfgBenchmark16_BatchCount;
+ printf("%u ms (%i%%),(%u bir/s)\r\n", time, (time - cfgBenchmark16_Reference) * 100 / time, int(ir * 1000.0 / time));
}
- if(cfgBenchmark17_Enable)
- {// Benchmark 17
+ if (cfgBenchmark17_Enable)
+ { // Benchmark 17
srand(380843);
- b3AlignedObjectArray<b3DbvtVolume> volumes;
- b3AlignedObjectArray<int> results;
- b3AlignedObjectArray<int> indices;
+ b3AlignedObjectArray<b3DbvtVolume> volumes;
+ b3AlignedObjectArray<int> results;
+ b3AlignedObjectArray<int> indices;
volumes.resize(cfgLeaves);
results.resize(cfgLeaves);
indices.resize(cfgLeaves);
- for(int i=0;i<cfgLeaves;++i)
+ for (int i = 0; i < cfgLeaves; ++i)
{
- indices[i]=i;
- volumes[i]=b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
+ indices[i] = i;
+ volumes[i] = b3DbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale);
}
- for(int i=0;i<cfgLeaves;++i)
+ for (int i = 0; i < cfgLeaves; ++i)
{
- b3Swap(indices[i],indices[rand()%cfgLeaves]);
+ b3Swap(indices[i], indices[rand() % cfgLeaves]);
}
printf("[17] b3DbvtVolume select: ");
wallclock.reset();
- for(int i=0;i<cfgBenchmark17_Iterations;++i)
+ for (int i = 0; i < cfgBenchmark17_Iterations; ++i)
{
- for(int j=0;j<cfgLeaves;++j)
+ for (int j = 0; j < cfgLeaves; ++j)
{
- for(int k=0;k<cfgLeaves;++k)
+ for (int k = 0; k < cfgLeaves; ++k)
{
- const int idx=indices[k];
- results[idx]=Select(volumes[idx],volumes[j],volumes[k]);
+ const int idx = indices[k];
+ results[idx] = Select(volumes[idx], volumes[j], volumes[k]);
}
}
}
- const int time=(int)wallclock.getTimeMilliseconds();
- printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark17_Reference)*100/time);
+ const int time = (int)wallclock.getTimeMilliseconds();
+ printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark17_Reference) * 100 / time);
}
printf("\r\n\r\n");
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-13 03:11:23 +0000