diff options
Diffstat (limited to 'thirdparty/bullet/Bullet3Collision/BroadPhaseCollision')
9 files changed, 2296 insertions, 2344 deletions
diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h index 1bc56cf80a..bec0800a6f 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h @@ -19,22 +19,20 @@ subject to the following restrictions: #include "Bullet3Common/b3Vector3.h" struct b3BroadphaseProxy; - -struct b3BroadphaseAabbCallback +struct b3BroadphaseAabbCallback { virtual ~b3BroadphaseAabbCallback() {} - virtual bool process(const b3BroadphaseProxy* proxy) = 0; + virtual bool process(const b3BroadphaseProxy* proxy) = 0; }; - -struct b3BroadphaseRayCallback : public b3BroadphaseAabbCallback +struct b3BroadphaseRayCallback : public b3BroadphaseAabbCallback { ///added some cached data to accelerate ray-AABB tests - b3Vector3 m_rayDirectionInverse; - unsigned int m_signs[3]; - b3Scalar m_lambda_max; + b3Vector3 m_rayDirectionInverse; + unsigned int m_signs[3]; + b3Scalar m_lambda_max; virtual ~b3BroadphaseRayCallback() {} }; -#endif //B3_BROADPHASE_CALLBACK_H +#endif //B3_BROADPHASE_CALLBACK_H 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"); } diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h index c004b9130f..f44e3377fe 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h @@ -26,50 +26,49 @@ subject to the following restrictions: // Compile time configuration // - // Implementation profiles -#define B3_DBVT_IMPL_GENERIC 0 // Generic implementation -#define B3_DBVT_IMPL_SSE 1 // SSE +#define B3_DBVT_IMPL_GENERIC 0 // Generic implementation +#define B3_DBVT_IMPL_SSE 1 // SSE // Template implementation of ICollide #ifdef _WIN32 -#if (defined (_MSC_VER) && _MSC_VER >= 1400) -#define B3_DBVT_USE_TEMPLATE 1 +#if (defined(_MSC_VER) && _MSC_VER >= 1400) +#define B3_DBVT_USE_TEMPLATE 1 #else -#define B3_DBVT_USE_TEMPLATE 0 +#define B3_DBVT_USE_TEMPLATE 0 #endif #else -#define B3_DBVT_USE_TEMPLATE 0 +#define B3_DBVT_USE_TEMPLATE 0 #endif // Use only intrinsics instead of inline asm -#define B3_DBVT_USE_INTRINSIC_SSE 1 +#define B3_DBVT_USE_INTRINSIC_SSE 1 // Using memmov for collideOCL -#define B3_DBVT_USE_MEMMOVE 1 +#define B3_DBVT_USE_MEMMOVE 1 // Enable benchmarking code -#define B3_DBVT_ENABLE_BENCHMARK 0 +#define B3_DBVT_ENABLE_BENCHMARK 0 // Inlining -#define B3_DBVT_INLINE B3_FORCE_INLINE +#define B3_DBVT_INLINE B3_FORCE_INLINE // Specific methods implementation //SSE gives errors on a MSVC 7.1 -#if defined (B3_USE_SSE) //&& defined (_WIN32) -#define B3_DBVT_SELECT_IMPL B3_DBVT_IMPL_SSE -#define B3_DBVT_MERGE_IMPL B3_DBVT_IMPL_SSE -#define B3_DBVT_INT0_IMPL B3_DBVT_IMPL_SSE +#if defined(B3_USE_SSE) //&& defined (_WIN32) +#define B3_DBVT_SELECT_IMPL B3_DBVT_IMPL_SSE +#define B3_DBVT_MERGE_IMPL B3_DBVT_IMPL_SSE +#define B3_DBVT_INT0_IMPL B3_DBVT_IMPL_SSE #else -#define B3_DBVT_SELECT_IMPL B3_DBVT_IMPL_GENERIC -#define B3_DBVT_MERGE_IMPL B3_DBVT_IMPL_GENERIC -#define B3_DBVT_INT0_IMPL B3_DBVT_IMPL_GENERIC +#define B3_DBVT_SELECT_IMPL B3_DBVT_IMPL_GENERIC +#define B3_DBVT_MERGE_IMPL B3_DBVT_IMPL_GENERIC +#define B3_DBVT_INT0_IMPL B3_DBVT_IMPL_GENERIC #endif -#if (B3_DBVT_SELECT_IMPL==B3_DBVT_IMPL_SSE)|| \ - (B3_DBVT_MERGE_IMPL==B3_DBVT_IMPL_SSE)|| \ - (B3_DBVT_INT0_IMPL==B3_DBVT_IMPL_SSE) +#if (B3_DBVT_SELECT_IMPL == B3_DBVT_IMPL_SSE) || \ + (B3_DBVT_MERGE_IMPL == B3_DBVT_IMPL_SSE) || \ + (B3_DBVT_INT0_IMPL == B3_DBVT_IMPL_SSE) #include <emmintrin.h> #endif @@ -78,21 +77,24 @@ subject to the following restrictions: // #if B3_DBVT_USE_TEMPLATE -#define B3_DBVT_VIRTUAL +#define B3_DBVT_VIRTUAL #define B3_DBVT_VIRTUAL_DTOR(a) -#define B3_DBVT_PREFIX template <typename T> -#define B3_DBVT_IPOLICY T& policy -#define B3_DBVT_CHECKTYPE static const ICollide& typechecker=*(T*)1;(void)typechecker; +#define B3_DBVT_PREFIX template <typename T> +#define B3_DBVT_IPOLICY T& policy +#define B3_DBVT_CHECKTYPE \ + static const ICollide& typechecker = *(T*)1; \ + (void)typechecker; #else -#define B3_DBVT_VIRTUAL_DTOR(a) virtual ~a() {} -#define B3_DBVT_VIRTUAL virtual +#define B3_DBVT_VIRTUAL_DTOR(a) \ + virtual ~a() {} +#define B3_DBVT_VIRTUAL virtual #define B3_DBVT_PREFIX -#define B3_DBVT_IPOLICY ICollide& policy +#define B3_DBVT_IPOLICY ICollide& policy #define B3_DBVT_CHECKTYPE #endif #if B3_DBVT_USE_MEMMOVE -#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__) +#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) #include <memory.h> #endif #include <string.h> @@ -126,187 +128,188 @@ subject to the following restrictions: // Defaults volumes // -/* b3DbvtAabbMm */ -struct b3DbvtAabbMm +/* b3DbvtAabbMm */ +struct b3DbvtAabbMm { - B3_DBVT_INLINE b3Vector3 Center() const { return((mi+mx)/2); } - B3_DBVT_INLINE b3Vector3 Lengths() const { return(mx-mi); } - B3_DBVT_INLINE b3Vector3 Extents() const { return((mx-mi)/2); } - B3_DBVT_INLINE const b3Vector3& Mins() const { return(mi); } - B3_DBVT_INLINE const b3Vector3& Maxs() const { return(mx); } - static inline b3DbvtAabbMm FromCE(const b3Vector3& c,const b3Vector3& e); - static inline b3DbvtAabbMm FromCR(const b3Vector3& c,b3Scalar r); - static inline b3DbvtAabbMm FromMM(const b3Vector3& mi,const b3Vector3& mx); - static inline b3DbvtAabbMm FromPoints(const b3Vector3* pts,int n); - static inline b3DbvtAabbMm FromPoints(const b3Vector3** ppts,int n); - B3_DBVT_INLINE void Expand(const b3Vector3& e); - B3_DBVT_INLINE void SignedExpand(const b3Vector3& e); - B3_DBVT_INLINE bool Contain(const b3DbvtAabbMm& a) const; - B3_DBVT_INLINE int Classify(const b3Vector3& n,b3Scalar o,int s) const; - B3_DBVT_INLINE b3Scalar ProjectMinimum(const b3Vector3& v,unsigned signs) const; - B3_DBVT_INLINE friend bool b3Intersect( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b); - - B3_DBVT_INLINE friend bool b3Intersect( const b3DbvtAabbMm& a, - const b3Vector3& b); - - B3_DBVT_INLINE friend b3Scalar b3Proximity( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b); - B3_DBVT_INLINE friend int b3Select( const b3DbvtAabbMm& o, - const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b); - B3_DBVT_INLINE friend void b3Merge( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b, - b3DbvtAabbMm& r); - B3_DBVT_INLINE friend bool b3NotEqual( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b); - - B3_DBVT_INLINE b3Vector3& tMins() { return(mi); } - B3_DBVT_INLINE b3Vector3& tMaxs() { return(mx); } - + B3_DBVT_INLINE b3Vector3 Center() const { return ((mi + mx) / 2); } + B3_DBVT_INLINE b3Vector3 Lengths() const { return (mx - mi); } + B3_DBVT_INLINE b3Vector3 Extents() const { return ((mx - mi) / 2); } + B3_DBVT_INLINE const b3Vector3& Mins() const { return (mi); } + B3_DBVT_INLINE const b3Vector3& Maxs() const { return (mx); } + static inline b3DbvtAabbMm FromCE(const b3Vector3& c, const b3Vector3& e); + static inline b3DbvtAabbMm FromCR(const b3Vector3& c, b3Scalar r); + static inline b3DbvtAabbMm FromMM(const b3Vector3& mi, const b3Vector3& mx); + static inline b3DbvtAabbMm FromPoints(const b3Vector3* pts, int n); + static inline b3DbvtAabbMm FromPoints(const b3Vector3** ppts, int n); + B3_DBVT_INLINE void Expand(const b3Vector3& e); + B3_DBVT_INLINE void SignedExpand(const b3Vector3& e); + B3_DBVT_INLINE bool Contain(const b3DbvtAabbMm& a) const; + B3_DBVT_INLINE int Classify(const b3Vector3& n, b3Scalar o, int s) const; + B3_DBVT_INLINE b3Scalar ProjectMinimum(const b3Vector3& v, unsigned signs) const; + B3_DBVT_INLINE friend bool b3Intersect(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b); + + B3_DBVT_INLINE friend bool b3Intersect(const b3DbvtAabbMm& a, + const b3Vector3& b); + + B3_DBVT_INLINE friend b3Scalar b3Proximity(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b); + B3_DBVT_INLINE friend int b3Select(const b3DbvtAabbMm& o, + const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b); + B3_DBVT_INLINE friend void b3Merge(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b, + b3DbvtAabbMm& r); + B3_DBVT_INLINE friend bool b3NotEqual(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b); + + B3_DBVT_INLINE b3Vector3& tMins() { return (mi); } + B3_DBVT_INLINE b3Vector3& tMaxs() { return (mx); } + private: - B3_DBVT_INLINE void AddSpan(const b3Vector3& d,b3Scalar& smi,b3Scalar& smx) const; + B3_DBVT_INLINE void AddSpan(const b3Vector3& d, b3Scalar& smi, b3Scalar& smx) const; + private: - b3Vector3 mi,mx; + b3Vector3 mi, mx; }; -// Types -typedef b3DbvtAabbMm b3DbvtVolume; +// Types +typedef b3DbvtAabbMm b3DbvtVolume; -/* b3DbvtNode */ -struct b3DbvtNode +/* b3DbvtNode */ +struct b3DbvtNode { - b3DbvtVolume volume; - b3DbvtNode* parent; - B3_DBVT_INLINE bool isleaf() const { return(childs[1]==0); } - B3_DBVT_INLINE bool isinternal() const { return(!isleaf()); } - union - { - b3DbvtNode* childs[2]; - void* data; - int dataAsInt; + b3DbvtVolume volume; + b3DbvtNode* parent; + B3_DBVT_INLINE bool isleaf() const { return (childs[1] == 0); } + B3_DBVT_INLINE bool isinternal() const { return (!isleaf()); } + union { + b3DbvtNode* childs[2]; + void* data; + int dataAsInt; }; }; ///The b3DynamicBvh class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree). ///This b3DynamicBvh is used for soft body collision detection and for the b3DynamicBvhBroadphase. It has a fast insert, remove and update of nodes. ///Unlike the b3QuantizedBvh, nodes can be dynamically moved around, which allows for change in topology of the underlying data structure. -struct b3DynamicBvh +struct b3DynamicBvh { - /* Stack element */ - struct sStkNN + /* Stack element */ + struct sStkNN { - const b3DbvtNode* a; - const b3DbvtNode* b; + const b3DbvtNode* a; + const b3DbvtNode* b; sStkNN() {} - sStkNN(const b3DbvtNode* na,const b3DbvtNode* nb) : a(na),b(nb) {} + sStkNN(const b3DbvtNode* na, const b3DbvtNode* nb) : a(na), b(nb) {} }; - struct sStkNP + struct sStkNP { - const b3DbvtNode* node; - int mask; - sStkNP(const b3DbvtNode* n,unsigned m) : node(n),mask(m) {} + const b3DbvtNode* node; + int mask; + sStkNP(const b3DbvtNode* n, unsigned m) : node(n), mask(m) {} }; - struct sStkNPS + struct sStkNPS { - const b3DbvtNode* node; - int mask; - b3Scalar value; + const b3DbvtNode* node; + int mask; + b3Scalar value; sStkNPS() {} - sStkNPS(const b3DbvtNode* n,unsigned m,b3Scalar v) : node(n),mask(m),value(v) {} + sStkNPS(const b3DbvtNode* n, unsigned m, b3Scalar v) : node(n), mask(m), value(v) {} }; - struct sStkCLN + struct sStkCLN { - const b3DbvtNode* node; - b3DbvtNode* parent; - sStkCLN(const b3DbvtNode* n,b3DbvtNode* p) : node(n),parent(p) {} + const b3DbvtNode* node; + b3DbvtNode* parent; + sStkCLN(const b3DbvtNode* n, b3DbvtNode* p) : node(n), parent(p) {} }; // Policies/Interfaces - /* ICollide */ - struct ICollide - { + /* ICollide */ + struct ICollide + { B3_DBVT_VIRTUAL_DTOR(ICollide) - B3_DBVT_VIRTUAL void Process(const b3DbvtNode*,const b3DbvtNode*) {} - B3_DBVT_VIRTUAL void Process(const b3DbvtNode*) {} - B3_DBVT_VIRTUAL void Process(const b3DbvtNode* n,b3Scalar) { Process(n); } - B3_DBVT_VIRTUAL bool Descent(const b3DbvtNode*) { return(true); } - B3_DBVT_VIRTUAL bool AllLeaves(const b3DbvtNode*) { return(true); } + B3_DBVT_VIRTUAL void Process(const b3DbvtNode*, const b3DbvtNode*) {} + B3_DBVT_VIRTUAL void Process(const b3DbvtNode*) {} + B3_DBVT_VIRTUAL void Process(const b3DbvtNode* n, b3Scalar) { Process(n); } + B3_DBVT_VIRTUAL bool Descent(const b3DbvtNode*) { return (true); } + B3_DBVT_VIRTUAL bool AllLeaves(const b3DbvtNode*) { return (true); } }; - /* IWriter */ - struct IWriter + /* IWriter */ + struct IWriter { virtual ~IWriter() {} - virtual void Prepare(const b3DbvtNode* root,int numnodes)=0; - virtual void WriteNode(const b3DbvtNode*,int index,int parent,int child0,int child1)=0; - virtual void WriteLeaf(const b3DbvtNode*,int index,int parent)=0; + virtual void Prepare(const b3DbvtNode* root, int numnodes) = 0; + virtual void WriteNode(const b3DbvtNode*, int index, int parent, int child0, int child1) = 0; + virtual void WriteLeaf(const b3DbvtNode*, int index, int parent) = 0; }; - /* IClone */ - struct IClone + /* IClone */ + struct IClone { - virtual ~IClone() {} - virtual void CloneLeaf(b3DbvtNode*) {} + virtual ~IClone() {} + virtual void CloneLeaf(b3DbvtNode*) {} }; // Constants - enum { - B3_SIMPLE_STACKSIZE = 64, - B3_DOUBLE_STACKSIZE = B3_SIMPLE_STACKSIZE*2 + enum + { + B3_SIMPLE_STACKSIZE = 64, + B3_DOUBLE_STACKSIZE = B3_SIMPLE_STACKSIZE * 2 }; // Fields - b3DbvtNode* m_root; - b3DbvtNode* m_free; - int m_lkhd; - int m_leaves; - unsigned m_opath; - - - b3AlignedObjectArray<sStkNN> m_stkStack; - mutable b3AlignedObjectArray<const b3DbvtNode*> m_rayTestStack; + b3DbvtNode* m_root; + b3DbvtNode* m_free; + int m_lkhd; + int m_leaves; + unsigned m_opath; + b3AlignedObjectArray<sStkNN> m_stkStack; + mutable b3AlignedObjectArray<const b3DbvtNode*> m_rayTestStack; // Methods b3DynamicBvh(); ~b3DynamicBvh(); - void clear(); - bool empty() const { return(0==m_root); } - void optimizeBottomUp(); - void optimizeTopDown(int bu_treshold=128); - void optimizeIncremental(int passes); - b3DbvtNode* insert(const b3DbvtVolume& box,void* data); - void update(b3DbvtNode* leaf,int lookahead=-1); - void update(b3DbvtNode* leaf,b3DbvtVolume& volume); - bool update(b3DbvtNode* leaf,b3DbvtVolume& volume,const b3Vector3& velocity,b3Scalar margin); - bool update(b3DbvtNode* leaf,b3DbvtVolume& volume,const b3Vector3& velocity); - bool update(b3DbvtNode* leaf,b3DbvtVolume& volume,b3Scalar margin); - void remove(b3DbvtNode* leaf); - void write(IWriter* iwriter) const; - void clone(b3DynamicBvh& dest,IClone* iclone=0) const; - static int maxdepth(const b3DbvtNode* node); - static int countLeaves(const b3DbvtNode* node); - static void extractLeaves(const b3DbvtNode* node,b3AlignedObjectArray<const b3DbvtNode*>& leaves); + void clear(); + bool empty() const { return (0 == m_root); } + void optimizeBottomUp(); + void optimizeTopDown(int bu_treshold = 128); + void optimizeIncremental(int passes); + b3DbvtNode* insert(const b3DbvtVolume& box, void* data); + void update(b3DbvtNode* leaf, int lookahead = -1); + void update(b3DbvtNode* leaf, b3DbvtVolume& volume); + bool update(b3DbvtNode* leaf, b3DbvtVolume& volume, const b3Vector3& velocity, b3Scalar margin); + bool update(b3DbvtNode* leaf, b3DbvtVolume& volume, const b3Vector3& velocity); + bool update(b3DbvtNode* leaf, b3DbvtVolume& volume, b3Scalar margin); + void remove(b3DbvtNode* leaf); + void write(IWriter* iwriter) const; + void clone(b3DynamicBvh& dest, IClone* iclone = 0) const; + static int maxdepth(const b3DbvtNode* node); + static int countLeaves(const b3DbvtNode* node); + static void extractLeaves(const b3DbvtNode* node, b3AlignedObjectArray<const b3DbvtNode*>& leaves); #if B3_DBVT_ENABLE_BENCHMARK - static void benchmark(); + static void benchmark(); #else - static void benchmark(){} + static void benchmark() + { + } #endif // B3_DBVT_IPOLICY must support ICollide policy/interface B3_DBVT_PREFIX - static void enumNodes( const b3DbvtNode* root, - B3_DBVT_IPOLICY); + static void enumNodes(const b3DbvtNode* root, + B3_DBVT_IPOLICY); B3_DBVT_PREFIX - static void enumLeaves( const b3DbvtNode* root, - B3_DBVT_IPOLICY); + static void enumLeaves(const b3DbvtNode* root, + B3_DBVT_IPOLICY); B3_DBVT_PREFIX - void collideTT( const b3DbvtNode* root0, - const b3DbvtNode* root1, - B3_DBVT_IPOLICY); + void collideTT(const b3DbvtNode* root0, + const b3DbvtNode* root1, + B3_DBVT_IPOLICY); B3_DBVT_PREFIX - void collideTTpersistentStack( const b3DbvtNode* root0, - const b3DbvtNode* root1, - B3_DBVT_IPOLICY); + void collideTTpersistentStack(const b3DbvtNode* root0, + const b3DbvtNode* root1, + B3_DBVT_IPOLICY); #if 0 B3_DBVT_PREFIX void collideTT( const b3DbvtNode* root0, @@ -322,71 +325,81 @@ struct b3DynamicBvh #endif B3_DBVT_PREFIX - void collideTV( const b3DbvtNode* root, - const b3DbvtVolume& volume, - B3_DBVT_IPOLICY) const; + void collideTV(const b3DbvtNode* root, + const b3DbvtVolume& volume, + B3_DBVT_IPOLICY) const; ///rayTest is a re-entrant ray test, and can be called in parallel as long as the b3AlignedAlloc is thread-safe (uses locking etc) ///rayTest is slower than rayTestInternal, because it builds a local stack, using memory allocations, and it recomputes signs/rayDirectionInverses each time B3_DBVT_PREFIX - static void rayTest( const b3DbvtNode* root, - const b3Vector3& rayFrom, - const b3Vector3& rayTo, - B3_DBVT_IPOLICY); + static void rayTest(const b3DbvtNode* root, + const b3Vector3& rayFrom, + const b3Vector3& rayTo, + B3_DBVT_IPOLICY); ///rayTestInternal is faster than rayTest, because it uses a persistent stack (to reduce dynamic memory allocations to a minimum) and it uses precomputed signs/rayInverseDirections ///rayTestInternal is used by b3DynamicBvhBroadphase to accelerate world ray casts B3_DBVT_PREFIX - void rayTestInternal( const b3DbvtNode* root, - const b3Vector3& rayFrom, - const b3Vector3& rayTo, - const b3Vector3& rayDirectionInverse, - unsigned int signs[3], - b3Scalar lambda_max, - const b3Vector3& aabbMin, - const b3Vector3& aabbMax, - B3_DBVT_IPOLICY) const; + void rayTestInternal(const b3DbvtNode* root, + const b3Vector3& rayFrom, + const b3Vector3& rayTo, + const b3Vector3& rayDirectionInverse, + unsigned int signs[3], + b3Scalar lambda_max, + const b3Vector3& aabbMin, + const b3Vector3& aabbMax, + B3_DBVT_IPOLICY) const; B3_DBVT_PREFIX - static void collideKDOP(const b3DbvtNode* root, - const b3Vector3* normals, - const b3Scalar* offsets, - int count, - B3_DBVT_IPOLICY); + static void collideKDOP(const b3DbvtNode* root, + const b3Vector3* normals, + const b3Scalar* offsets, + int count, + B3_DBVT_IPOLICY); B3_DBVT_PREFIX - static void collideOCL( const b3DbvtNode* root, - const b3Vector3* normals, - const b3Scalar* offsets, - const b3Vector3& sortaxis, - int count, - B3_DBVT_IPOLICY, - bool fullsort=true); + static void collideOCL(const b3DbvtNode* root, + const b3Vector3* normals, + const b3Scalar* offsets, + const b3Vector3& sortaxis, + int count, + B3_DBVT_IPOLICY, + bool fullsort = true); B3_DBVT_PREFIX - static void collideTU( const b3DbvtNode* root, - B3_DBVT_IPOLICY); - // Helpers - static B3_DBVT_INLINE int nearest(const int* i,const b3DynamicBvh::sStkNPS* a,b3Scalar v,int l,int h) + static void collideTU(const b3DbvtNode* root, + B3_DBVT_IPOLICY); + // Helpers + static B3_DBVT_INLINE int nearest(const int* i, const b3DynamicBvh::sStkNPS* a, b3Scalar v, int l, int h) { - int m=0; - while(l<h) + int m = 0; + while (l < h) { - m=(l+h)>>1; - if(a[i[m]].value>=v) l=m+1; else h=m; + m = (l + h) >> 1; + if (a[i[m]].value >= v) + l = m + 1; + else + h = m; } - return(h); + return (h); } - static B3_DBVT_INLINE int allocate( b3AlignedObjectArray<int>& ifree, - b3AlignedObjectArray<sStkNPS>& stock, - const sStkNPS& value) + static B3_DBVT_INLINE int allocate(b3AlignedObjectArray<int>& ifree, + b3AlignedObjectArray<sStkNPS>& stock, + const sStkNPS& value) { - int i; - if(ifree.size()>0) - { i=ifree[ifree.size()-1];ifree.pop_back();stock[i]=value; } + int i; + if (ifree.size() > 0) + { + i = ifree[ifree.size() - 1]; + ifree.pop_back(); + stock[i] = value; + } else - { i=stock.size();stock.push_back(value); } - return(i); + { + i = stock.size(); + stock.push_back(value); + } + return (i); } // private: - b3DynamicBvh(const b3DynamicBvh&) {} + b3DynamicBvh(const b3DynamicBvh&) {} }; // @@ -394,227 +407,252 @@ private: // // -inline b3DbvtAabbMm b3DbvtAabbMm::FromCE(const b3Vector3& c,const b3Vector3& e) +inline b3DbvtAabbMm b3DbvtAabbMm::FromCE(const b3Vector3& c, const b3Vector3& e) { b3DbvtAabbMm box; - box.mi=c-e;box.mx=c+e; - return(box); + box.mi = c - e; + box.mx = c + e; + return (box); } // -inline b3DbvtAabbMm b3DbvtAabbMm::FromCR(const b3Vector3& c,b3Scalar r) +inline b3DbvtAabbMm b3DbvtAabbMm::FromCR(const b3Vector3& c, b3Scalar r) { - return(FromCE(c,b3MakeVector3(r,r,r))); + return (FromCE(c, b3MakeVector3(r, r, r))); } // -inline b3DbvtAabbMm b3DbvtAabbMm::FromMM(const b3Vector3& mi,const b3Vector3& mx) +inline b3DbvtAabbMm b3DbvtAabbMm::FromMM(const b3Vector3& mi, const b3Vector3& mx) { b3DbvtAabbMm box; - box.mi=mi;box.mx=mx; - return(box); + box.mi = mi; + box.mx = mx; + return (box); } // -inline b3DbvtAabbMm b3DbvtAabbMm::FromPoints(const b3Vector3* pts,int n) +inline b3DbvtAabbMm b3DbvtAabbMm::FromPoints(const b3Vector3* pts, int n) { b3DbvtAabbMm box; - box.mi=box.mx=pts[0]; - for(int i=1;i<n;++i) + box.mi = box.mx = pts[0]; + for (int i = 1; i < n; ++i) { box.mi.setMin(pts[i]); box.mx.setMax(pts[i]); } - return(box); + return (box); } // -inline b3DbvtAabbMm b3DbvtAabbMm::FromPoints(const b3Vector3** ppts,int n) +inline b3DbvtAabbMm b3DbvtAabbMm::FromPoints(const b3Vector3** ppts, int n) { b3DbvtAabbMm box; - box.mi=box.mx=*ppts[0]; - for(int i=1;i<n;++i) + box.mi = box.mx = *ppts[0]; + for (int i = 1; i < n; ++i) { box.mi.setMin(*ppts[i]); box.mx.setMax(*ppts[i]); } - return(box); + return (box); } // -B3_DBVT_INLINE void b3DbvtAabbMm::Expand(const b3Vector3& e) +B3_DBVT_INLINE void b3DbvtAabbMm::Expand(const b3Vector3& e) { - mi-=e;mx+=e; + mi -= e; + mx += e; } // -B3_DBVT_INLINE void b3DbvtAabbMm::SignedExpand(const b3Vector3& e) +B3_DBVT_INLINE void b3DbvtAabbMm::SignedExpand(const b3Vector3& e) { - if(e.x>0) mx.setX(mx.x+e[0]); else mi.setX(mi.x+e[0]); - if(e.y>0) mx.setY(mx.y+e[1]); else mi.setY(mi.y+e[1]); - if(e.z>0) mx.setZ(mx.z+e[2]); else mi.setZ(mi.z+e[2]); + if (e.x > 0) + mx.setX(mx.x + e[0]); + else + mi.setX(mi.x + e[0]); + if (e.y > 0) + mx.setY(mx.y + e[1]); + else + mi.setY(mi.y + e[1]); + if (e.z > 0) + mx.setZ(mx.z + e[2]); + else + mi.setZ(mi.z + e[2]); } // -B3_DBVT_INLINE bool b3DbvtAabbMm::Contain(const b3DbvtAabbMm& a) const +B3_DBVT_INLINE bool b3DbvtAabbMm::Contain(const b3DbvtAabbMm& a) const { - return( (mi.x<=a.mi.x)&& - (mi.y<=a.mi.y)&& - (mi.z<=a.mi.z)&& - (mx.x>=a.mx.x)&& - (mx.y>=a.mx.y)&& - (mx.z>=a.mx.z)); + return ((mi.x <= a.mi.x) && + (mi.y <= a.mi.y) && + (mi.z <= a.mi.z) && + (mx.x >= a.mx.x) && + (mx.y >= a.mx.y) && + (mx.z >= a.mx.z)); } // -B3_DBVT_INLINE int b3DbvtAabbMm::Classify(const b3Vector3& n,b3Scalar o,int s) const +B3_DBVT_INLINE int b3DbvtAabbMm::Classify(const b3Vector3& n, b3Scalar o, int s) const { - b3Vector3 pi,px; - switch(s) + b3Vector3 pi, px; + switch (s) { - case (0+0+0): px=b3MakeVector3(mi.x,mi.y,mi.z); - pi=b3MakeVector3(mx.x,mx.y,mx.z);break; - case (1+0+0): px=b3MakeVector3(mx.x,mi.y,mi.z); - pi=b3MakeVector3(mi.x,mx.y,mx.z);break; - case (0+2+0): px=b3MakeVector3(mi.x,mx.y,mi.z); - pi=b3MakeVector3(mx.x,mi.y,mx.z);break; - case (1+2+0): px=b3MakeVector3(mx.x,mx.y,mi.z); - pi=b3MakeVector3(mi.x,mi.y,mx.z);break; - case (0+0+4): px=b3MakeVector3(mi.x,mi.y,mx.z); - pi=b3MakeVector3(mx.x,mx.y,mi.z);break; - case (1+0+4): px=b3MakeVector3(mx.x,mi.y,mx.z); - pi=b3MakeVector3(mi.x,mx.y,mi.z);break; - case (0+2+4): px=b3MakeVector3(mi.x,mx.y,mx.z); - pi=b3MakeVector3(mx.x,mi.y,mi.z);break; - case (1+2+4): px=b3MakeVector3(mx.x,mx.y,mx.z); - pi=b3MakeVector3(mi.x,mi.y,mi.z);break; + case (0 + 0 + 0): + px = b3MakeVector3(mi.x, mi.y, mi.z); + pi = b3MakeVector3(mx.x, mx.y, mx.z); + break; + case (1 + 0 + 0): + px = b3MakeVector3(mx.x, mi.y, mi.z); + pi = b3MakeVector3(mi.x, mx.y, mx.z); + break; + case (0 + 2 + 0): + px = b3MakeVector3(mi.x, mx.y, mi.z); + pi = b3MakeVector3(mx.x, mi.y, mx.z); + break; + case (1 + 2 + 0): + px = b3MakeVector3(mx.x, mx.y, mi.z); + pi = b3MakeVector3(mi.x, mi.y, mx.z); + break; + case (0 + 0 + 4): + px = b3MakeVector3(mi.x, mi.y, mx.z); + pi = b3MakeVector3(mx.x, mx.y, mi.z); + break; + case (1 + 0 + 4): + px = b3MakeVector3(mx.x, mi.y, mx.z); + pi = b3MakeVector3(mi.x, mx.y, mi.z); + break; + case (0 + 2 + 4): + px = b3MakeVector3(mi.x, mx.y, mx.z); + pi = b3MakeVector3(mx.x, mi.y, mi.z); + break; + case (1 + 2 + 4): + px = b3MakeVector3(mx.x, mx.y, mx.z); + pi = b3MakeVector3(mi.x, mi.y, mi.z); + break; } - if((b3Dot(n,px)+o)<0) return(-1); - if((b3Dot(n,pi)+o)>=0) return(+1); - return(0); + if ((b3Dot(n, px) + o) < 0) return (-1); + if ((b3Dot(n, pi) + o) >= 0) return (+1); + return (0); } // -B3_DBVT_INLINE b3Scalar b3DbvtAabbMm::ProjectMinimum(const b3Vector3& v,unsigned signs) const +B3_DBVT_INLINE b3Scalar b3DbvtAabbMm::ProjectMinimum(const b3Vector3& v, unsigned signs) const { - const b3Vector3* b[]={&mx,&mi}; - const b3Vector3 p = b3MakeVector3( b[(signs>>0)&1]->x, - b[(signs>>1)&1]->y, - b[(signs>>2)&1]->z); - return(b3Dot(p,v)); + const b3Vector3* b[] = {&mx, &mi}; + const b3Vector3 p = b3MakeVector3(b[(signs >> 0) & 1]->x, + b[(signs >> 1) & 1]->y, + b[(signs >> 2) & 1]->z); + return (b3Dot(p, v)); } // -B3_DBVT_INLINE void b3DbvtAabbMm::AddSpan(const b3Vector3& d,b3Scalar& smi,b3Scalar& smx) const +B3_DBVT_INLINE void b3DbvtAabbMm::AddSpan(const b3Vector3& d, b3Scalar& smi, b3Scalar& smx) const { - for(int i=0;i<3;++i) + for (int i = 0; i < 3; ++i) { - if(d[i]<0) - { smi+=mx[i]*d[i];smx+=mi[i]*d[i]; } + if (d[i] < 0) + { + smi += mx[i] * d[i]; + smx += mi[i] * d[i]; + } else - { smi+=mi[i]*d[i];smx+=mx[i]*d[i]; } + { + smi += mi[i] * d[i]; + smx += mx[i] * d[i]; + } } } // -B3_DBVT_INLINE bool b3Intersect( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b) +B3_DBVT_INLINE bool b3Intersect(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b) { -#if B3_DBVT_INT0_IMPL == B3_DBVT_IMPL_SSE - const __m128 rt(_mm_or_ps( _mm_cmplt_ps(_mm_load_ps(b.mx),_mm_load_ps(a.mi)), - _mm_cmplt_ps(_mm_load_ps(a.mx),_mm_load_ps(b.mi)))); -#if defined (_WIN32) - const __int32* pu((const __int32*)&rt); +#if B3_DBVT_INT0_IMPL == B3_DBVT_IMPL_SSE + const __m128 rt(_mm_or_ps(_mm_cmplt_ps(_mm_load_ps(b.mx), _mm_load_ps(a.mi)), + _mm_cmplt_ps(_mm_load_ps(a.mx), _mm_load_ps(b.mi)))); +#if defined(_WIN32) + const __int32* pu((const __int32*)&rt); #else - const int* pu((const int*)&rt); + const int* pu((const int*)&rt); #endif - return((pu[0]|pu[1]|pu[2])==0); + return ((pu[0] | pu[1] | pu[2]) == 0); #else - return( (a.mi.x<=b.mx.x)&& - (a.mx.x>=b.mi.x)&& - (a.mi.y<=b.mx.y)&& - (a.mx.y>=b.mi.y)&& - (a.mi.z<=b.mx.z)&& - (a.mx.z>=b.mi.z)); + return ((a.mi.x <= b.mx.x) && + (a.mx.x >= b.mi.x) && + (a.mi.y <= b.mx.y) && + (a.mx.y >= b.mi.y) && + (a.mi.z <= b.mx.z) && + (a.mx.z >= b.mi.z)); #endif } - - // -B3_DBVT_INLINE bool b3Intersect( const b3DbvtAabbMm& a, - const b3Vector3& b) +B3_DBVT_INLINE bool b3Intersect(const b3DbvtAabbMm& a, + const b3Vector3& b) { - return( (b.x>=a.mi.x)&& - (b.y>=a.mi.y)&& - (b.z>=a.mi.z)&& - (b.x<=a.mx.x)&& - (b.y<=a.mx.y)&& - (b.z<=a.mx.z)); + return ((b.x >= a.mi.x) && + (b.y >= a.mi.y) && + (b.z >= a.mi.z) && + (b.x <= a.mx.x) && + (b.y <= a.mx.y) && + (b.z <= a.mx.z)); } - - - - ////////////////////////////////////// - // -B3_DBVT_INLINE b3Scalar b3Proximity( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b) +B3_DBVT_INLINE b3Scalar b3Proximity(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b) { - const b3Vector3 d=(a.mi+a.mx)-(b.mi+b.mx); - return(b3Fabs(d.x)+b3Fabs(d.y)+b3Fabs(d.z)); + const b3Vector3 d = (a.mi + a.mx) - (b.mi + b.mx); + return (b3Fabs(d.x) + b3Fabs(d.y) + b3Fabs(d.z)); } - - // -B3_DBVT_INLINE int b3Select( const b3DbvtAabbMm& o, - const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b) +B3_DBVT_INLINE int b3Select(const b3DbvtAabbMm& o, + const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b) { -#if B3_DBVT_SELECT_IMPL == B3_DBVT_IMPL_SSE - -#if defined (_WIN32) - static B3_ATTRIBUTE_ALIGNED16(const unsigned __int32) mask[]={0x7fffffff,0x7fffffff,0x7fffffff,0x7fffffff}; +#if B3_DBVT_SELECT_IMPL == B3_DBVT_IMPL_SSE + +#if defined(_WIN32) + static B3_ATTRIBUTE_ALIGNED16(const unsigned __int32) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff}; #else - static B3_ATTRIBUTE_ALIGNED16(const unsigned int) mask[]={0x7fffffff,0x7fffffff,0x7fffffff,0x00000000 /*0x7fffffff*/}; + static B3_ATTRIBUTE_ALIGNED16(const unsigned int) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x00000000 /*0x7fffffff*/}; #endif ///@todo: the intrinsic version is 11% slower #if B3_DBVT_USE_INTRINSIC_SSE - union b3SSEUnion ///NOTE: if we use more intrinsics, move b3SSEUnion into the LinearMath directory + union b3SSEUnion ///NOTE: if we use more intrinsics, move b3SSEUnion into the LinearMath directory { - __m128 ssereg; - float floats[4]; - int ints[4]; + __m128 ssereg; + float floats[4]; + int ints[4]; }; - __m128 omi(_mm_load_ps(o.mi)); - omi=_mm_add_ps(omi,_mm_load_ps(o.mx)); - __m128 ami(_mm_load_ps(a.mi)); - ami=_mm_add_ps(ami,_mm_load_ps(a.mx)); - ami=_mm_sub_ps(ami,omi); - ami=_mm_and_ps(ami,_mm_load_ps((const float*)mask)); - __m128 bmi(_mm_load_ps(b.mi)); - bmi=_mm_add_ps(bmi,_mm_load_ps(b.mx)); - bmi=_mm_sub_ps(bmi,omi); - bmi=_mm_and_ps(bmi,_mm_load_ps((const float*)mask)); - __m128 t0(_mm_movehl_ps(ami,ami)); - ami=_mm_add_ps(ami,t0); - ami=_mm_add_ss(ami,_mm_shuffle_ps(ami,ami,1)); - __m128 t1(_mm_movehl_ps(bmi,bmi)); - bmi=_mm_add_ps(bmi,t1); - bmi=_mm_add_ss(bmi,_mm_shuffle_ps(bmi,bmi,1)); - + __m128 omi(_mm_load_ps(o.mi)); + omi = _mm_add_ps(omi, _mm_load_ps(o.mx)); + __m128 ami(_mm_load_ps(a.mi)); + ami = _mm_add_ps(ami, _mm_load_ps(a.mx)); + ami = _mm_sub_ps(ami, omi); + ami = _mm_and_ps(ami, _mm_load_ps((const float*)mask)); + __m128 bmi(_mm_load_ps(b.mi)); + bmi = _mm_add_ps(bmi, _mm_load_ps(b.mx)); + bmi = _mm_sub_ps(bmi, omi); + bmi = _mm_and_ps(bmi, _mm_load_ps((const float*)mask)); + __m128 t0(_mm_movehl_ps(ami, ami)); + ami = _mm_add_ps(ami, t0); + ami = _mm_add_ss(ami, _mm_shuffle_ps(ami, ami, 1)); + __m128 t1(_mm_movehl_ps(bmi, bmi)); + bmi = _mm_add_ps(bmi, t1); + bmi = _mm_add_ss(bmi, _mm_shuffle_ps(bmi, bmi, 1)); + b3SSEUnion tmp; - tmp.ssereg = _mm_cmple_ss(bmi,ami); - return tmp.ints[0]&1; + tmp.ssereg = _mm_cmple_ss(bmi, ami); + return tmp.ints[0] & 1; #else - B3_ATTRIBUTE_ALIGNED16(__int32 r[1]); + B3_ATTRIBUTE_ALIGNED16(__int32 r[1]); __asm { mov eax,o @@ -642,46 +680,52 @@ B3_DBVT_INLINE int b3Select( const b3DbvtAabbMm& o, cmpless xmm2,xmm1 movss r,xmm2 } - return(r[0]&1); + return (r[0] & 1); #endif #else - return(b3Proximity(o,a)<b3Proximity(o,b)?0:1); + return (b3Proximity(o, a) < b3Proximity(o, b) ? 0 : 1); #endif } // -B3_DBVT_INLINE void b3Merge( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b, - b3DbvtAabbMm& r) +B3_DBVT_INLINE void b3Merge(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b, + b3DbvtAabbMm& r) { -#if B3_DBVT_MERGE_IMPL==B3_DBVT_IMPL_SSE - __m128 ami(_mm_load_ps(a.mi)); - __m128 amx(_mm_load_ps(a.mx)); - __m128 bmi(_mm_load_ps(b.mi)); - __m128 bmx(_mm_load_ps(b.mx)); - ami=_mm_min_ps(ami,bmi); - amx=_mm_max_ps(amx,bmx); - _mm_store_ps(r.mi,ami); - _mm_store_ps(r.mx,amx); +#if B3_DBVT_MERGE_IMPL == B3_DBVT_IMPL_SSE + __m128 ami(_mm_load_ps(a.mi)); + __m128 amx(_mm_load_ps(a.mx)); + __m128 bmi(_mm_load_ps(b.mi)); + __m128 bmx(_mm_load_ps(b.mx)); + ami = _mm_min_ps(ami, bmi); + amx = _mm_max_ps(amx, bmx); + _mm_store_ps(r.mi, ami); + _mm_store_ps(r.mx, amx); #else - for(int i=0;i<3;++i) + for (int i = 0; i < 3; ++i) { - if(a.mi[i]<b.mi[i]) r.mi[i]=a.mi[i]; else r.mi[i]=b.mi[i]; - if(a.mx[i]>b.mx[i]) r.mx[i]=a.mx[i]; else r.mx[i]=b.mx[i]; + if (a.mi[i] < b.mi[i]) + r.mi[i] = a.mi[i]; + else + r.mi[i] = b.mi[i]; + if (a.mx[i] > b.mx[i]) + r.mx[i] = a.mx[i]; + else + r.mx[i] = b.mx[i]; } #endif } // -B3_DBVT_INLINE bool b3NotEqual( const b3DbvtAabbMm& a, - const b3DbvtAabbMm& b) +B3_DBVT_INLINE bool b3NotEqual(const b3DbvtAabbMm& a, + const b3DbvtAabbMm& b) { - return( (a.mi.x!=b.mi.x)|| - (a.mi.y!=b.mi.y)|| - (a.mi.z!=b.mi.z)|| - (a.mx.x!=b.mx.x)|| - (a.mx.y!=b.mx.y)|| - (a.mx.z!=b.mx.z)); + return ((a.mi.x != b.mi.x) || + (a.mi.y != b.mi.y) || + (a.mi.z != b.mi.z) || + (a.mx.x != b.mx.x) || + (a.mx.y != b.mx.y) || + (a.mx.z != b.mx.z)); } // @@ -690,162 +734,162 @@ B3_DBVT_INLINE bool b3NotEqual( const b3DbvtAabbMm& a, // B3_DBVT_PREFIX -inline void b3DynamicBvh::enumNodes( const b3DbvtNode* root, - B3_DBVT_IPOLICY) +inline void b3DynamicBvh::enumNodes(const b3DbvtNode* root, + B3_DBVT_IPOLICY) { B3_DBVT_CHECKTYPE - policy.Process(root); - if(root->isinternal()) + policy.Process(root); + if (root->isinternal()) { - enumNodes(root->childs[0],policy); - enumNodes(root->childs[1],policy); + enumNodes(root->childs[0], policy); + enumNodes(root->childs[1], policy); } } // B3_DBVT_PREFIX -inline void b3DynamicBvh::enumLeaves( const b3DbvtNode* root, - B3_DBVT_IPOLICY) +inline void b3DynamicBvh::enumLeaves(const b3DbvtNode* root, + B3_DBVT_IPOLICY) { B3_DBVT_CHECKTYPE - if(root->isinternal()) - { - enumLeaves(root->childs[0],policy); - enumLeaves(root->childs[1],policy); - } - else - { - policy.Process(root); - } + if (root->isinternal()) + { + enumLeaves(root->childs[0], policy); + enumLeaves(root->childs[1], policy); + } + else + { + policy.Process(root); + } } // B3_DBVT_PREFIX -inline void b3DynamicBvh::collideTT( const b3DbvtNode* root0, - const b3DbvtNode* root1, - B3_DBVT_IPOLICY) +inline void b3DynamicBvh::collideTT(const b3DbvtNode* root0, + const b3DbvtNode* root1, + B3_DBVT_IPOLICY) { B3_DBVT_CHECKTYPE - if(root0&&root1) + if (root0 && root1) + { + int depth = 1; + int treshold = B3_DOUBLE_STACKSIZE - 4; + b3AlignedObjectArray<sStkNN> stkStack; + stkStack.resize(B3_DOUBLE_STACKSIZE); + stkStack[0] = sStkNN(root0, root1); + do { - int depth=1; - int treshold=B3_DOUBLE_STACKSIZE-4; - b3AlignedObjectArray<sStkNN> stkStack; - stkStack.resize(B3_DOUBLE_STACKSIZE); - stkStack[0]=sStkNN(root0,root1); - do { - sStkNN p=stkStack[--depth]; - if(depth>treshold) + sStkNN p = stkStack[--depth]; + if (depth > treshold) + { + stkStack.resize(stkStack.size() * 2); + treshold = stkStack.size() - 4; + } + if (p.a == p.b) + { + if (p.a->isinternal()) { - stkStack.resize(stkStack.size()*2); - treshold=stkStack.size()-4; + stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]); + stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]); } - if(p.a==p.b) + } + else if (b3Intersect(p.a->volume, p.b->volume)) + { + if (p.a->isinternal()) { - if(p.a->isinternal()) + if (p.b->isinternal()) { - stkStack[depth++]=sStkNN(p.a->childs[0],p.a->childs[0]); - stkStack[depth++]=sStkNN(p.a->childs[1],p.a->childs[1]); - stkStack[depth++]=sStkNN(p.a->childs[0],p.a->childs[1]); + stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]); + } + else + { + stkStack[depth++] = sStkNN(p.a->childs[0], p.b); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b); } } - else if(b3Intersect(p.a->volume,p.b->volume)) + else { - if(p.a->isinternal()) + if (p.b->isinternal()) { - if(p.b->isinternal()) - { - stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[0]); - stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[0]); - stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[1]); - stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[1]); - } - else - { - stkStack[depth++]=sStkNN(p.a->childs[0],p.b); - stkStack[depth++]=sStkNN(p.a->childs[1],p.b); - } + stkStack[depth++] = sStkNN(p.a, p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a, p.b->childs[1]); } else { - if(p.b->isinternal()) - { - stkStack[depth++]=sStkNN(p.a,p.b->childs[0]); - stkStack[depth++]=sStkNN(p.a,p.b->childs[1]); - } - else - { - policy.Process(p.a,p.b); - } + policy.Process(p.a, p.b); } } - } while(depth); - } + } + } while (depth); + } } - - B3_DBVT_PREFIX -inline void b3DynamicBvh::collideTTpersistentStack( const b3DbvtNode* root0, - const b3DbvtNode* root1, - B3_DBVT_IPOLICY) +inline void b3DynamicBvh::collideTTpersistentStack(const b3DbvtNode* root0, + const b3DbvtNode* root1, + B3_DBVT_IPOLICY) { B3_DBVT_CHECKTYPE - if(root0&&root1) + if (root0 && root1) + { + int depth = 1; + int treshold = B3_DOUBLE_STACKSIZE - 4; + + m_stkStack.resize(B3_DOUBLE_STACKSIZE); + m_stkStack[0] = sStkNN(root0, root1); + do { - int depth=1; - int treshold=B3_DOUBLE_STACKSIZE-4; - - m_stkStack.resize(B3_DOUBLE_STACKSIZE); - m_stkStack[0]=sStkNN(root0,root1); - do { - sStkNN p=m_stkStack[--depth]; - if(depth>treshold) + sStkNN p = m_stkStack[--depth]; + if (depth > treshold) + { + m_stkStack.resize(m_stkStack.size() * 2); + treshold = m_stkStack.size() - 4; + } + if (p.a == p.b) + { + if (p.a->isinternal()) { - m_stkStack.resize(m_stkStack.size()*2); - treshold=m_stkStack.size()-4; + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]); + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]); } - if(p.a==p.b) + } + else if (b3Intersect(p.a->volume, p.b->volume)) + { + if (p.a->isinternal()) { - if(p.a->isinternal()) + if (p.b->isinternal()) + { + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]); + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]); + } + else { - m_stkStack[depth++]=sStkNN(p.a->childs[0],p.a->childs[0]); - m_stkStack[depth++]=sStkNN(p.a->childs[1],p.a->childs[1]); - m_stkStack[depth++]=sStkNN(p.a->childs[0],p.a->childs[1]); + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b); } } - else if(b3Intersect(p.a->volume,p.b->volume)) + else { - if(p.a->isinternal()) + if (p.b->isinternal()) { - if(p.b->isinternal()) - { - m_stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[0]); - m_stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[0]); - m_stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[1]); - m_stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[1]); - } - else - { - m_stkStack[depth++]=sStkNN(p.a->childs[0],p.b); - m_stkStack[depth++]=sStkNN(p.a->childs[1],p.b); - } + m_stkStack[depth++] = sStkNN(p.a, p.b->childs[0]); + m_stkStack[depth++] = sStkNN(p.a, p.b->childs[1]); } else { - if(p.b->isinternal()) - { - m_stkStack[depth++]=sStkNN(p.a,p.b->childs[0]); - m_stkStack[depth++]=sStkNN(p.a,p.b->childs[1]); - } - else - { - policy.Process(p.a,p.b); - } + policy.Process(p.a, p.b); } } - } while(depth); - } + } + } while (depth); + } } #if 0 @@ -915,337 +959,356 @@ inline void b3DynamicBvh::collideTT( const b3DbvtNode* root0, const b3Transform xform=xform0.inverse()*xform1; collideTT(root0,root1,xform,policy); } -#endif +#endif // B3_DBVT_PREFIX -inline void b3DynamicBvh::collideTV( const b3DbvtNode* root, - const b3DbvtVolume& vol, - B3_DBVT_IPOLICY) const +inline void b3DynamicBvh::collideTV(const b3DbvtNode* root, + const b3DbvtVolume& vol, + B3_DBVT_IPOLICY) const { B3_DBVT_CHECKTYPE - if(root) + if (root) + { + B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) + volume(vol); + b3AlignedObjectArray<const b3DbvtNode*> stack; + stack.resize(0); + stack.reserve(B3_SIMPLE_STACKSIZE); + stack.push_back(root); + do { - B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) volume(vol); - b3AlignedObjectArray<const b3DbvtNode*> stack; - stack.resize(0); - stack.reserve(B3_SIMPLE_STACKSIZE); - stack.push_back(root); - do { - const b3DbvtNode* n=stack[stack.size()-1]; - stack.pop_back(); - if(b3Intersect(n->volume,volume)) + const b3DbvtNode* n = stack[stack.size() - 1]; + stack.pop_back(); + if (b3Intersect(n->volume, volume)) + { + if (n->isinternal()) { - if(n->isinternal()) - { - stack.push_back(n->childs[0]); - stack.push_back(n->childs[1]); - } - else - { - policy.Process(n); - } + stack.push_back(n->childs[0]); + stack.push_back(n->childs[1]); } - } while(stack.size()>0); - } + else + { + policy.Process(n); + } + } + } while (stack.size() > 0); + } } B3_DBVT_PREFIX -inline void b3DynamicBvh::rayTestInternal( const b3DbvtNode* root, - const b3Vector3& rayFrom, - const b3Vector3& rayTo, - const b3Vector3& rayDirectionInverse, - unsigned int signs[3], - b3Scalar lambda_max, - const b3Vector3& aabbMin, - const b3Vector3& aabbMax, - B3_DBVT_IPOLICY) const +inline void b3DynamicBvh::rayTestInternal(const b3DbvtNode* root, + const b3Vector3& rayFrom, + const b3Vector3& rayTo, + const b3Vector3& rayDirectionInverse, + unsigned int signs[3], + b3Scalar lambda_max, + const b3Vector3& aabbMin, + const b3Vector3& aabbMax, + B3_DBVT_IPOLICY) const { - (void) rayTo; + (void)rayTo; B3_DBVT_CHECKTYPE - if(root) + if (root) { - int depth=1; - int treshold=B3_DOUBLE_STACKSIZE-2; - b3AlignedObjectArray<const b3DbvtNode*>& stack = m_rayTestStack; + int depth = 1; + int treshold = B3_DOUBLE_STACKSIZE - 2; + b3AlignedObjectArray<const b3DbvtNode*>& stack = m_rayTestStack; stack.resize(B3_DOUBLE_STACKSIZE); - stack[0]=root; + stack[0] = root; b3Vector3 bounds[2]; - do + do { - const b3DbvtNode* node=stack[--depth]; - bounds[0] = node->volume.Mins()-aabbMax; - bounds[1] = node->volume.Maxs()-aabbMin; - b3Scalar tmin=1.f,lambda_min=0.f; - unsigned int result1=false; - result1 = b3RayAabb2(rayFrom,rayDirectionInverse,signs,bounds,tmin,lambda_min,lambda_max); - if(result1) + const b3DbvtNode* node = stack[--depth]; + bounds[0] = node->volume.Mins() - aabbMax; + bounds[1] = node->volume.Maxs() - aabbMin; + b3Scalar tmin = 1.f, lambda_min = 0.f; + unsigned int result1 = false; + result1 = b3RayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max); + if (result1) { - if(node->isinternal()) + if (node->isinternal()) { - if(depth>treshold) + if (depth > treshold) { - stack.resize(stack.size()*2); - treshold=stack.size()-2; + stack.resize(stack.size() * 2); + treshold = stack.size() - 2; } - stack[depth++]=node->childs[0]; - stack[depth++]=node->childs[1]; + stack[depth++] = node->childs[0]; + stack[depth++] = node->childs[1]; } else { policy.Process(node); } } - } while(depth); + } while (depth); } } // B3_DBVT_PREFIX -inline void b3DynamicBvh::rayTest( const b3DbvtNode* root, - const b3Vector3& rayFrom, - const b3Vector3& rayTo, - B3_DBVT_IPOLICY) +inline void b3DynamicBvh::rayTest(const b3DbvtNode* root, + const b3Vector3& rayFrom, + const b3Vector3& rayTo, + B3_DBVT_IPOLICY) { B3_DBVT_CHECKTYPE - if(root) - { - b3Vector3 rayDir = (rayTo-rayFrom); - rayDir.normalize (); + if (root) + { + b3Vector3 rayDir = (rayTo - rayFrom); + rayDir.normalize(); - ///what about division by zero? --> just set rayDirection[i] to INF/B3_LARGE_FLOAT - b3Vector3 rayDirectionInverse; - rayDirectionInverse[0] = rayDir[0] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[0]; - rayDirectionInverse[1] = rayDir[1] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[1]; - rayDirectionInverse[2] = rayDir[2] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[2]; - unsigned int signs[3] = { rayDirectionInverse[0] < 0.0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0}; + ///what about division by zero? --> just set rayDirection[i] to INF/B3_LARGE_FLOAT + b3Vector3 rayDirectionInverse; + rayDirectionInverse[0] = rayDir[0] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[0]; + rayDirectionInverse[1] = rayDir[1] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[1]; + rayDirectionInverse[2] = rayDir[2] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[2]; + unsigned int signs[3] = {rayDirectionInverse[0] < 0.0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0}; - b3Scalar lambda_max = rayDir.dot(rayTo-rayFrom); + b3Scalar lambda_max = rayDir.dot(rayTo - rayFrom); #ifdef COMPARE_BTRAY_AABB2 - b3Vector3 resultNormal; -#endif//COMPARE_BTRAY_AABB2 - - b3AlignedObjectArray<const b3DbvtNode*> stack; + b3Vector3 resultNormal; +#endif //COMPARE_BTRAY_AABB2 - int depth=1; - int treshold=B3_DOUBLE_STACKSIZE-2; + b3AlignedObjectArray<const b3DbvtNode*> stack; - stack.resize(B3_DOUBLE_STACKSIZE); - stack[0]=root; - b3Vector3 bounds[2]; - do { - const b3DbvtNode* node=stack[--depth]; + int depth = 1; + int treshold = B3_DOUBLE_STACKSIZE - 2; - bounds[0] = node->volume.Mins(); - bounds[1] = node->volume.Maxs(); - - b3Scalar tmin=1.f,lambda_min=0.f; - unsigned int result1 = b3RayAabb2(rayFrom,rayDirectionInverse,signs,bounds,tmin,lambda_min,lambda_max); + stack.resize(B3_DOUBLE_STACKSIZE); + stack[0] = root; + b3Vector3 bounds[2]; + do + { + const b3DbvtNode* node = stack[--depth]; + + bounds[0] = node->volume.Mins(); + bounds[1] = node->volume.Maxs(); + + b3Scalar tmin = 1.f, lambda_min = 0.f; + unsigned int result1 = b3RayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max); #ifdef COMPARE_BTRAY_AABB2 - b3Scalar param=1.f; - bool result2 = b3RayAabb(rayFrom,rayTo,node->volume.Mins(),node->volume.Maxs(),param,resultNormal); - b3Assert(result1 == result2); -#endif //TEST_BTRAY_AABB2 + b3Scalar param = 1.f; + bool result2 = b3RayAabb(rayFrom, rayTo, node->volume.Mins(), node->volume.Maxs(), param, resultNormal); + b3Assert(result1 == result2); +#endif //TEST_BTRAY_AABB2 - if(result1) + if (result1) + { + if (node->isinternal()) { - if(node->isinternal()) - { - if(depth>treshold) - { - stack.resize(stack.size()*2); - treshold=stack.size()-2; - } - stack[depth++]=node->childs[0]; - stack[depth++]=node->childs[1]; - } - else + if (depth > treshold) { - policy.Process(node); + stack.resize(stack.size() * 2); + treshold = stack.size() - 2; } + stack[depth++] = node->childs[0]; + stack[depth++] = node->childs[1]; } - } while(depth); - - } + else + { + policy.Process(node); + } + } + } while (depth); + } } // B3_DBVT_PREFIX -inline void b3DynamicBvh::collideKDOP(const b3DbvtNode* root, - const b3Vector3* normals, - const b3Scalar* offsets, - int count, - B3_DBVT_IPOLICY) +inline void b3DynamicBvh::collideKDOP(const b3DbvtNode* root, + const b3Vector3* normals, + const b3Scalar* offsets, + int count, + B3_DBVT_IPOLICY) { B3_DBVT_CHECKTYPE - if(root) + if (root) + { + const int inside = (1 << count) - 1; + b3AlignedObjectArray<sStkNP> stack; + int signs[sizeof(unsigned) * 8]; + b3Assert(count < int(sizeof(signs) / sizeof(signs[0]))); + for (int i = 0; i < count; ++i) { - const int inside=(1<<count)-1; - b3AlignedObjectArray<sStkNP> stack; - int signs[sizeof(unsigned)*8]; - b3Assert(count<int (sizeof(signs)/sizeof(signs[0]))); - for(int i=0;i<count;++i) + signs[i] = ((normals[i].x >= 0) ? 1 : 0) + + ((normals[i].y >= 0) ? 2 : 0) + + ((normals[i].z >= 0) ? 4 : 0); + } + stack.reserve(B3_SIMPLE_STACKSIZE); + stack.push_back(sStkNP(root, 0)); + do + { + sStkNP se = stack[stack.size() - 1]; + bool out = false; + stack.pop_back(); + for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1) { - signs[i]= ((normals[i].x>=0)?1:0)+ - ((normals[i].y>=0)?2:0)+ - ((normals[i].z>=0)?4:0); - } - stack.reserve(B3_SIMPLE_STACKSIZE); - stack.push_back(sStkNP(root,0)); - do { - sStkNP se=stack[stack.size()-1]; - bool out=false; - stack.pop_back(); - for(int i=0,j=1;(!out)&&(i<count);++i,j<<=1) + if (0 == (se.mask & j)) { - if(0==(se.mask&j)) + const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]); + switch (side) { - const int side=se.node->volume.Classify(normals[i],offsets[i],signs[i]); - switch(side) - { - case -1: out=true;break; - case +1: se.mask|=j;break; - } + case -1: + out = true; + break; + case +1: + se.mask |= j; + break; } } - if(!out) + } + if (!out) + { + if ((se.mask != inside) && (se.node->isinternal())) { - if((se.mask!=inside)&&(se.node->isinternal())) - { - stack.push_back(sStkNP(se.node->childs[0],se.mask)); - stack.push_back(sStkNP(se.node->childs[1],se.mask)); - } - else - { - if(policy.AllLeaves(se.node)) enumLeaves(se.node,policy); - } + stack.push_back(sStkNP(se.node->childs[0], se.mask)); + stack.push_back(sStkNP(se.node->childs[1], se.mask)); } - } while(stack.size()); - } + else + { + if (policy.AllLeaves(se.node)) enumLeaves(se.node, policy); + } + } + } while (stack.size()); + } } // B3_DBVT_PREFIX -inline void b3DynamicBvh::collideOCL( const b3DbvtNode* root, - const b3Vector3* normals, - const b3Scalar* offsets, - const b3Vector3& sortaxis, - int count, - B3_DBVT_IPOLICY, - bool fsort) +inline void b3DynamicBvh::collideOCL(const b3DbvtNode* root, + const b3Vector3* normals, + const b3Scalar* offsets, + const b3Vector3& sortaxis, + int count, + B3_DBVT_IPOLICY, + bool fsort) { B3_DBVT_CHECKTYPE - if(root) + if (root) + { + const unsigned srtsgns = (sortaxis[0] >= 0 ? 1 : 0) + + (sortaxis[1] >= 0 ? 2 : 0) + + (sortaxis[2] >= 0 ? 4 : 0); + const int inside = (1 << count) - 1; + b3AlignedObjectArray<sStkNPS> stock; + b3AlignedObjectArray<int> ifree; + b3AlignedObjectArray<int> stack; + int signs[sizeof(unsigned) * 8]; + b3Assert(count < int(sizeof(signs) / sizeof(signs[0]))); + for (int i = 0; i < count; ++i) { - const unsigned srtsgns=(sortaxis[0]>=0?1:0)+ - (sortaxis[1]>=0?2:0)+ - (sortaxis[2]>=0?4:0); - const int inside=(1<<count)-1; - b3AlignedObjectArray<sStkNPS> stock; - b3AlignedObjectArray<int> ifree; - b3AlignedObjectArray<int> stack; - int signs[sizeof(unsigned)*8]; - b3Assert(count<int (sizeof(signs)/sizeof(signs[0]))); - for(int i=0;i<count;++i) + signs[i] = ((normals[i].x >= 0) ? 1 : 0) + + ((normals[i].y >= 0) ? 2 : 0) + + ((normals[i].z >= 0) ? 4 : 0); + } + stock.reserve(B3_SIMPLE_STACKSIZE); + stack.reserve(B3_SIMPLE_STACKSIZE); + ifree.reserve(B3_SIMPLE_STACKSIZE); + stack.push_back(allocate(ifree, stock, sStkNPS(root, 0, root->volume.ProjectMinimum(sortaxis, srtsgns)))); + do + { + const int id = stack[stack.size() - 1]; + sStkNPS se = stock[id]; + stack.pop_back(); + ifree.push_back(id); + if (se.mask != inside) { - signs[i]= ((normals[i].x>=0)?1:0)+ - ((normals[i].y>=0)?2:0)+ - ((normals[i].z>=0)?4:0); - } - stock.reserve(B3_SIMPLE_STACKSIZE); - stack.reserve(B3_SIMPLE_STACKSIZE); - ifree.reserve(B3_SIMPLE_STACKSIZE); - stack.push_back(allocate(ifree,stock,sStkNPS(root,0,root->volume.ProjectMinimum(sortaxis,srtsgns)))); - do { - const int id=stack[stack.size()-1]; - sStkNPS se=stock[id]; - stack.pop_back();ifree.push_back(id); - if(se.mask!=inside) + bool out = false; + for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1) { - bool out=false; - for(int i=0,j=1;(!out)&&(i<count);++i,j<<=1) + if (0 == (se.mask & j)) { - if(0==(se.mask&j)) + const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]); + switch (side) { - const int side=se.node->volume.Classify(normals[i],offsets[i],signs[i]); - switch(side) - { - case -1: out=true;break; - case +1: se.mask|=j;break; - } + case -1: + out = true; + break; + case +1: + se.mask |= j; + break; } } - if(out) continue; } - if(policy.Descent(se.node)) + if (out) continue; + } + if (policy.Descent(se.node)) + { + if (se.node->isinternal()) { - if(se.node->isinternal()) + const b3DbvtNode* pns[] = {se.node->childs[0], se.node->childs[1]}; + sStkNPS nes[] = {sStkNPS(pns[0], se.mask, pns[0]->volume.ProjectMinimum(sortaxis, srtsgns)), + sStkNPS(pns[1], se.mask, pns[1]->volume.ProjectMinimum(sortaxis, srtsgns))}; + const int q = nes[0].value < nes[1].value ? 1 : 0; + int j = stack.size(); + if (fsort && (j > 0)) { - const b3DbvtNode* pns[]={ se.node->childs[0],se.node->childs[1]}; - sStkNPS nes[]={ sStkNPS(pns[0],se.mask,pns[0]->volume.ProjectMinimum(sortaxis,srtsgns)), - sStkNPS(pns[1],se.mask,pns[1]->volume.ProjectMinimum(sortaxis,srtsgns))}; - const int q=nes[0].value<nes[1].value?1:0; - int j=stack.size(); - if(fsort&&(j>0)) - { - /* Insert 0 */ - j=nearest(&stack[0],&stock[0],nes[q].value,0,stack.size()); - stack.push_back(0); + /* Insert 0 */ + j = nearest(&stack[0], &stock[0], nes[q].value, 0, stack.size()); + stack.push_back(0); #if B3_DBVT_USE_MEMMOVE - memmove(&stack[j+1],&stack[j],sizeof(int)*(stack.size()-j-1)); + memmove(&stack[j + 1], &stack[j], sizeof(int) * (stack.size() - j - 1)); #else - for(int k=stack.size()-1;k>j;--k) stack[k]=stack[k-1]; + for (int k = stack.size() - 1; k > j; --k) stack[k] = stack[k - 1]; #endif - stack[j]=allocate(ifree,stock,nes[q]); - /* Insert 1 */ - j=nearest(&stack[0],&stock[0],nes[1-q].value,j,stack.size()); - stack.push_back(0); + stack[j] = allocate(ifree, stock, nes[q]); + /* Insert 1 */ + j = nearest(&stack[0], &stock[0], nes[1 - q].value, j, stack.size()); + stack.push_back(0); #if B3_DBVT_USE_MEMMOVE - memmove(&stack[j+1],&stack[j],sizeof(int)*(stack.size()-j-1)); + memmove(&stack[j + 1], &stack[j], sizeof(int) * (stack.size() - j - 1)); #else - for(int k=stack.size()-1;k>j;--k) stack[k]=stack[k-1]; + for (int k = stack.size() - 1; k > j; --k) stack[k] = stack[k - 1]; #endif - stack[j]=allocate(ifree,stock,nes[1-q]); - } - else - { - stack.push_back(allocate(ifree,stock,nes[q])); - stack.push_back(allocate(ifree,stock,nes[1-q])); - } + stack[j] = allocate(ifree, stock, nes[1 - q]); } else { - policy.Process(se.node,se.value); + stack.push_back(allocate(ifree, stock, nes[q])); + stack.push_back(allocate(ifree, stock, nes[1 - q])); } } - } while(stack.size()); - } + else + { + policy.Process(se.node, se.value); + } + } + } while (stack.size()); + } } // B3_DBVT_PREFIX -inline void b3DynamicBvh::collideTU( const b3DbvtNode* root, - B3_DBVT_IPOLICY) +inline void b3DynamicBvh::collideTU(const b3DbvtNode* root, + B3_DBVT_IPOLICY) { B3_DBVT_CHECKTYPE - if(root) + if (root) + { + b3AlignedObjectArray<const b3DbvtNode*> stack; + stack.reserve(B3_SIMPLE_STACKSIZE); + stack.push_back(root); + do { - b3AlignedObjectArray<const b3DbvtNode*> stack; - stack.reserve(B3_SIMPLE_STACKSIZE); - stack.push_back(root); - do { - const b3DbvtNode* n=stack[stack.size()-1]; - stack.pop_back(); - if(policy.Descent(n)) + const b3DbvtNode* n = stack[stack.size() - 1]; + stack.pop_back(); + if (policy.Descent(n)) + { + if (n->isinternal()) { - if(n->isinternal()) - { stack.push_back(n->childs[0]);stack.push_back(n->childs[1]); } - else - { policy.Process(n); } + stack.push_back(n->childs[0]); + stack.push_back(n->childs[1]); } - } while(stack.size()>0); - } + else + { + policy.Process(n); + } + } + } while (stack.size() > 0); + } } // diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.cpp b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.cpp index bc150955b8..dea2ddb0f2 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.cpp +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.cpp @@ -22,28 +22,27 @@ subject to the following restrictions: // Profiling // -#if B3_DBVT_BP_PROFILE||B3_DBVT_BP_ENABLE_BENCHMARK +#if B3_DBVT_BP_PROFILE || B3_DBVT_BP_ENABLE_BENCHMARK #include <stdio.h> #endif #if B3_DBVT_BP_PROFILE -struct b3ProfileScope +struct b3ProfileScope { - __forceinline b3ProfileScope(b3Clock& clock,unsigned long& value) : - m_clock(&clock),m_value(&value),m_base(clock.getTimeMicroseconds()) + __forceinline b3ProfileScope(b3Clock& clock, unsigned long& value) : m_clock(&clock), m_value(&value), m_base(clock.getTimeMicroseconds()) { } __forceinline ~b3ProfileScope() { - (*m_value)+=m_clock->getTimeMicroseconds()-m_base; + (*m_value) += m_clock->getTimeMicroseconds() - m_base; } - b3Clock* m_clock; - unsigned long* m_value; - unsigned long m_base; + b3Clock* m_clock; + unsigned long* m_value; + unsigned long m_base; }; -#define b3SPC(_value_) b3ProfileScope spc_scope(m_clock,_value_) +#define b3SPC(_value_) b3ProfileScope spc_scope(m_clock, _value_) #else -#define b3SPC(_value_) +#define b3SPC(_value_) #endif // @@ -52,66 +51,75 @@ struct b3ProfileScope // template <typename T> -static inline void b3ListAppend(T* item,T*& list) +static inline void b3ListAppend(T* item, T*& list) { - item->links[0]=0; - item->links[1]=list; - if(list) list->links[0]=item; - list=item; + item->links[0] = 0; + item->links[1] = list; + if (list) list->links[0] = item; + list = item; } // template <typename T> -static inline void b3ListRemove(T* item,T*& list) +static inline void b3ListRemove(T* item, T*& list) { - if(item->links[0]) item->links[0]->links[1]=item->links[1]; else list=item->links[1]; - if(item->links[1]) item->links[1]->links[0]=item->links[0]; + if (item->links[0]) + item->links[0]->links[1] = item->links[1]; + else + list = item->links[1]; + if (item->links[1]) item->links[1]->links[0] = item->links[0]; } // template <typename T> -static inline int b3ListCount(T* root) +static inline int b3ListCount(T* root) { - int n=0; - while(root) { ++n;root=root->links[1]; } - return(n); + int n = 0; + while (root) + { + ++n; + root = root->links[1]; + } + return (n); } // template <typename T> -static inline void b3Clear(T& value) +static inline void b3Clear(T& value) { - static const struct ZeroDummy : T {} zerodummy; - value=zerodummy; + static const struct ZeroDummy : T + { + } zerodummy; + value = zerodummy; } // // Colliders // -/* Tree collider */ -struct b3DbvtTreeCollider : b3DynamicBvh::ICollide +/* Tree collider */ +struct b3DbvtTreeCollider : b3DynamicBvh::ICollide { - b3DynamicBvhBroadphase* pbp; - b3DbvtProxy* proxy; + b3DynamicBvhBroadphase* pbp; + b3DbvtProxy* proxy; b3DbvtTreeCollider(b3DynamicBvhBroadphase* p) : pbp(p) {} - void Process(const b3DbvtNode* na,const b3DbvtNode* nb) + void Process(const b3DbvtNode* na, const b3DbvtNode* nb) { - if(na!=nb) + if (na != nb) { - b3DbvtProxy* pa=(b3DbvtProxy*)na->data; - b3DbvtProxy* pb=(b3DbvtProxy*)nb->data; + b3DbvtProxy* pa = (b3DbvtProxy*)na->data; + b3DbvtProxy* pb = (b3DbvtProxy*)nb->data; #if B3_DBVT_BP_SORTPAIRS - if(pa->m_uniqueId>pb->m_uniqueId) - b3Swap(pa,pb); + if (pa->m_uniqueId > pb->m_uniqueId) + b3Swap(pa, pb); #endif - pbp->m_paircache->addOverlappingPair(pa->getUid(),pb->getUid()); + pbp->m_paircache->addOverlappingPair(pa->getUid(), pb->getUid()); ++pbp->m_newpairs; } } - void Process(const b3DbvtNode* n) + void Process(const b3DbvtNode* n) { - Process(n,proxy->leaf); + Process(n, proxy->leaf); } }; @@ -122,26 +130,26 @@ struct b3DbvtTreeCollider : b3DynamicBvh::ICollide // b3DynamicBvhBroadphase::b3DynamicBvhBroadphase(int proxyCapacity, b3OverlappingPairCache* paircache) { - m_deferedcollide = false; - m_needcleanup = true; - m_releasepaircache = (paircache!=0)?false:true; - m_prediction = 0; - m_stageCurrent = 0; - m_fixedleft = 0; - m_fupdates = 1; - m_dupdates = 0; - m_cupdates = 10; - m_newpairs = 1; - m_updates_call = 0; - m_updates_done = 0; - m_updates_ratio = 0; - m_paircache = paircache? paircache : new(b3AlignedAlloc(sizeof(b3HashedOverlappingPairCache),16)) b3HashedOverlappingPairCache(); - - m_pid = 0; - m_cid = 0; - for(int i=0;i<=STAGECOUNT;++i) + m_deferedcollide = false; + m_needcleanup = true; + m_releasepaircache = (paircache != 0) ? false : true; + m_prediction = 0; + m_stageCurrent = 0; + m_fixedleft = 0; + m_fupdates = 1; + m_dupdates = 0; + m_cupdates = 10; + m_newpairs = 1; + m_updates_call = 0; + m_updates_done = 0; + m_updates_ratio = 0; + m_paircache = paircache ? paircache : new (b3AlignedAlloc(sizeof(b3HashedOverlappingPairCache), 16)) b3HashedOverlappingPairCache(); + + m_pid = 0; + m_cid = 0; + for (int i = 0; i <= STAGECOUNT; ++i) { - m_stageRoots[i]=0; + m_stageRoots[i] = 0; } #if B3_DBVT_BP_PROFILE b3Clear(m_profiling); @@ -152,7 +160,7 @@ b3DynamicBvhBroadphase::b3DynamicBvhBroadphase(int proxyCapacity, b3OverlappingP // b3DynamicBvhBroadphase::~b3DynamicBvhBroadphase() { - if(m_releasepaircache) + if (m_releasepaircache) { m_paircache->~b3OverlappingPairCache(); b3AlignedFree(m_paircache); @@ -160,53 +168,53 @@ b3DynamicBvhBroadphase::~b3DynamicBvhBroadphase() } // -b3BroadphaseProxy* b3DynamicBvhBroadphase::createProxy( const b3Vector3& aabbMin, - const b3Vector3& aabbMax, - int objectId, - void* userPtr, - int collisionFilterGroup, - int collisionFilterMask) +b3BroadphaseProxy* b3DynamicBvhBroadphase::createProxy(const b3Vector3& aabbMin, + const b3Vector3& aabbMax, + int objectId, + void* userPtr, + int collisionFilterGroup, + int collisionFilterMask) { b3DbvtProxy* mem = &m_proxies[objectId]; - b3DbvtProxy* proxy=new(mem) b3DbvtProxy( aabbMin,aabbMax,userPtr, - collisionFilterGroup, - collisionFilterMask); + b3DbvtProxy* proxy = new (mem) b3DbvtProxy(aabbMin, aabbMax, userPtr, + collisionFilterGroup, + collisionFilterMask); - b3DbvtAabbMm aabb = b3DbvtVolume::FromMM(aabbMin,aabbMax); + b3DbvtAabbMm aabb = b3DbvtVolume::FromMM(aabbMin, aabbMax); //bproxy->aabb = b3DbvtVolume::FromMM(aabbMin,aabbMax); - proxy->stage = m_stageCurrent; - proxy->m_uniqueId = objectId; - proxy->leaf = m_sets[0].insert(aabb,proxy); - b3ListAppend(proxy,m_stageRoots[m_stageCurrent]); - if(!m_deferedcollide) + proxy->stage = m_stageCurrent; + proxy->m_uniqueId = objectId; + proxy->leaf = m_sets[0].insert(aabb, proxy); + b3ListAppend(proxy, m_stageRoots[m_stageCurrent]); + if (!m_deferedcollide) { - b3DbvtTreeCollider collider(this); - collider.proxy=proxy; - m_sets[0].collideTV(m_sets[0].m_root,aabb,collider); - m_sets[1].collideTV(m_sets[1].m_root,aabb,collider); + b3DbvtTreeCollider collider(this); + collider.proxy = proxy; + m_sets[0].collideTV(m_sets[0].m_root, aabb, collider); + m_sets[1].collideTV(m_sets[1].m_root, aabb, collider); } - return(proxy); + return (proxy); } // -void b3DynamicBvhBroadphase::destroyProxy( b3BroadphaseProxy* absproxy, - b3Dispatcher* dispatcher) +void b3DynamicBvhBroadphase::destroyProxy(b3BroadphaseProxy* absproxy, + b3Dispatcher* dispatcher) { - b3DbvtProxy* proxy=(b3DbvtProxy*)absproxy; - if(proxy->stage==STAGECOUNT) + b3DbvtProxy* proxy = (b3DbvtProxy*)absproxy; + if (proxy->stage == STAGECOUNT) m_sets[1].remove(proxy->leaf); else m_sets[0].remove(proxy->leaf); - b3ListRemove(proxy,m_stageRoots[proxy->stage]); - m_paircache->removeOverlappingPairsContainingProxy(proxy->getUid(),dispatcher); - - m_needcleanup=true; + b3ListRemove(proxy, m_stageRoots[proxy->stage]); + m_paircache->removeOverlappingPairsContainingProxy(proxy->getUid(), dispatcher); + + m_needcleanup = true; } -void b3DynamicBvhBroadphase::getAabb(int objectId,b3Vector3& aabbMin, b3Vector3& aabbMax ) const +void b3DynamicBvhBroadphase::getAabb(int objectId, b3Vector3& aabbMin, b3Vector3& aabbMax) const { - const b3DbvtProxy* proxy=&m_proxies[objectId]; + const b3DbvtProxy* proxy = &m_proxies[objectId]; aabbMin = proxy->m_aabbMin; aabbMax = proxy->m_aabbMax; } @@ -219,235 +227,223 @@ void b3DynamicBvhBroadphase::getAabb(b3BroadphaseProxy* absproxy,b3Vector3& aabb } */ - -struct BroadphaseRayTester : b3DynamicBvh::ICollide +struct BroadphaseRayTester : b3DynamicBvh::ICollide { b3BroadphaseRayCallback& m_rayCallback; BroadphaseRayTester(b3BroadphaseRayCallback& orgCallback) - :m_rayCallback(orgCallback) + : m_rayCallback(orgCallback) { } - void Process(const b3DbvtNode* leaf) + void Process(const b3DbvtNode* leaf) { - b3DbvtProxy* proxy=(b3DbvtProxy*)leaf->data; + b3DbvtProxy* proxy = (b3DbvtProxy*)leaf->data; m_rayCallback.process(proxy); } -}; +}; -void b3DynamicBvhBroadphase::rayTest(const b3Vector3& rayFrom,const b3Vector3& rayTo, b3BroadphaseRayCallback& rayCallback,const b3Vector3& aabbMin,const b3Vector3& aabbMax) +void b3DynamicBvhBroadphase::rayTest(const b3Vector3& rayFrom, const b3Vector3& rayTo, b3BroadphaseRayCallback& rayCallback, const b3Vector3& aabbMin, const b3Vector3& aabbMax) { BroadphaseRayTester callback(rayCallback); - m_sets[0].rayTestInternal( m_sets[0].m_root, - rayFrom, - rayTo, - rayCallback.m_rayDirectionInverse, - rayCallback.m_signs, - rayCallback.m_lambda_max, - aabbMin, - aabbMax, - callback); - - m_sets[1].rayTestInternal( m_sets[1].m_root, - rayFrom, - rayTo, - rayCallback.m_rayDirectionInverse, - rayCallback.m_signs, - rayCallback.m_lambda_max, - aabbMin, - aabbMax, - callback); - + m_sets[0].rayTestInternal(m_sets[0].m_root, + rayFrom, + rayTo, + rayCallback.m_rayDirectionInverse, + rayCallback.m_signs, + rayCallback.m_lambda_max, + aabbMin, + aabbMax, + callback); + + m_sets[1].rayTestInternal(m_sets[1].m_root, + rayFrom, + rayTo, + rayCallback.m_rayDirectionInverse, + rayCallback.m_signs, + rayCallback.m_lambda_max, + aabbMin, + aabbMax, + callback); } - -struct BroadphaseAabbTester : b3DynamicBvh::ICollide +struct BroadphaseAabbTester : b3DynamicBvh::ICollide { b3BroadphaseAabbCallback& m_aabbCallback; BroadphaseAabbTester(b3BroadphaseAabbCallback& orgCallback) - :m_aabbCallback(orgCallback) + : m_aabbCallback(orgCallback) { } - void Process(const b3DbvtNode* leaf) + void Process(const b3DbvtNode* leaf) { - b3DbvtProxy* proxy=(b3DbvtProxy*)leaf->data; + b3DbvtProxy* proxy = (b3DbvtProxy*)leaf->data; m_aabbCallback.process(proxy); } -}; +}; -void b3DynamicBvhBroadphase::aabbTest(const b3Vector3& aabbMin,const b3Vector3& aabbMax,b3BroadphaseAabbCallback& aabbCallback) +void b3DynamicBvhBroadphase::aabbTest(const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3BroadphaseAabbCallback& aabbCallback) { BroadphaseAabbTester callback(aabbCallback); - const B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) bounds=b3DbvtVolume::FromMM(aabbMin,aabbMax); - //process all children, that overlap with the given AABB bounds - m_sets[0].collideTV(m_sets[0].m_root,bounds,callback); - m_sets[1].collideTV(m_sets[1].m_root,bounds,callback); - + const B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) bounds = b3DbvtVolume::FromMM(aabbMin, aabbMax); + //process all children, that overlap with the given AABB bounds + m_sets[0].collideTV(m_sets[0].m_root, bounds, callback); + m_sets[1].collideTV(m_sets[1].m_root, bounds, callback); } - - // -void b3DynamicBvhBroadphase::setAabb(int objectId, - const b3Vector3& aabbMin, - const b3Vector3& aabbMax, - b3Dispatcher* /*dispatcher*/) +void b3DynamicBvhBroadphase::setAabb(int objectId, + const b3Vector3& aabbMin, + const b3Vector3& aabbMax, + b3Dispatcher* /*dispatcher*/) { - b3DbvtProxy* proxy=&m_proxies[objectId]; -// b3DbvtProxy* proxy=(b3DbvtProxy*)absproxy; - B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) aabb=b3DbvtVolume::FromMM(aabbMin,aabbMax); + b3DbvtProxy* proxy = &m_proxies[objectId]; + // b3DbvtProxy* proxy=(b3DbvtProxy*)absproxy; + B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) + aabb = b3DbvtVolume::FromMM(aabbMin, aabbMax); #if B3_DBVT_BP_PREVENTFALSEUPDATE - if(b3NotEqual(aabb,proxy->leaf->volume)) + if (b3NotEqual(aabb, proxy->leaf->volume)) #endif { - bool docollide=false; - if(proxy->stage==STAGECOUNT) - {/* fixed -> dynamic set */ + bool docollide = false; + if (proxy->stage == STAGECOUNT) + { /* fixed -> dynamic set */ m_sets[1].remove(proxy->leaf); - proxy->leaf=m_sets[0].insert(aabb,proxy); - docollide=true; + proxy->leaf = m_sets[0].insert(aabb, proxy); + docollide = true; } else - {/* dynamic set */ + { /* dynamic set */ ++m_updates_call; - if(b3Intersect(proxy->leaf->volume,aabb)) - {/* Moving */ - - const b3Vector3 delta=aabbMin-proxy->m_aabbMin; - b3Vector3 velocity(((proxy->m_aabbMax-proxy->m_aabbMin)/2)*m_prediction); - if(delta[0]<0) velocity[0]=-velocity[0]; - if(delta[1]<0) velocity[1]=-velocity[1]; - if(delta[2]<0) velocity[2]=-velocity[2]; - if ( -#ifdef B3_DBVT_BP_MARGIN - m_sets[0].update(proxy->leaf,aabb,velocity,B3_DBVT_BP_MARGIN) + if (b3Intersect(proxy->leaf->volume, aabb)) + { /* Moving */ + + const b3Vector3 delta = aabbMin - proxy->m_aabbMin; + b3Vector3 velocity(((proxy->m_aabbMax - proxy->m_aabbMin) / 2) * m_prediction); + if (delta[0] < 0) velocity[0] = -velocity[0]; + if (delta[1] < 0) velocity[1] = -velocity[1]; + if (delta[2] < 0) velocity[2] = -velocity[2]; + if ( +#ifdef B3_DBVT_BP_MARGIN + m_sets[0].update(proxy->leaf, aabb, velocity, B3_DBVT_BP_MARGIN) #else - m_sets[0].update(proxy->leaf,aabb,velocity) + m_sets[0].update(proxy->leaf, aabb, velocity) #endif - ) + ) { ++m_updates_done; - docollide=true; + docollide = true; } } else - {/* Teleporting */ - m_sets[0].update(proxy->leaf,aabb); + { /* Teleporting */ + m_sets[0].update(proxy->leaf, aabb); ++m_updates_done; - docollide=true; - } + docollide = true; + } } - b3ListRemove(proxy,m_stageRoots[proxy->stage]); + b3ListRemove(proxy, m_stageRoots[proxy->stage]); proxy->m_aabbMin = aabbMin; proxy->m_aabbMax = aabbMax; - proxy->stage = m_stageCurrent; - b3ListAppend(proxy,m_stageRoots[m_stageCurrent]); - if(docollide) + proxy->stage = m_stageCurrent; + b3ListAppend(proxy, m_stageRoots[m_stageCurrent]); + if (docollide) { - m_needcleanup=true; - if(!m_deferedcollide) + m_needcleanup = true; + if (!m_deferedcollide) { - b3DbvtTreeCollider collider(this); - m_sets[1].collideTTpersistentStack(m_sets[1].m_root,proxy->leaf,collider); - m_sets[0].collideTTpersistentStack(m_sets[0].m_root,proxy->leaf,collider); + b3DbvtTreeCollider collider(this); + m_sets[1].collideTTpersistentStack(m_sets[1].m_root, proxy->leaf, collider); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, proxy->leaf, collider); } - } + } } } - // -void b3DynamicBvhBroadphase::setAabbForceUpdate( b3BroadphaseProxy* absproxy, - const b3Vector3& aabbMin, - const b3Vector3& aabbMax, - b3Dispatcher* /*dispatcher*/) +void b3DynamicBvhBroadphase::setAabbForceUpdate(b3BroadphaseProxy* absproxy, + const b3Vector3& aabbMin, + const b3Vector3& aabbMax, + b3Dispatcher* /*dispatcher*/) { - b3DbvtProxy* proxy=(b3DbvtProxy*)absproxy; - B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) aabb=b3DbvtVolume::FromMM(aabbMin,aabbMax); - bool docollide=false; - if(proxy->stage==STAGECOUNT) - {/* fixed -> dynamic set */ + b3DbvtProxy* proxy = (b3DbvtProxy*)absproxy; + B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) + aabb = b3DbvtVolume::FromMM(aabbMin, aabbMax); + bool docollide = false; + if (proxy->stage == STAGECOUNT) + { /* fixed -> dynamic set */ m_sets[1].remove(proxy->leaf); - proxy->leaf=m_sets[0].insert(aabb,proxy); - docollide=true; + proxy->leaf = m_sets[0].insert(aabb, proxy); + docollide = true; } else - {/* dynamic set */ + { /* dynamic set */ ++m_updates_call; - /* Teleporting */ - m_sets[0].update(proxy->leaf,aabb); + /* Teleporting */ + m_sets[0].update(proxy->leaf, aabb); ++m_updates_done; - docollide=true; + docollide = true; } - b3ListRemove(proxy,m_stageRoots[proxy->stage]); + b3ListRemove(proxy, m_stageRoots[proxy->stage]); proxy->m_aabbMin = aabbMin; proxy->m_aabbMax = aabbMax; - proxy->stage = m_stageCurrent; - b3ListAppend(proxy,m_stageRoots[m_stageCurrent]); - if(docollide) + proxy->stage = m_stageCurrent; + b3ListAppend(proxy, m_stageRoots[m_stageCurrent]); + if (docollide) { - m_needcleanup=true; - if(!m_deferedcollide) + m_needcleanup = true; + if (!m_deferedcollide) { - b3DbvtTreeCollider collider(this); - m_sets[1].collideTTpersistentStack(m_sets[1].m_root,proxy->leaf,collider); - m_sets[0].collideTTpersistentStack(m_sets[0].m_root,proxy->leaf,collider); + b3DbvtTreeCollider collider(this); + m_sets[1].collideTTpersistentStack(m_sets[1].m_root, proxy->leaf, collider); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, proxy->leaf, collider); } - } + } } // -void b3DynamicBvhBroadphase::calculateOverlappingPairs(b3Dispatcher* dispatcher) +void b3DynamicBvhBroadphase::calculateOverlappingPairs(b3Dispatcher* dispatcher) { collide(dispatcher); #if B3_DBVT_BP_PROFILE - if(0==(m_pid%B3_DBVT_BP_PROFILING_RATE)) - { - printf("fixed(%u) dynamics(%u) pairs(%u)\r\n",m_sets[1].m_leaves,m_sets[0].m_leaves,m_paircache->getNumOverlappingPairs()); - unsigned int total=m_profiling.m_total; - if(total<=0) total=1; - printf("ddcollide: %u%% (%uus)\r\n",(50+m_profiling.m_ddcollide*100)/total,m_profiling.m_ddcollide/B3_DBVT_BP_PROFILING_RATE); - printf("fdcollide: %u%% (%uus)\r\n",(50+m_profiling.m_fdcollide*100)/total,m_profiling.m_fdcollide/B3_DBVT_BP_PROFILING_RATE); - printf("cleanup: %u%% (%uus)\r\n",(50+m_profiling.m_cleanup*100)/total,m_profiling.m_cleanup/B3_DBVT_BP_PROFILING_RATE); - printf("total: %uus\r\n",total/B3_DBVT_BP_PROFILING_RATE); - const unsigned long sum=m_profiling.m_ddcollide+ - m_profiling.m_fdcollide+ - m_profiling.m_cleanup; - printf("leaked: %u%% (%uus)\r\n",100-((50+sum*100)/total),(total-sum)/B3_DBVT_BP_PROFILING_RATE); - printf("job counts: %u%%\r\n",(m_profiling.m_jobcount*100)/((m_sets[0].m_leaves+m_sets[1].m_leaves)*B3_DBVT_BP_PROFILING_RATE)); + if (0 == (m_pid % B3_DBVT_BP_PROFILING_RATE)) + { + printf("fixed(%u) dynamics(%u) pairs(%u)\r\n", m_sets[1].m_leaves, m_sets[0].m_leaves, m_paircache->getNumOverlappingPairs()); + unsigned int total = m_profiling.m_total; + if (total <= 0) total = 1; + printf("ddcollide: %u%% (%uus)\r\n", (50 + m_profiling.m_ddcollide * 100) / total, m_profiling.m_ddcollide / B3_DBVT_BP_PROFILING_RATE); + printf("fdcollide: %u%% (%uus)\r\n", (50 + m_profiling.m_fdcollide * 100) / total, m_profiling.m_fdcollide / B3_DBVT_BP_PROFILING_RATE); + printf("cleanup: %u%% (%uus)\r\n", (50 + m_profiling.m_cleanup * 100) / total, m_profiling.m_cleanup / B3_DBVT_BP_PROFILING_RATE); + printf("total: %uus\r\n", total / B3_DBVT_BP_PROFILING_RATE); + const unsigned long sum = m_profiling.m_ddcollide + + m_profiling.m_fdcollide + + m_profiling.m_cleanup; + printf("leaked: %u%% (%uus)\r\n", 100 - ((50 + sum * 100) / total), (total - sum) / B3_DBVT_BP_PROFILING_RATE); + printf("job counts: %u%%\r\n", (m_profiling.m_jobcount * 100) / ((m_sets[0].m_leaves + m_sets[1].m_leaves) * B3_DBVT_BP_PROFILING_RATE)); b3Clear(m_profiling); m_clock.reset(); } #endif performDeferredRemoval(dispatcher); - } void b3DynamicBvhBroadphase::performDeferredRemoval(b3Dispatcher* dispatcher) { - if (m_paircache->hasDeferredRemoval()) { - - b3BroadphasePairArray& overlappingPairArray = m_paircache->getOverlappingPairArray(); + b3BroadphasePairArray& overlappingPairArray = m_paircache->getOverlappingPairArray(); //perform a sort, to find duplicates and to sort 'invalid' pairs to the end overlappingPairArray.quickSort(b3BroadphasePairSortPredicate()); int invalidPair = 0; - int i; - b3BroadphasePair previousPair = b3MakeBroadphasePair(-1,-1); - - - - for (i=0;i<overlappingPairArray.size();i++) + b3BroadphasePair previousPair = b3MakeBroadphasePair(-1, -1); + + for (i = 0; i < overlappingPairArray.size(); i++) { - b3BroadphasePair& pair = overlappingPairArray[i]; bool isDuplicate = (pair == previousPair); @@ -459,33 +455,34 @@ void b3DynamicBvhBroadphase::performDeferredRemoval(b3Dispatcher* dispatcher) if (!isDuplicate) { //important to perform AABB check that is consistent with the broadphase - b3DbvtProxy* pa=&m_proxies[pair.x]; - b3DbvtProxy* pb=&m_proxies[pair.y]; - bool hasOverlap = b3Intersect(pa->leaf->volume,pb->leaf->volume); + b3DbvtProxy* pa = &m_proxies[pair.x]; + b3DbvtProxy* pb = &m_proxies[pair.y]; + bool hasOverlap = b3Intersect(pa->leaf->volume, pb->leaf->volume); if (hasOverlap) { needsRemoval = false; - } else + } + else { needsRemoval = true; } - } else + } + else { //remove duplicate needsRemoval = true; //should have no algorithm } - + if (needsRemoval) { - m_paircache->cleanOverlappingPair(pair,dispatcher); + m_paircache->cleanOverlappingPair(pair, dispatcher); pair.x = -1; pair.y = -1; invalidPair++; - } - + } } //perform a sort, to sort 'invalid' pairs to the end @@ -495,7 +492,7 @@ void b3DynamicBvhBroadphase::performDeferredRemoval(b3Dispatcher* dispatcher) } // -void b3DynamicBvhBroadphase::collide(b3Dispatcher* dispatcher) +void b3DynamicBvhBroadphase::collide(b3Dispatcher* dispatcher) { /*printf("---------------------------------------------------------\n"); printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves); @@ -512,285 +509,293 @@ void b3DynamicBvhBroadphase::collide(b3Dispatcher* dispatcher) } */ - - b3SPC(m_profiling.m_total); - /* optimize */ - m_sets[0].optimizeIncremental(1+(m_sets[0].m_leaves*m_dupdates)/100); - if(m_fixedleft) + /* optimize */ + m_sets[0].optimizeIncremental(1 + (m_sets[0].m_leaves * m_dupdates) / 100); + if (m_fixedleft) { - const int count=1+(m_sets[1].m_leaves*m_fupdates)/100; - m_sets[1].optimizeIncremental(1+(m_sets[1].m_leaves*m_fupdates)/100); - m_fixedleft=b3Max<int>(0,m_fixedleft-count); + const int count = 1 + (m_sets[1].m_leaves * m_fupdates) / 100; + m_sets[1].optimizeIncremental(1 + (m_sets[1].m_leaves * m_fupdates) / 100); + m_fixedleft = b3Max<int>(0, m_fixedleft - count); } - /* dynamic -> fixed set */ - m_stageCurrent=(m_stageCurrent+1)%STAGECOUNT; - b3DbvtProxy* current=m_stageRoots[m_stageCurrent]; - if(current) + /* dynamic -> fixed set */ + m_stageCurrent = (m_stageCurrent + 1) % STAGECOUNT; + b3DbvtProxy* current = m_stageRoots[m_stageCurrent]; + if (current) { - b3DbvtTreeCollider collider(this); - do { - b3DbvtProxy* next=current->links[1]; - b3ListRemove(current,m_stageRoots[current->stage]); - b3ListAppend(current,m_stageRoots[STAGECOUNT]); + b3DbvtTreeCollider collider(this); + do + { + b3DbvtProxy* next = current->links[1]; + b3ListRemove(current, m_stageRoots[current->stage]); + b3ListAppend(current, m_stageRoots[STAGECOUNT]); #if B3_DBVT_BP_ACCURATESLEEPING - m_paircache->removeOverlappingPairsContainingProxy(current,dispatcher); - collider.proxy=current; - b3DynamicBvh::collideTV(m_sets[0].m_root,current->aabb,collider); - b3DynamicBvh::collideTV(m_sets[1].m_root,current->aabb,collider); + m_paircache->removeOverlappingPairsContainingProxy(current, dispatcher); + collider.proxy = current; + b3DynamicBvh::collideTV(m_sets[0].m_root, current->aabb, collider); + b3DynamicBvh::collideTV(m_sets[1].m_root, current->aabb, collider); #endif m_sets[0].remove(current->leaf); - B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) curAabb=b3DbvtVolume::FromMM(current->m_aabbMin,current->m_aabbMax); - current->leaf = m_sets[1].insert(curAabb,current); - current->stage = STAGECOUNT; - current = next; - } while(current); - m_fixedleft=m_sets[1].m_leaves; - m_needcleanup=true; + B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) + curAabb = b3DbvtVolume::FromMM(current->m_aabbMin, current->m_aabbMax); + current->leaf = m_sets[1].insert(curAabb, current); + current->stage = STAGECOUNT; + current = next; + } while (current); + m_fixedleft = m_sets[1].m_leaves; + m_needcleanup = true; } - /* collide dynamics */ + /* collide dynamics */ { - b3DbvtTreeCollider collider(this); - if(m_deferedcollide) + b3DbvtTreeCollider collider(this); + if (m_deferedcollide) { b3SPC(m_profiling.m_fdcollide); - m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[1].m_root,collider); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[1].m_root, collider); } - if(m_deferedcollide) + if (m_deferedcollide) { b3SPC(m_profiling.m_ddcollide); - m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[0].m_root,collider); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[0].m_root, collider); } } - /* clean up */ - if(m_needcleanup) + /* clean up */ + if (m_needcleanup) { b3SPC(m_profiling.m_cleanup); - b3BroadphasePairArray& pairs=m_paircache->getOverlappingPairArray(); - if(pairs.size()>0) + b3BroadphasePairArray& pairs = m_paircache->getOverlappingPairArray(); + if (pairs.size() > 0) { - - int ni=b3Min(pairs.size(),b3Max<int>(m_newpairs,(pairs.size()*m_cupdates)/100)); - for(int i=0;i<ni;++i) + int ni = b3Min(pairs.size(), b3Max<int>(m_newpairs, (pairs.size() * m_cupdates) / 100)); + for (int i = 0; i < ni; ++i) { - b3BroadphasePair& p=pairs[(m_cid+i)%pairs.size()]; - b3DbvtProxy* pa=&m_proxies[p.x]; - b3DbvtProxy* pb=&m_proxies[p.y]; - if(!b3Intersect(pa->leaf->volume,pb->leaf->volume)) + b3BroadphasePair& p = pairs[(m_cid + i) % pairs.size()]; + b3DbvtProxy* pa = &m_proxies[p.x]; + b3DbvtProxy* pb = &m_proxies[p.y]; + if (!b3Intersect(pa->leaf->volume, pb->leaf->volume)) { #if B3_DBVT_BP_SORTPAIRS - if(pa->m_uniqueId>pb->m_uniqueId) - b3Swap(pa,pb); + if (pa->m_uniqueId > pb->m_uniqueId) + b3Swap(pa, pb); #endif - m_paircache->removeOverlappingPair(pa->getUid(),pb->getUid(),dispatcher); - --ni;--i; + m_paircache->removeOverlappingPair(pa->getUid(), pb->getUid(), dispatcher); + --ni; + --i; } } - if(pairs.size()>0) m_cid=(m_cid+ni)%pairs.size(); else m_cid=0; + if (pairs.size() > 0) + m_cid = (m_cid + ni) % pairs.size(); + else + m_cid = 0; } } ++m_pid; - m_newpairs=1; - m_needcleanup=false; - if(m_updates_call>0) - { m_updates_ratio=m_updates_done/(b3Scalar)m_updates_call; } + m_newpairs = 1; + m_needcleanup = false; + if (m_updates_call > 0) + { + m_updates_ratio = m_updates_done / (b3Scalar)m_updates_call; + } else - { m_updates_ratio=0; } - m_updates_done/=2; - m_updates_call/=2; + { + m_updates_ratio = 0; + } + m_updates_done /= 2; + m_updates_call /= 2; } // -void b3DynamicBvhBroadphase::optimize() +void b3DynamicBvhBroadphase::optimize() { m_sets[0].optimizeTopDown(); m_sets[1].optimizeTopDown(); } // -b3OverlappingPairCache* b3DynamicBvhBroadphase::getOverlappingPairCache() +b3OverlappingPairCache* b3DynamicBvhBroadphase::getOverlappingPairCache() { - return(m_paircache); + return (m_paircache); } // -const b3OverlappingPairCache* b3DynamicBvhBroadphase::getOverlappingPairCache() const +const b3OverlappingPairCache* b3DynamicBvhBroadphase::getOverlappingPairCache() const { - return(m_paircache); + return (m_paircache); } // -void b3DynamicBvhBroadphase::getBroadphaseAabb(b3Vector3& aabbMin,b3Vector3& aabbMax) const +void b3DynamicBvhBroadphase::getBroadphaseAabb(b3Vector3& aabbMin, b3Vector3& aabbMax) const { + B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) + bounds; - B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume) bounds; - - if(!m_sets[0].empty()) - if(!m_sets[1].empty()) b3Merge( m_sets[0].m_root->volume, - m_sets[1].m_root->volume,bounds); + if (!m_sets[0].empty()) + if (!m_sets[1].empty()) + b3Merge(m_sets[0].m_root->volume, + m_sets[1].m_root->volume, bounds); else - bounds=m_sets[0].m_root->volume; - else if(!m_sets[1].empty()) bounds=m_sets[1].m_root->volume; + bounds = m_sets[0].m_root->volume; + else if (!m_sets[1].empty()) + bounds = m_sets[1].m_root->volume; else - bounds=b3DbvtVolume::FromCR(b3MakeVector3(0,0,0),0); - aabbMin=bounds.Mins(); - aabbMax=bounds.Maxs(); + bounds = b3DbvtVolume::FromCR(b3MakeVector3(0, 0, 0), 0); + aabbMin = bounds.Mins(); + aabbMax = bounds.Maxs(); } void b3DynamicBvhBroadphase::resetPool(b3Dispatcher* dispatcher) { - int totalObjects = m_sets[0].m_leaves + m_sets[1].m_leaves; if (!totalObjects) { //reset internal dynamic tree data structures m_sets[0].clear(); m_sets[1].clear(); - - m_deferedcollide = false; - m_needcleanup = true; - m_stageCurrent = 0; - m_fixedleft = 0; - m_fupdates = 1; - m_dupdates = 0; - m_cupdates = 10; - m_newpairs = 1; - m_updates_call = 0; - m_updates_done = 0; - m_updates_ratio = 0; - - m_pid = 0; - m_cid = 0; - for(int i=0;i<=STAGECOUNT;++i) + + m_deferedcollide = false; + m_needcleanup = true; + m_stageCurrent = 0; + m_fixedleft = 0; + m_fupdates = 1; + m_dupdates = 0; + m_cupdates = 10; + m_newpairs = 1; + m_updates_call = 0; + m_updates_done = 0; + m_updates_ratio = 0; + + m_pid = 0; + m_cid = 0; + for (int i = 0; i <= STAGECOUNT; ++i) { - m_stageRoots[i]=0; + m_stageRoots[i] = 0; } } } // -void b3DynamicBvhBroadphase::printStats() -{} +void b3DynamicBvhBroadphase::printStats() +{ +} // #if B3_DBVT_BP_ENABLE_BENCHMARK -struct b3BroadphaseBenchmark +struct b3BroadphaseBenchmark { - struct Experiment + struct Experiment { - const char* name; - int object_count; - int update_count; - int spawn_count; - int iterations; - b3Scalar speed; - b3Scalar amplitude; + const char* name; + int object_count; + int update_count; + int spawn_count; + int iterations; + b3Scalar speed; + b3Scalar amplitude; }; - struct Object + struct Object { - b3Vector3 center; - b3Vector3 extents; - b3BroadphaseProxy* proxy; - b3Scalar time; - void update(b3Scalar speed,b3Scalar amplitude,b3BroadphaseInterface* pbi) + b3Vector3 center; + b3Vector3 extents; + b3BroadphaseProxy* proxy; + b3Scalar time; + void update(b3Scalar speed, b3Scalar amplitude, b3BroadphaseInterface* pbi) { - time += speed; - center[0] = b3Cos(time*(b3Scalar)2.17)*amplitude+ - b3Sin(time)*amplitude/2; - center[1] = b3Cos(time*(b3Scalar)1.38)*amplitude+ - b3Sin(time)*amplitude; - center[2] = b3Sin(time*(b3Scalar)0.777)*amplitude; - pbi->setAabb(proxy,center-extents,center+extents,0); + time += speed; + center[0] = b3Cos(time * (b3Scalar)2.17) * amplitude + + b3Sin(time) * amplitude / 2; + center[1] = b3Cos(time * (b3Scalar)1.38) * amplitude + + b3Sin(time) * amplitude; + center[2] = b3Sin(time * (b3Scalar)0.777) * amplitude; + pbi->setAabb(proxy, center - extents, center + extents, 0); } }; - static int UnsignedRand(int range=RAND_MAX-1) { return(rand()%(range+1)); } - static b3Scalar UnitRand() { return(UnsignedRand(16384)/(b3Scalar)16384); } - static void OutputTime(const char* name,b3Clock& c,unsigned count=0) + static int UnsignedRand(int range = RAND_MAX - 1) { return (rand() % (range + 1)); } + static b3Scalar UnitRand() { return (UnsignedRand(16384) / (b3Scalar)16384); } + static void OutputTime(const char* name, b3Clock& c, unsigned count = 0) { - const unsigned long us=c.getTimeMicroseconds(); - const unsigned long ms=(us+500)/1000; - const b3Scalar sec=us/(b3Scalar)(1000*1000); - if(count>0) - printf("%s : %u us (%u ms), %.2f/s\r\n",name,us,ms,count/sec); + const unsigned long us = c.getTimeMicroseconds(); + const unsigned long ms = (us + 500) / 1000; + const b3Scalar sec = us / (b3Scalar)(1000 * 1000); + if (count > 0) + printf("%s : %u us (%u ms), %.2f/s\r\n", name, us, ms, count / sec); else - printf("%s : %u us (%u ms)\r\n",name,us,ms); + printf("%s : %u us (%u ms)\r\n", name, us, ms); } }; -void b3DynamicBvhBroadphase::benchmark(b3BroadphaseInterface* pbi) +void b3DynamicBvhBroadphase::benchmark(b3BroadphaseInterface* pbi) { - static const b3BroadphaseBenchmark::Experiment experiments[]= - { - {"1024o.10%",1024,10,0,8192,(b3Scalar)0.005,(b3Scalar)100}, - /*{"4096o.10%",4096,10,0,8192,(b3Scalar)0.005,(b3Scalar)100}, + static const b3BroadphaseBenchmark::Experiment experiments[] = + { + {"1024o.10%", 1024, 10, 0, 8192, (b3Scalar)0.005, (b3Scalar)100}, + /*{"4096o.10%",4096,10,0,8192,(b3Scalar)0.005,(b3Scalar)100}, {"8192o.10%",8192,10,0,8192,(b3Scalar)0.005,(b3Scalar)100},*/ - }; - static const int nexperiments=sizeof(experiments)/sizeof(experiments[0]); - b3AlignedObjectArray<b3BroadphaseBenchmark::Object*> objects; - b3Clock wallclock; - /* Begin */ - for(int iexp=0;iexp<nexperiments;++iexp) + }; + static const int nexperiments = sizeof(experiments) / sizeof(experiments[0]); + b3AlignedObjectArray<b3BroadphaseBenchmark::Object*> objects; + b3Clock wallclock; + /* Begin */ + for (int iexp = 0; iexp < nexperiments; ++iexp) { - const b3BroadphaseBenchmark::Experiment& experiment=experiments[iexp]; - const int object_count=experiment.object_count; - const int update_count=(object_count*experiment.update_count)/100; - const int spawn_count=(object_count*experiment.spawn_count)/100; - const b3Scalar speed=experiment.speed; - const b3Scalar amplitude=experiment.amplitude; - printf("Experiment #%u '%s':\r\n",iexp,experiment.name); - printf("\tObjects: %u\r\n",object_count); - printf("\tUpdate: %u\r\n",update_count); - printf("\tSpawn: %u\r\n",spawn_count); - printf("\tSpeed: %f\r\n",speed); - printf("\tAmplitude: %f\r\n",amplitude); + const b3BroadphaseBenchmark::Experiment& experiment = experiments[iexp]; + const int object_count = experiment.object_count; + const int update_count = (object_count * experiment.update_count) / 100; + const int spawn_count = (object_count * experiment.spawn_count) / 100; + const b3Scalar speed = experiment.speed; + const b3Scalar amplitude = experiment.amplitude; + printf("Experiment #%u '%s':\r\n", iexp, experiment.name); + printf("\tObjects: %u\r\n", object_count); + printf("\tUpdate: %u\r\n", update_count); + printf("\tSpawn: %u\r\n", spawn_count); + printf("\tSpeed: %f\r\n", speed); + printf("\tAmplitude: %f\r\n", amplitude); srand(180673); - /* Create objects */ + /* Create objects */ wallclock.reset(); objects.reserve(object_count); - for(int i=0;i<object_count;++i) + for (int i = 0; i < object_count; ++i) { - b3BroadphaseBenchmark::Object* po=new b3BroadphaseBenchmark::Object(); - po->center[0]=b3BroadphaseBenchmark::UnitRand()*50; - po->center[1]=b3BroadphaseBenchmark::UnitRand()*50; - po->center[2]=b3BroadphaseBenchmark::UnitRand()*50; - po->extents[0]=b3BroadphaseBenchmark::UnitRand()*2+2; - po->extents[1]=b3BroadphaseBenchmark::UnitRand()*2+2; - po->extents[2]=b3BroadphaseBenchmark::UnitRand()*2+2; - po->time=b3BroadphaseBenchmark::UnitRand()*2000; - po->proxy=pbi->createProxy(po->center-po->extents,po->center+po->extents,0,po,1,1,0,0); + b3BroadphaseBenchmark::Object* po = new b3BroadphaseBenchmark::Object(); + po->center[0] = b3BroadphaseBenchmark::UnitRand() * 50; + po->center[1] = b3BroadphaseBenchmark::UnitRand() * 50; + po->center[2] = b3BroadphaseBenchmark::UnitRand() * 50; + po->extents[0] = b3BroadphaseBenchmark::UnitRand() * 2 + 2; + po->extents[1] = b3BroadphaseBenchmark::UnitRand() * 2 + 2; + po->extents[2] = b3BroadphaseBenchmark::UnitRand() * 2 + 2; + po->time = b3BroadphaseBenchmark::UnitRand() * 2000; + po->proxy = pbi->createProxy(po->center - po->extents, po->center + po->extents, 0, po, 1, 1, 0, 0); objects.push_back(po); } - b3BroadphaseBenchmark::OutputTime("\tInitialization",wallclock); - /* First update */ + b3BroadphaseBenchmark::OutputTime("\tInitialization", wallclock); + /* First update */ wallclock.reset(); - for(int i=0;i<objects.size();++i) + for (int i = 0; i < objects.size(); ++i) { - objects[i]->update(speed,amplitude,pbi); + objects[i]->update(speed, amplitude, pbi); } - b3BroadphaseBenchmark::OutputTime("\tFirst update",wallclock); - /* Updates */ + b3BroadphaseBenchmark::OutputTime("\tFirst update", wallclock); + /* Updates */ wallclock.reset(); - for(int i=0;i<experiment.iterations;++i) + for (int i = 0; i < experiment.iterations; ++i) { - for(int j=0;j<update_count;++j) - { - objects[j]->update(speed,amplitude,pbi); + for (int j = 0; j < update_count; ++j) + { + objects[j]->update(speed, amplitude, pbi); } pbi->calculateOverlappingPairs(0); } - b3BroadphaseBenchmark::OutputTime("\tUpdate",wallclock,experiment.iterations); - /* Clean up */ + b3BroadphaseBenchmark::OutputTime("\tUpdate", wallclock, experiment.iterations); + /* Clean up */ wallclock.reset(); - for(int i=0;i<objects.size();++i) + for (int i = 0; i < objects.size(); ++i) { - pbi->destroyProxy(objects[i]->proxy,0); + pbi->destroyProxy(objects[i]->proxy, 0); delete objects[i]; } objects.resize(0); - b3BroadphaseBenchmark::OutputTime("\tRelease",wallclock); + b3BroadphaseBenchmark::OutputTime("\tRelease", wallclock); } - } #else /*void b3DynamicBvhBroadphase::benchmark(b3BroadphaseInterface*) @@ -799,6 +804,5 @@ void b3DynamicBvhBroadphase::benchmark(b3BroadphaseInterface* pbi) #endif #if B3_DBVT_BP_PROFILE -#undef b3SPC +#undef b3SPC #endif - diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h index 7ac085d90c..c235e40148 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h @@ -27,46 +27,43 @@ subject to the following restrictions: // Compile time config // -#define B3_DBVT_BP_PROFILE 0 +#define B3_DBVT_BP_PROFILE 0 //#define B3_DBVT_BP_SORTPAIRS 1 -#define B3_DBVT_BP_PREVENTFALSEUPDATE 0 -#define B3_DBVT_BP_ACCURATESLEEPING 0 -#define B3_DBVT_BP_ENABLE_BENCHMARK 0 -#define B3_DBVT_BP_MARGIN (b3Scalar)0.05 +#define B3_DBVT_BP_PREVENTFALSEUPDATE 0 +#define B3_DBVT_BP_ACCURATESLEEPING 0 +#define B3_DBVT_BP_ENABLE_BENCHMARK 0 +#define B3_DBVT_BP_MARGIN (b3Scalar)0.05 #if B3_DBVT_BP_PROFILE -#define B3_DBVT_BP_PROFILING_RATE 256 +#define B3_DBVT_BP_PROFILING_RATE 256 #endif - - - -B3_ATTRIBUTE_ALIGNED16(struct) b3BroadphaseProxy +B3_ATTRIBUTE_ALIGNED16(struct) +b3BroadphaseProxy { + B3_DECLARE_ALIGNED_ALLOCATOR(); -B3_DECLARE_ALIGNED_ALLOCATOR(); - ///optional filtering to cull potential collisions enum CollisionFilterGroups { - DefaultFilter = 1, - StaticFilter = 2, - KinematicFilter = 4, - DebrisFilter = 8, - SensorTrigger = 16, - CharacterFilter = 32, - AllFilter = -1 //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger + DefaultFilter = 1, + StaticFilter = 2, + KinematicFilter = 4, + DebrisFilter = 8, + SensorTrigger = 16, + CharacterFilter = 32, + AllFilter = -1 //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger }; //Usually the client b3CollisionObject or Rigidbody class - void* m_clientObject; + void* m_clientObject; int m_collisionFilterGroup; int m_collisionFilterMask; - int m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. + int m_uniqueId; //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. - b3Vector3 m_aabbMin; - b3Vector3 m_aabbMax; + b3Vector3 m_aabbMin; + b3Vector3 m_aabbMax; B3_FORCE_INLINE int getUid() const { @@ -74,116 +71,112 @@ B3_DECLARE_ALIGNED_ALLOCATOR(); } //used for memory pools - b3BroadphaseProxy() :m_clientObject(0) + b3BroadphaseProxy() : m_clientObject(0) { } - b3BroadphaseProxy(const b3Vector3& aabbMin,const b3Vector3& aabbMax,void* userPtr, int collisionFilterGroup, int collisionFilterMask) - :m_clientObject(userPtr), - m_collisionFilterGroup(collisionFilterGroup), - m_collisionFilterMask(collisionFilterMask), - m_aabbMin(aabbMin), - m_aabbMax(aabbMax) + b3BroadphaseProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask) + : m_clientObject(userPtr), + m_collisionFilterGroup(collisionFilterGroup), + m_collisionFilterMask(collisionFilterMask), + m_aabbMin(aabbMin), + m_aabbMax(aabbMax) { } }; - - - - // // b3DbvtProxy // struct b3DbvtProxy : b3BroadphaseProxy { - /* Fields */ + /* Fields */ //b3DbvtAabbMm aabb; - b3DbvtNode* leaf; - b3DbvtProxy* links[2]; - int stage; - /* ctor */ + b3DbvtNode* leaf; + b3DbvtProxy* links[2]; + int stage; + /* ctor */ explicit b3DbvtProxy() {} - b3DbvtProxy(const b3Vector3& aabbMin,const b3Vector3& aabbMax,void* userPtr, int collisionFilterGroup, int collisionFilterMask) : - b3BroadphaseProxy(aabbMin,aabbMax,userPtr,collisionFilterGroup,collisionFilterMask) + b3DbvtProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask) : b3BroadphaseProxy(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask) { - links[0]=links[1]=0; + links[0] = links[1] = 0; } }; -typedef b3AlignedObjectArray<b3DbvtProxy*> b3DbvtProxyArray; +typedef b3AlignedObjectArray<b3DbvtProxy*> b3DbvtProxyArray; ///The b3DynamicBvhBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see b3DynamicBvh). ///One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other. ///This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases b3AxisSweep3 and b332BitAxisSweep3. -struct b3DynamicBvhBroadphase +struct b3DynamicBvhBroadphase { - /* Config */ - enum { - DYNAMIC_SET = 0, /* Dynamic set index */ - FIXED_SET = 1, /* Fixed set index */ - STAGECOUNT = 2 /* Number of stages */ + /* Config */ + enum + { + DYNAMIC_SET = 0, /* Dynamic set index */ + FIXED_SET = 1, /* Fixed set index */ + STAGECOUNT = 2 /* Number of stages */ }; - /* Fields */ - b3DynamicBvh m_sets[2]; // Dbvt sets - b3DbvtProxy* m_stageRoots[STAGECOUNT+1]; // Stages list - - b3AlignedObjectArray<b3DbvtProxy> m_proxies; - b3OverlappingPairCache* m_paircache; // Pair cache - b3Scalar m_prediction; // Velocity prediction - int m_stageCurrent; // Current stage - int m_fupdates; // % of fixed updates per frame - int m_dupdates; // % of dynamic updates per frame - int m_cupdates; // % of cleanup updates per frame - int m_newpairs; // Number of pairs created - int m_fixedleft; // Fixed optimization left - unsigned m_updates_call; // Number of updates call - unsigned m_updates_done; // Number of updates done - b3Scalar m_updates_ratio; // m_updates_done/m_updates_call - int m_pid; // Parse id - int m_cid; // Cleanup index - bool m_releasepaircache; // Release pair cache on delete - bool m_deferedcollide; // Defere dynamic/static collision to collide call - bool m_needcleanup; // Need to run cleanup? + /* Fields */ + b3DynamicBvh m_sets[2]; // Dbvt sets + b3DbvtProxy* m_stageRoots[STAGECOUNT + 1]; // Stages list + + b3AlignedObjectArray<b3DbvtProxy> m_proxies; + b3OverlappingPairCache* m_paircache; // Pair cache + b3Scalar m_prediction; // Velocity prediction + int m_stageCurrent; // Current stage + int m_fupdates; // % of fixed updates per frame + int m_dupdates; // % of dynamic updates per frame + int m_cupdates; // % of cleanup updates per frame + int m_newpairs; // Number of pairs created + int m_fixedleft; // Fixed optimization left + unsigned m_updates_call; // Number of updates call + unsigned m_updates_done; // Number of updates done + b3Scalar m_updates_ratio; // m_updates_done/m_updates_call + int m_pid; // Parse id + int m_cid; // Cleanup index + bool m_releasepaircache; // Release pair cache on delete + bool m_deferedcollide; // Defere dynamic/static collision to collide call + bool m_needcleanup; // Need to run cleanup? #if B3_DBVT_BP_PROFILE - b3Clock m_clock; - struct { - unsigned long m_total; - unsigned long m_ddcollide; - unsigned long m_fdcollide; - unsigned long m_cleanup; - unsigned long m_jobcount; - } m_profiling; + b3Clock m_clock; + struct + { + unsigned long m_total; + unsigned long m_ddcollide; + unsigned long m_fdcollide; + unsigned long m_cleanup; + unsigned long m_jobcount; + } m_profiling; #endif - /* Methods */ - b3DynamicBvhBroadphase(int proxyCapacity, b3OverlappingPairCache* paircache=0); + /* Methods */ + b3DynamicBvhBroadphase(int proxyCapacity, b3OverlappingPairCache* paircache = 0); virtual ~b3DynamicBvhBroadphase(); - void collide(b3Dispatcher* dispatcher); - void optimize(); - + void collide(b3Dispatcher* dispatcher); + void optimize(); + /* b3BroadphaseInterface Implementation */ - b3BroadphaseProxy* createProxy(const b3Vector3& aabbMin,const b3Vector3& aabbMax,int objectIndex,void* userPtr, int collisionFilterGroup, int collisionFilterMask); - virtual void destroyProxy(b3BroadphaseProxy* proxy,b3Dispatcher* dispatcher); - virtual void setAabb(int objectId,const b3Vector3& aabbMin,const b3Vector3& aabbMax,b3Dispatcher* dispatcher); - virtual void rayTest(const b3Vector3& rayFrom,const b3Vector3& rayTo, b3BroadphaseRayCallback& rayCallback, const b3Vector3& aabbMin=b3MakeVector3(0,0,0), const b3Vector3& aabbMax = b3MakeVector3(0,0,0)); - virtual void aabbTest(const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3BroadphaseAabbCallback& callback); + b3BroadphaseProxy* createProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int objectIndex, void* userPtr, int collisionFilterGroup, int collisionFilterMask); + virtual void destroyProxy(b3BroadphaseProxy* proxy, b3Dispatcher* dispatcher); + virtual void setAabb(int objectId, const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3Dispatcher* dispatcher); + virtual void rayTest(const b3Vector3& rayFrom, const b3Vector3& rayTo, b3BroadphaseRayCallback& rayCallback, const b3Vector3& aabbMin = b3MakeVector3(0, 0, 0), const b3Vector3& aabbMax = b3MakeVector3(0, 0, 0)); + virtual void aabbTest(const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3BroadphaseAabbCallback& callback); //virtual void getAabb(b3BroadphaseProxy* proxy,b3Vector3& aabbMin, b3Vector3& aabbMax ) const; - virtual void getAabb(int objectId,b3Vector3& aabbMin, b3Vector3& aabbMax ) const; - virtual void calculateOverlappingPairs(b3Dispatcher* dispatcher=0); - virtual b3OverlappingPairCache* getOverlappingPairCache(); - virtual const b3OverlappingPairCache* getOverlappingPairCache() const; - virtual void getBroadphaseAabb(b3Vector3& aabbMin,b3Vector3& aabbMax) const; - virtual void printStats(); - + virtual void getAabb(int objectId, b3Vector3& aabbMin, b3Vector3& aabbMax) const; + virtual void calculateOverlappingPairs(b3Dispatcher* dispatcher = 0); + virtual b3OverlappingPairCache* getOverlappingPairCache(); + virtual const b3OverlappingPairCache* getOverlappingPairCache() const; + virtual void getBroadphaseAabb(b3Vector3& aabbMin, b3Vector3& aabbMax) const; + virtual void printStats(); ///reset broadphase internal structures, to ensure determinism/reproducability virtual void resetPool(b3Dispatcher* dispatcher); - void performDeferredRemoval(b3Dispatcher* dispatcher); - - void setVelocityPrediction(b3Scalar prediction) + void performDeferredRemoval(b3Dispatcher* dispatcher); + + void setVelocityPrediction(b3Scalar prediction) { m_prediction = prediction; } @@ -192,15 +185,13 @@ struct b3DynamicBvhBroadphase return m_prediction; } - ///this setAabbForceUpdate is similar to setAabb but always forces the aabb update. + ///this setAabbForceUpdate is similar to setAabb but always forces the aabb update. ///it is not part of the b3BroadphaseInterface but specific to b3DynamicBvhBroadphase. ///it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see ///http://code.google.com/p/bullet/issues/detail?id=223 - void setAabbForceUpdate( b3BroadphaseProxy* absproxy,const b3Vector3& aabbMin,const b3Vector3& aabbMax,b3Dispatcher* /*dispatcher*/); + void setAabbForceUpdate(b3BroadphaseProxy* absproxy, const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3Dispatcher* /*dispatcher*/); //static void benchmark(b3BroadphaseInterface*); - - }; #endif diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h index 39bf27de3e..4ff9ebae81 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h @@ -23,20 +23,20 @@ subject to the following restrictions: typedef b3Int4 b3BroadphasePair; -inline b3Int4 b3MakeBroadphasePair(int xx,int yy) +inline b3Int4 b3MakeBroadphasePair(int xx, int yy) { b3Int4 pair; if (xx < yy) - { - pair.x = xx; - pair.y = yy; - } - else - { + { + pair.x = xx; + pair.y = yy; + } + else + { pair.x = yy; - pair.y = xx; - } + pair.y = xx; + } pair.z = B3_NEW_PAIR_MARKER; pair.w = B3_NEW_PAIR_MARKER; return pair; @@ -51,22 +51,20 @@ inline b3Int4 b3MakeBroadphasePair(int xx,int yy) class b3BroadphasePairSortPredicate { - public: - - bool operator() ( const b3BroadphasePair& a, const b3BroadphasePair& b ) const - { - const int uidA0 = a.x; - const int uidB0 = b.x; - const int uidA1 = a.y; - const int uidB1 = b.y; - return uidA0 > uidB0 || (uidA0 == uidB0 && uidA1 > uidB1); - } +public: + bool operator()(const b3BroadphasePair& a, const b3BroadphasePair& b) const + { + const int uidA0 = a.x; + const int uidB0 = b.x; + const int uidA1 = a.y; + const int uidB1 = b.y; + return uidA0 > uidB0 || (uidA0 == uidB0 && uidA1 > uidB1); + } }; -B3_FORCE_INLINE bool operator==(const b3BroadphasePair& a, const b3BroadphasePair& b) +B3_FORCE_INLINE bool operator==(const b3BroadphasePair& a, const b3BroadphasePair& b) { - return (a.x == b.x ) && (a.y == b.y ); + return (a.x == b.x) && (a.y == b.y); } -#endif //B3_OVERLAPPING_PAIR_H - +#endif //B3_OVERLAPPING_PAIR_H diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.cpp b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.cpp index e4bda61624..19773244be 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.cpp +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.cpp @@ -13,8 +13,6 @@ subject to the following restrictions: 3. This notice may not be removed or altered from any source distribution. */ - - #include "b3OverlappingPairCache.h" //#include "b3Dispatcher.h" @@ -23,35 +21,26 @@ subject to the following restrictions: #include <stdio.h> -int b3g_overlappingPairs = 0; -int b3g_removePairs =0; -int b3g_addedPairs =0; -int b3g_findPairs =0; - - - +int b3g_overlappingPairs = 0; +int b3g_removePairs = 0; +int b3g_addedPairs = 0; +int b3g_findPairs = 0; -b3HashedOverlappingPairCache::b3HashedOverlappingPairCache(): - m_overlapFilterCallback(0) +b3HashedOverlappingPairCache::b3HashedOverlappingPairCache() : m_overlapFilterCallback(0) //, m_blockedForChanges(false) { - int initialAllocatedSize= 2; + int initialAllocatedSize = 2; m_overlappingPairArray.reserve(initialAllocatedSize); growTables(); } - - - b3HashedOverlappingPairCache::~b3HashedOverlappingPairCache() { } - - -void b3HashedOverlappingPairCache::cleanOverlappingPair(b3BroadphasePair& pair,b3Dispatcher* dispatcher) +void b3HashedOverlappingPairCache::cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher) { -/* if (pair.m_algorithm) + /* if (pair.m_algorithm) { { pair.m_algorithm->~b3CollisionAlgorithm(); @@ -60,91 +49,74 @@ void b3HashedOverlappingPairCache::cleanOverlappingPair(b3BroadphasePair& pair,b } } */ - } - - - -void b3HashedOverlappingPairCache::cleanProxyFromPairs(int proxy,b3Dispatcher* dispatcher) +void b3HashedOverlappingPairCache::cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher) { - - class CleanPairCallback : public b3OverlapCallback + class CleanPairCallback : public b3OverlapCallback { int m_cleanProxy; - b3OverlappingPairCache* m_pairCache; + b3OverlappingPairCache* m_pairCache; b3Dispatcher* m_dispatcher; public: - CleanPairCallback(int cleanProxy,b3OverlappingPairCache* pairCache,b3Dispatcher* dispatcher) - :m_cleanProxy(cleanProxy), - m_pairCache(pairCache), - m_dispatcher(dispatcher) + CleanPairCallback(int cleanProxy, b3OverlappingPairCache* pairCache, b3Dispatcher* dispatcher) + : m_cleanProxy(cleanProxy), + m_pairCache(pairCache), + m_dispatcher(dispatcher) { } - virtual bool processOverlap(b3BroadphasePair& pair) + virtual bool processOverlap(b3BroadphasePair& pair) { if ((pair.x == m_cleanProxy) || (pair.y == m_cleanProxy)) { - m_pairCache->cleanOverlappingPair(pair,m_dispatcher); + m_pairCache->cleanOverlappingPair(pair, m_dispatcher); } return false; } - }; - CleanPairCallback cleanPairs(proxy,this,dispatcher); - - processAllOverlappingPairs(&cleanPairs,dispatcher); + CleanPairCallback cleanPairs(proxy, this, dispatcher); + processAllOverlappingPairs(&cleanPairs, dispatcher); } - - - -void b3HashedOverlappingPairCache::removeOverlappingPairsContainingProxy(int proxy,b3Dispatcher* dispatcher) +void b3HashedOverlappingPairCache::removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher* dispatcher) { - - class RemovePairCallback : public b3OverlapCallback + class RemovePairCallback : public b3OverlapCallback { int m_obsoleteProxy; public: RemovePairCallback(int obsoleteProxy) - :m_obsoleteProxy(obsoleteProxy) + : m_obsoleteProxy(obsoleteProxy) { } - virtual bool processOverlap(b3BroadphasePair& pair) + virtual bool processOverlap(b3BroadphasePair& pair) { return ((pair.x == m_obsoleteProxy) || - (pair.y == m_obsoleteProxy)); + (pair.y == m_obsoleteProxy)); } - }; - RemovePairCallback removeCallback(proxy); - processAllOverlappingPairs(&removeCallback,dispatcher); + processAllOverlappingPairs(&removeCallback, dispatcher); } - - - - b3BroadphasePair* b3HashedOverlappingPairCache::findPair(int proxy0, int proxy1) { b3g_findPairs++; - if(proxy0 >proxy1) - b3Swap(proxy0,proxy1); + if (proxy0 > proxy1) + b3Swap(proxy0, proxy1); int proxyId1 = proxy0; int proxyId2 = proxy1; /*if (proxyId1 > proxyId2) b3Swap(proxyId1, proxyId2);*/ - int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1)); + int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); if (hash >= m_hashTable.size()) { @@ -169,9 +141,8 @@ b3BroadphasePair* b3HashedOverlappingPairCache::findPair(int proxy0, int proxy1) //#include <stdio.h> -void b3HashedOverlappingPairCache::growTables() +void b3HashedOverlappingPairCache::growTables() { - int newCapacity = m_overlappingPairArray.capacity(); if (m_hashTable.size() < newCapacity) @@ -182,10 +153,9 @@ void b3HashedOverlappingPairCache::growTables() m_hashTable.resize(newCapacity); m_next.resize(newCapacity); - int i; - for (i= 0; i < newCapacity; ++i) + for (i = 0; i < newCapacity; ++i) { m_hashTable[i] = B3_NULL_PAIR; } @@ -194,35 +164,31 @@ void b3HashedOverlappingPairCache::growTables() m_next[i] = B3_NULL_PAIR; } - for(i=0;i<curHashtableSize;i++) + for (i = 0; i < curHashtableSize; i++) { - const b3BroadphasePair& pair = m_overlappingPairArray[i]; int proxyId1 = pair.x; int proxyId2 = pair.y; /*if (proxyId1 > proxyId2) b3Swap(proxyId1, proxyId2);*/ - int hashValue = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1)); // New hash value with new mask + int hashValue = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask m_next[i] = m_hashTable[hashValue]; m_hashTable[hashValue] = i; } - - } } b3BroadphasePair* b3HashedOverlappingPairCache::internalAddPair(int proxy0, int proxy1) { - if(proxy0>proxy1) - b3Swap(proxy0,proxy1); + if (proxy0 > proxy1) + b3Swap(proxy0, proxy1); int proxyId1 = proxy0; int proxyId2 = proxy1; /*if (proxyId1 > proxyId2) b3Swap(proxyId1, proxyId2);*/ - int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1)); // New hash value with new mask - + int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask b3BroadphasePair* pair = internalFindPair(proxy0, proxy1, hash); if (pair != NULL) @@ -243,8 +209,8 @@ b3BroadphasePair* b3HashedOverlappingPairCache::internalAddPair(int proxy0, int pair = &m_overlappingPairArray.expandNonInitializing(); //this is where we add an actual pair, so also call the 'ghost' -// if (m_ghostPairCallback) -// m_ghostPairCallback->addOverlappingPair(proxy0,proxy1); + // if (m_ghostPairCallback) + // m_ghostPairCallback->addOverlappingPair(proxy0,proxy1); int newCapacity = m_overlappingPairArray.capacity(); @@ -252,16 +218,15 @@ b3BroadphasePair* b3HashedOverlappingPairCache::internalAddPair(int proxy0, int { growTables(); //hash with new capacity - hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1)); + hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); } - - *pair = b3MakeBroadphasePair(proxy0,proxy1); - -// pair->m_pProxy0 = proxy0; -// pair->m_pProxy1 = proxy1; + + *pair = b3MakeBroadphasePair(proxy0, proxy1); + + // pair->m_pProxy0 = proxy0; + // pair->m_pProxy1 = proxy1; //pair->m_algorithm = 0; //pair->m_internalTmpValue = 0; - m_next[count] = m_hashTable[hash]; m_hashTable[hash] = count; @@ -269,20 +234,18 @@ b3BroadphasePair* b3HashedOverlappingPairCache::internalAddPair(int proxy0, int return pair; } - - -void* b3HashedOverlappingPairCache::removeOverlappingPair(int proxy0, int proxy1,b3Dispatcher* dispatcher) +void* b3HashedOverlappingPairCache::removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher) { b3g_removePairs++; - if(proxy0>proxy1) - b3Swap(proxy0,proxy1); + if (proxy0 > proxy1) + b3Swap(proxy0, proxy1); int proxyId1 = proxy0; int proxyId2 = proxy1; /*if (proxyId1 > proxyId2) b3Swap(proxyId1, proxyId2);*/ - int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1)); + int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); b3BroadphasePair* pair = internalFindPair(proxy0, proxy1, hash); if (pair == NULL) @@ -290,9 +253,7 @@ void* b3HashedOverlappingPairCache::removeOverlappingPair(int proxy0, int proxy1 return 0; } - cleanOverlappingPair(*pair,dispatcher); - - + cleanOverlappingPair(*pair, dispatcher); int pairIndex = int(pair - &m_overlappingPairArray[0]); b3Assert(pairIndex < m_overlappingPairArray.size()); @@ -336,8 +297,8 @@ void* b3HashedOverlappingPairCache::removeOverlappingPair(int proxy0, int proxy1 // Remove the last pair from the hash table. const b3BroadphasePair* last = &m_overlappingPairArray[lastPairIndex]; - /* missing swap here too, Nat. */ - int lastHash = static_cast<int>(getHash(static_cast<unsigned int>(last->x), static_cast<unsigned int>(last->y)) & (m_overlappingPairArray.capacity()-1)); + /* missing swap here too, Nat. */ + int lastHash = static_cast<int>(getHash(static_cast<unsigned int>(last->x), static_cast<unsigned int>(last->y)) & (m_overlappingPairArray.capacity() - 1)); index = m_hashTable[lastHash]; b3Assert(index != B3_NULL_PAIR); @@ -372,47 +333,42 @@ void* b3HashedOverlappingPairCache::removeOverlappingPair(int proxy0, int proxy1 } //#include <stdio.h> -void b3HashedOverlappingPairCache::processAllOverlappingPairs(b3OverlapCallback* callback,b3Dispatcher* dispatcher) +void b3HashedOverlappingPairCache::processAllOverlappingPairs(b3OverlapCallback* callback, b3Dispatcher* dispatcher) { - int i; -// printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size()); - for (i=0;i<m_overlappingPairArray.size();) + // printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size()); + for (i = 0; i < m_overlappingPairArray.size();) { - b3BroadphasePair* pair = &m_overlappingPairArray[i]; if (callback->processOverlap(*pair)) { - removeOverlappingPair(pair->x,pair->y,dispatcher); + removeOverlappingPair(pair->x, pair->y, dispatcher); b3g_overlappingPairs--; - } else + } + else { i++; } } } - - - - -void b3HashedOverlappingPairCache::sortOverlappingPairs(b3Dispatcher* dispatcher) +void b3HashedOverlappingPairCache::sortOverlappingPairs(b3Dispatcher* dispatcher) { ///need to keep hashmap in sync with pair address, so rebuild all b3BroadphasePairArray tmpPairs; int i; - for (i=0;i<m_overlappingPairArray.size();i++) + for (i = 0; i < m_overlappingPairArray.size(); i++) { tmpPairs.push_back(m_overlappingPairArray[i]); } - for (i=0;i<tmpPairs.size();i++) + for (i = 0; i < tmpPairs.size(); i++) { - removeOverlappingPair(tmpPairs[i].x,tmpPairs[i].y,dispatcher); + removeOverlappingPair(tmpPairs[i].x, tmpPairs[i].y, dispatcher); } - + for (i = 0; i < m_next.size(); i++) { m_next[i] = B3_NULL_PAIR; @@ -420,33 +376,29 @@ void b3HashedOverlappingPairCache::sortOverlappingPairs(b3Dispatcher* dispatcher tmpPairs.quickSort(b3BroadphasePairSortPredicate()); - for (i=0;i<tmpPairs.size();i++) + for (i = 0; i < tmpPairs.size(); i++) { - addOverlappingPair(tmpPairs[i].x ,tmpPairs[i].y); + addOverlappingPair(tmpPairs[i].x, tmpPairs[i].y); } - - } - -void* b3SortedOverlappingPairCache::removeOverlappingPair(int proxy0,int proxy1, b3Dispatcher* dispatcher ) +void* b3SortedOverlappingPairCache::removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher) { if (!hasDeferredRemoval()) { - b3BroadphasePair findPair = b3MakeBroadphasePair(proxy0,proxy1); - + b3BroadphasePair findPair = b3MakeBroadphasePair(proxy0, proxy1); int findIndex = m_overlappingPairArray.findLinearSearch(findPair); if (findIndex < m_overlappingPairArray.size()) { b3g_overlappingPairs--; b3BroadphasePair& pair = m_overlappingPairArray[findIndex]; - - cleanOverlappingPair(pair,dispatcher); + + cleanOverlappingPair(pair, dispatcher); //if (m_ghostPairCallback) // m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1,dispatcher); - - m_overlappingPairArray.swap(findIndex,m_overlappingPairArray.capacity()-1); + + m_overlappingPairArray.swap(findIndex, m_overlappingPairArray.capacity() - 1); m_overlappingPairArray.pop_back(); return 0; } @@ -455,100 +407,77 @@ void* b3SortedOverlappingPairCache::removeOverlappingPair(int proxy0,int proxy1, return 0; } - - - - - - - -b3BroadphasePair* b3SortedOverlappingPairCache::addOverlappingPair(int proxy0,int proxy1) +b3BroadphasePair* b3SortedOverlappingPairCache::addOverlappingPair(int proxy0, int proxy1) { //don't add overlap with own b3Assert(proxy0 != proxy1); - if (!needsBroadphaseCollision(proxy0,proxy1)) + if (!needsBroadphaseCollision(proxy0, proxy1)) return 0; - + b3BroadphasePair* pair = &m_overlappingPairArray.expandNonInitializing(); - *pair = b3MakeBroadphasePair(proxy0,proxy1); - - + *pair = b3MakeBroadphasePair(proxy0, proxy1); + b3g_overlappingPairs++; b3g_addedPairs++; - -// if (m_ghostPairCallback) -// m_ghostPairCallback->addOverlappingPair(proxy0, proxy1); + + // if (m_ghostPairCallback) + // m_ghostPairCallback->addOverlappingPair(proxy0, proxy1); return pair; - } ///this findPair becomes really slow. Either sort the list to speedup the query, or ///use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed. ///we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address) ///Also we can use a 2D bitmap, which can be useful for a future GPU implementation - b3BroadphasePair* b3SortedOverlappingPairCache::findPair(int proxy0,int proxy1) +b3BroadphasePair* b3SortedOverlappingPairCache::findPair(int proxy0, int proxy1) { - if (!needsBroadphaseCollision(proxy0,proxy1)) + if (!needsBroadphaseCollision(proxy0, proxy1)) return 0; - b3BroadphasePair tmpPair = b3MakeBroadphasePair(proxy0,proxy1); + b3BroadphasePair tmpPair = b3MakeBroadphasePair(proxy0, proxy1); int findIndex = m_overlappingPairArray.findLinearSearch(tmpPair); if (findIndex < m_overlappingPairArray.size()) { //b3Assert(it != m_overlappingPairSet.end()); - b3BroadphasePair* pair = &m_overlappingPairArray[findIndex]; + b3BroadphasePair* pair = &m_overlappingPairArray[findIndex]; return pair; } return 0; } - - - - - - - - - //#include <stdio.h> -void b3SortedOverlappingPairCache::processAllOverlappingPairs(b3OverlapCallback* callback,b3Dispatcher* dispatcher) +void b3SortedOverlappingPairCache::processAllOverlappingPairs(b3OverlapCallback* callback, b3Dispatcher* dispatcher) { - int i; - for (i=0;i<m_overlappingPairArray.size();) + for (i = 0; i < m_overlappingPairArray.size();) { - b3BroadphasePair* pair = &m_overlappingPairArray[i]; if (callback->processOverlap(*pair)) { - cleanOverlappingPair(*pair,dispatcher); + cleanOverlappingPair(*pair, dispatcher); pair->x = -1; pair->y = -1; - m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1); + m_overlappingPairArray.swap(i, m_overlappingPairArray.size() - 1); m_overlappingPairArray.pop_back(); b3g_overlappingPairs--; - } else + } + else { i++; } } } - - - -b3SortedOverlappingPairCache::b3SortedOverlappingPairCache(): - m_blockedForChanges(false), - m_hasDeferredRemoval(true), - m_overlapFilterCallback(0) +b3SortedOverlappingPairCache::b3SortedOverlappingPairCache() : m_blockedForChanges(false), + m_hasDeferredRemoval(true), + m_overlapFilterCallback(0) { - int initialAllocatedSize= 2; + int initialAllocatedSize = 2; m_overlappingPairArray.reserve(initialAllocatedSize); } @@ -556,9 +485,9 @@ b3SortedOverlappingPairCache::~b3SortedOverlappingPairCache() { } -void b3SortedOverlappingPairCache::cleanOverlappingPair(b3BroadphasePair& pair,b3Dispatcher* dispatcher) +void b3SortedOverlappingPairCache::cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher) { -/* if (pair.m_algorithm) + /* if (pair.m_algorithm) { { pair.m_algorithm->~b3CollisionAlgorithm(); @@ -570,69 +499,61 @@ void b3SortedOverlappingPairCache::cleanOverlappingPair(b3BroadphasePair& pair,b */ } - -void b3SortedOverlappingPairCache::cleanProxyFromPairs(int proxy,b3Dispatcher* dispatcher) +void b3SortedOverlappingPairCache::cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher) { - - class CleanPairCallback : public b3OverlapCallback + class CleanPairCallback : public b3OverlapCallback { int m_cleanProxy; - b3OverlappingPairCache* m_pairCache; + b3OverlappingPairCache* m_pairCache; b3Dispatcher* m_dispatcher; public: - CleanPairCallback(int cleanProxy,b3OverlappingPairCache* pairCache,b3Dispatcher* dispatcher) - :m_cleanProxy(cleanProxy), - m_pairCache(pairCache), - m_dispatcher(dispatcher) + CleanPairCallback(int cleanProxy, b3OverlappingPairCache* pairCache, b3Dispatcher* dispatcher) + : m_cleanProxy(cleanProxy), + m_pairCache(pairCache), + m_dispatcher(dispatcher) { } - virtual bool processOverlap(b3BroadphasePair& pair) + virtual bool processOverlap(b3BroadphasePair& pair) { if ((pair.x == m_cleanProxy) || (pair.y == m_cleanProxy)) { - m_pairCache->cleanOverlappingPair(pair,m_dispatcher); + m_pairCache->cleanOverlappingPair(pair, m_dispatcher); } return false; } - }; - CleanPairCallback cleanPairs(proxy,this,dispatcher); - - processAllOverlappingPairs(&cleanPairs,dispatcher); + CleanPairCallback cleanPairs(proxy, this, dispatcher); + processAllOverlappingPairs(&cleanPairs, dispatcher); } - -void b3SortedOverlappingPairCache::removeOverlappingPairsContainingProxy(int proxy,b3Dispatcher* dispatcher) +void b3SortedOverlappingPairCache::removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher* dispatcher) { - - class RemovePairCallback : public b3OverlapCallback + class RemovePairCallback : public b3OverlapCallback { int m_obsoleteProxy; public: RemovePairCallback(int obsoleteProxy) - :m_obsoleteProxy(obsoleteProxy) + : m_obsoleteProxy(obsoleteProxy) { } - virtual bool processOverlap(b3BroadphasePair& pair) + virtual bool processOverlap(b3BroadphasePair& pair) { return ((pair.x == m_obsoleteProxy) || - (pair.y == m_obsoleteProxy)); + (pair.y == m_obsoleteProxy)); } - }; RemovePairCallback removeCallback(proxy); - processAllOverlappingPairs(&removeCallback,dispatcher); + processAllOverlappingPairs(&removeCallback, dispatcher); } -void b3SortedOverlappingPairCache::sortOverlappingPairs(b3Dispatcher* dispatcher) +void b3SortedOverlappingPairCache::sortOverlappingPairs(b3Dispatcher* dispatcher) { //should already be sorted } - diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h index f67eb676f1..f1de1d94eb 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h @@ -22,152 +22,136 @@ subject to the following restrictions: class b3Dispatcher; #include "b3OverlappingPair.h" +typedef b3AlignedObjectArray<b3BroadphasePair> b3BroadphasePairArray; - -typedef b3AlignedObjectArray<b3BroadphasePair> b3BroadphasePairArray; - -struct b3OverlapCallback +struct b3OverlapCallback { virtual ~b3OverlapCallback() - {} + { + } //return true for deletion of the pair - virtual bool processOverlap(b3BroadphasePair& pair) = 0; - + virtual bool processOverlap(b3BroadphasePair& pair) = 0; }; struct b3OverlapFilterCallback { virtual ~b3OverlapFilterCallback() - {} + { + } // return true when pairs need collision - virtual bool needBroadphaseCollision(int proxy0,int proxy1) const = 0; + virtual bool needBroadphaseCollision(int proxy0, int proxy1) const = 0; }; - - - - - - extern int b3g_removePairs; extern int b3g_addedPairs; extern int b3g_findPairs; -const int B3_NULL_PAIR=0xffffffff; +const int B3_NULL_PAIR = 0xffffffff; ///The b3OverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the b3BroadphaseInterface broadphases. ///The b3HashedOverlappingPairCache and b3SortedOverlappingPairCache classes are two implementations. -class b3OverlappingPairCache +class b3OverlappingPairCache { public: - virtual ~b3OverlappingPairCache() {} // this is needed so we can get to the derived class destructor + virtual ~b3OverlappingPairCache() {} // this is needed so we can get to the derived class destructor - virtual b3BroadphasePair* getOverlappingPairArrayPtr() = 0; - - virtual const b3BroadphasePair* getOverlappingPairArrayPtr() const = 0; + virtual b3BroadphasePair* getOverlappingPairArrayPtr() = 0; - virtual b3BroadphasePairArray& getOverlappingPairArray() = 0; + virtual const b3BroadphasePair* getOverlappingPairArrayPtr() const = 0; - virtual void cleanOverlappingPair(b3BroadphasePair& pair,b3Dispatcher* dispatcher) = 0; + virtual b3BroadphasePairArray& getOverlappingPairArray() = 0; + + virtual void cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher) = 0; virtual int getNumOverlappingPairs() const = 0; - virtual void cleanProxyFromPairs(int proxy,b3Dispatcher* dispatcher) = 0; + virtual void cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher) = 0; - virtual void setOverlapFilterCallback(b3OverlapFilterCallback* callback) = 0; + virtual void setOverlapFilterCallback(b3OverlapFilterCallback* callback) = 0; - virtual void processAllOverlappingPairs(b3OverlapCallback*,b3Dispatcher* dispatcher) = 0; + virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* dispatcher) = 0; virtual b3BroadphasePair* findPair(int proxy0, int proxy1) = 0; - virtual bool hasDeferredRemoval() = 0; + virtual bool hasDeferredRemoval() = 0; //virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback)=0; - virtual b3BroadphasePair* addOverlappingPair(int proxy0,int proxy1)=0; - virtual void* removeOverlappingPair(int proxy0,int proxy1,b3Dispatcher* dispatcher)=0; - virtual void removeOverlappingPairsContainingProxy(int /*proxy0*/,b3Dispatcher* /*dispatcher*/)=0; - - virtual void sortOverlappingPairs(b3Dispatcher* dispatcher) = 0; - + virtual b3BroadphasePair* addOverlappingPair(int proxy0, int proxy1) = 0; + virtual void* removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher) = 0; + virtual void removeOverlappingPairsContainingProxy(int /*proxy0*/, b3Dispatcher* /*dispatcher*/) = 0; + virtual void sortOverlappingPairs(b3Dispatcher* dispatcher) = 0; }; /// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com class b3HashedOverlappingPairCache : public b3OverlappingPairCache { - b3BroadphasePairArray m_overlappingPairArray; + b3BroadphasePairArray m_overlappingPairArray; b3OverlapFilterCallback* m_overlapFilterCallback; -// bool m_blockedForChanges; - + // bool m_blockedForChanges; public: b3HashedOverlappingPairCache(); virtual ~b3HashedOverlappingPairCache(); - - virtual void removeOverlappingPairsContainingProxy(int proxy,b3Dispatcher* dispatcher); + virtual void removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher* dispatcher); - virtual void* removeOverlappingPair(int proxy0,int proxy1,b3Dispatcher* dispatcher); - - B3_FORCE_INLINE bool needsBroadphaseCollision(int proxy0,int proxy1) const + virtual void* removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher); + + B3_FORCE_INLINE bool needsBroadphaseCollision(int proxy0, int proxy1) const { if (m_overlapFilterCallback) - return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1); + return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1); - bool collides = true;//(proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0; + bool collides = true; //(proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0; //collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask); - + return collides; } // Add a pair and return the new pair. If the pair already exists, // no new pair is created and the old one is returned. - virtual b3BroadphasePair* addOverlappingPair(int proxy0,int proxy1) + virtual b3BroadphasePair* addOverlappingPair(int proxy0, int proxy1) { b3g_addedPairs++; - if (!needsBroadphaseCollision(proxy0,proxy1)) + if (!needsBroadphaseCollision(proxy0, proxy1)) return 0; - return internalAddPair(proxy0,proxy1); + return internalAddPair(proxy0, proxy1); } - - - void cleanProxyFromPairs(int proxy,b3Dispatcher* dispatcher); + void cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher); - - virtual void processAllOverlappingPairs(b3OverlapCallback*,b3Dispatcher* dispatcher); + virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* dispatcher); - virtual b3BroadphasePair* getOverlappingPairArrayPtr() + virtual b3BroadphasePair* getOverlappingPairArrayPtr() { return &m_overlappingPairArray[0]; } - const b3BroadphasePair* getOverlappingPairArrayPtr() const + const b3BroadphasePair* getOverlappingPairArrayPtr() const { return &m_overlappingPairArray[0]; } - b3BroadphasePairArray& getOverlappingPairArray() + b3BroadphasePairArray& getOverlappingPairArray() { return m_overlappingPairArray; } - const b3BroadphasePairArray& getOverlappingPairArray() const + const b3BroadphasePairArray& getOverlappingPairArray() const { return m_overlappingPairArray; } - void cleanOverlappingPair(b3BroadphasePair& pair,b3Dispatcher* dispatcher); - - + void cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher); b3BroadphasePair* findPair(int proxy0, int proxy1); int GetCount() const { return m_overlappingPairArray.size(); } -// b3BroadphasePair* GetPairs() { return m_pairs; } + // b3BroadphasePair* GetPairs() { return m_pairs; } b3OverlapFilterCallback* getOverlapFilterCallback() { @@ -179,19 +163,19 @@ public: m_overlapFilterCallback = callback; } - int getNumOverlappingPairs() const + int getNumOverlappingPairs() const { return m_overlappingPairArray.size(); } + private: - - b3BroadphasePair* internalAddPair(int proxy0,int proxy1); + b3BroadphasePair* internalAddPair(int proxy0, int proxy1); - void growTables(); + void growTables(); B3_FORCE_INLINE bool equalsPair(const b3BroadphasePair& pair, int proxyId1, int proxyId2) - { - return pair.x == proxyId1 && pair.y == proxyId2; + { + return pair.x == proxyId1 && pair.y == proxyId2; } /* @@ -210,43 +194,37 @@ private: } */ - - - B3_FORCE_INLINE unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2) + B3_FORCE_INLINE unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2) { - int key = static_cast<int>(((unsigned int)proxyId1) | (((unsigned int)proxyId2) <<16)); + int key = static_cast<int>(((unsigned int)proxyId1) | (((unsigned int)proxyId2) << 16)); // Thomas Wang's hash key += ~(key << 15); - key ^= (key >> 10); - key += (key << 3); - key ^= (key >> 6); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); key += ~(key << 11); - key ^= (key >> 16); + key ^= (key >> 16); return static_cast<unsigned int>(key); } - - - - B3_FORCE_INLINE b3BroadphasePair* internalFindPair(int proxy0, int proxy1, int hash) { int proxyId1 = proxy0; int proxyId2 = proxy1; - #if 0 // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat. +#if 0 // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat. if (proxyId1 > proxyId2) b3Swap(proxyId1, proxyId2); - #endif +#endif int index = m_hashTable[hash]; - - while( index != B3_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false) + + while (index != B3_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false) { index = m_next[index]; } - if ( index == B3_NULL_PAIR ) + if (index == B3_NULL_PAIR) { return NULL; } @@ -256,161 +234,142 @@ private: return &m_overlappingPairArray[index]; } - virtual bool hasDeferredRemoval() + virtual bool hasDeferredRemoval() { return false; } -/* virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback) + /* virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback) { m_ghostPairCallback = ghostPairCallback; } */ - virtual void sortOverlappingPairs(b3Dispatcher* dispatcher); - + virtual void sortOverlappingPairs(b3Dispatcher* dispatcher); protected: - - b3AlignedObjectArray<int> m_hashTable; - b3AlignedObjectArray<int> m_next; -// b3OverlappingPairCallback* m_ghostPairCallback; - + b3AlignedObjectArray<int> m_hashTable; + b3AlignedObjectArray<int> m_next; + // b3OverlappingPairCallback* m_ghostPairCallback; }; - - - ///b3SortedOverlappingPairCache maintains the objects with overlapping AABB ///Typically managed by the Broadphase, Axis3Sweep or b3SimpleBroadphase -class b3SortedOverlappingPairCache : public b3OverlappingPairCache +class b3SortedOverlappingPairCache : public b3OverlappingPairCache { - protected: - //avoid brute-force finding all the time - b3BroadphasePairArray m_overlappingPairArray; +protected: + //avoid brute-force finding all the time + b3BroadphasePairArray m_overlappingPairArray; - //during the dispatch, check that user doesn't destroy/create proxy - bool m_blockedForChanges; + //during the dispatch, check that user doesn't destroy/create proxy + bool m_blockedForChanges; - ///by default, do the removal during the pair traversal - bool m_hasDeferredRemoval; - - //if set, use the callback instead of the built in filter in needBroadphaseCollision - b3OverlapFilterCallback* m_overlapFilterCallback; + ///by default, do the removal during the pair traversal + bool m_hasDeferredRemoval; -// b3OverlappingPairCallback* m_ghostPairCallback; + //if set, use the callback instead of the built in filter in needBroadphaseCollision + b3OverlapFilterCallback* m_overlapFilterCallback; - public: - - b3SortedOverlappingPairCache(); - virtual ~b3SortedOverlappingPairCache(); + // b3OverlappingPairCallback* m_ghostPairCallback; - virtual void processAllOverlappingPairs(b3OverlapCallback*,b3Dispatcher* dispatcher); +public: + b3SortedOverlappingPairCache(); + virtual ~b3SortedOverlappingPairCache(); - void* removeOverlappingPair(int proxy0,int proxy1,b3Dispatcher* dispatcher); + virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* dispatcher); - void cleanOverlappingPair(b3BroadphasePair& pair,b3Dispatcher* dispatcher); - - b3BroadphasePair* addOverlappingPair(int proxy0,int proxy1); + void* removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher); - b3BroadphasePair* findPair(int proxy0,int proxy1); - - - void cleanProxyFromPairs(int proxy,b3Dispatcher* dispatcher); + void cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher); - virtual void removeOverlappingPairsContainingProxy(int proxy,b3Dispatcher* dispatcher); + b3BroadphasePair* addOverlappingPair(int proxy0, int proxy1); + b3BroadphasePair* findPair(int proxy0, int proxy1); - inline bool needsBroadphaseCollision(int proxy0,int proxy1) const - { - if (m_overlapFilterCallback) - return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1); + void cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher); - bool collides = true;//(proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0; - //collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask); - - return collides; - } - - b3BroadphasePairArray& getOverlappingPairArray() - { - return m_overlappingPairArray; - } + virtual void removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher* dispatcher); - const b3BroadphasePairArray& getOverlappingPairArray() const - { - return m_overlappingPairArray; - } + inline bool needsBroadphaseCollision(int proxy0, int proxy1) const + { + if (m_overlapFilterCallback) + return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1); - + bool collides = true; //(proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0; + //collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask); + return collides; + } - b3BroadphasePair* getOverlappingPairArrayPtr() - { - return &m_overlappingPairArray[0]; - } + b3BroadphasePairArray& getOverlappingPairArray() + { + return m_overlappingPairArray; + } - const b3BroadphasePair* getOverlappingPairArrayPtr() const - { - return &m_overlappingPairArray[0]; - } + const b3BroadphasePairArray& getOverlappingPairArray() const + { + return m_overlappingPairArray; + } - int getNumOverlappingPairs() const - { - return m_overlappingPairArray.size(); - } - - b3OverlapFilterCallback* getOverlapFilterCallback() - { - return m_overlapFilterCallback; - } + b3BroadphasePair* getOverlappingPairArrayPtr() + { + return &m_overlappingPairArray[0]; + } - void setOverlapFilterCallback(b3OverlapFilterCallback* callback) - { - m_overlapFilterCallback = callback; - } + const b3BroadphasePair* getOverlappingPairArrayPtr() const + { + return &m_overlappingPairArray[0]; + } - virtual bool hasDeferredRemoval() - { - return m_hasDeferredRemoval; - } + int getNumOverlappingPairs() const + { + return m_overlappingPairArray.size(); + } + + b3OverlapFilterCallback* getOverlapFilterCallback() + { + return m_overlapFilterCallback; + } -/* virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback) + void setOverlapFilterCallback(b3OverlapFilterCallback* callback) + { + m_overlapFilterCallback = callback; + } + + virtual bool hasDeferredRemoval() + { + return m_hasDeferredRemoval; + } + + /* virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback) { m_ghostPairCallback = ghostPairCallback; } */ - virtual void sortOverlappingPairs(b3Dispatcher* dispatcher); - - + virtual void sortOverlappingPairs(b3Dispatcher* dispatcher); }; - - ///b3NullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing. class b3NullPairCache : public b3OverlappingPairCache { - - b3BroadphasePairArray m_overlappingPairArray; + b3BroadphasePairArray m_overlappingPairArray; public: - - virtual b3BroadphasePair* getOverlappingPairArrayPtr() + virtual b3BroadphasePair* getOverlappingPairArrayPtr() { return &m_overlappingPairArray[0]; } - const b3BroadphasePair* getOverlappingPairArrayPtr() const + const b3BroadphasePair* getOverlappingPairArrayPtr() const { return &m_overlappingPairArray[0]; } - b3BroadphasePairArray& getOverlappingPairArray() + b3BroadphasePairArray& getOverlappingPairArray() { return m_overlappingPairArray; } - - virtual void cleanOverlappingPair(b3BroadphasePair& /*pair*/,b3Dispatcher* /*dispatcher*/) - { + virtual void cleanOverlappingPair(b3BroadphasePair& /*pair*/, b3Dispatcher* /*dispatcher*/) + { } virtual int getNumOverlappingPairs() const @@ -418,16 +377,15 @@ public: return 0; } - virtual void cleanProxyFromPairs(int /*proxy*/,b3Dispatcher* /*dispatcher*/) + virtual void cleanProxyFromPairs(int /*proxy*/, b3Dispatcher* /*dispatcher*/) { - } - virtual void setOverlapFilterCallback(b3OverlapFilterCallback* /*callback*/) + virtual void setOverlapFilterCallback(b3OverlapFilterCallback* /*callback*/) { } - virtual void processAllOverlappingPairs(b3OverlapCallback*,b3Dispatcher* /*dispatcher*/) + virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* /*dispatcher*/) { } @@ -436,39 +394,34 @@ public: return 0; } - virtual bool hasDeferredRemoval() + virtual bool hasDeferredRemoval() { return true; } -// virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* /* ghostPairCallback */) -// { -// -// } + // virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* /* ghostPairCallback */) + // { + // + // } - virtual b3BroadphasePair* addOverlappingPair(int /*proxy0*/,int /*proxy1*/) + virtual b3BroadphasePair* addOverlappingPair(int /*proxy0*/, int /*proxy1*/) { return 0; } - virtual void* removeOverlappingPair(int /*proxy0*/,int /*proxy1*/,b3Dispatcher* /*dispatcher*/) + virtual void* removeOverlappingPair(int /*proxy0*/, int /*proxy1*/, b3Dispatcher* /*dispatcher*/) { return 0; } - virtual void removeOverlappingPairsContainingProxy(int /*proxy0*/,b3Dispatcher* /*dispatcher*/) + virtual void removeOverlappingPairsContainingProxy(int /*proxy0*/, b3Dispatcher* /*dispatcher*/) { } - - virtual void sortOverlappingPairs(b3Dispatcher* dispatcher) + + virtual void sortOverlappingPairs(b3Dispatcher* dispatcher) { - (void) dispatcher; + (void)dispatcher; } - - }; - -#endif //B3_OVERLAPPING_PAIR_CACHE_H - - +#endif //B3_OVERLAPPING_PAIR_CACHE_H diff --git a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h index 7f9bf990bf..343a2c0e21 100644 --- a/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h +++ b/thirdparty/bullet/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h @@ -2,7 +2,6 @@ #ifndef B3_AABB_H #define B3_AABB_H - #include "Bullet3Common/shared/b3Float4.h" #include "Bullet3Common/shared/b3Mat3x3.h" @@ -10,44 +9,42 @@ typedef struct b3Aabb b3Aabb_t; struct b3Aabb { - union - { + union { float m_min[4]; b3Float4 m_minVec; int m_minIndices[4]; }; - union - { - float m_max[4]; + union { + float m_max[4]; b3Float4 m_maxVec; int m_signedMaxIndices[4]; }; }; -inline void b3TransformAabb2(b3Float4ConstArg localAabbMin,b3Float4ConstArg localAabbMax, float margin, - b3Float4ConstArg pos, - b3QuatConstArg orn, - b3Float4* aabbMinOut,b3Float4* aabbMaxOut) +inline void b3TransformAabb2(b3Float4ConstArg localAabbMin, b3Float4ConstArg localAabbMax, float margin, + b3Float4ConstArg pos, + b3QuatConstArg orn, + b3Float4* aabbMinOut, b3Float4* aabbMaxOut) { - b3Float4 localHalfExtents = 0.5f*(localAabbMax-localAabbMin); - localHalfExtents+=b3MakeFloat4(margin,margin,margin,0.f); - b3Float4 localCenter = 0.5f*(localAabbMax+localAabbMin); - b3Mat3x3 m; - m = b3QuatGetRotationMatrix(orn); - b3Mat3x3 abs_b = b3AbsoluteMat3x3(m); - b3Float4 center = b3TransformPoint(localCenter,pos,orn); - - b3Float4 extent = b3MakeFloat4(b3Dot3F4(localHalfExtents,b3GetRow(abs_b,0)), - b3Dot3F4(localHalfExtents,b3GetRow(abs_b,1)), - b3Dot3F4(localHalfExtents,b3GetRow(abs_b,2)), - 0.f); - *aabbMinOut = center-extent; - *aabbMaxOut = center+extent; + b3Float4 localHalfExtents = 0.5f * (localAabbMax - localAabbMin); + localHalfExtents += b3MakeFloat4(margin, margin, margin, 0.f); + b3Float4 localCenter = 0.5f * (localAabbMax + localAabbMin); + b3Mat3x3 m; + m = b3QuatGetRotationMatrix(orn); + b3Mat3x3 abs_b = b3AbsoluteMat3x3(m); + b3Float4 center = b3TransformPoint(localCenter, pos, orn); + + b3Float4 extent = b3MakeFloat4(b3Dot3F4(localHalfExtents, b3GetRow(abs_b, 0)), + b3Dot3F4(localHalfExtents, b3GetRow(abs_b, 1)), + b3Dot3F4(localHalfExtents, b3GetRow(abs_b, 2)), + 0.f); + *aabbMinOut = center - extent; + *aabbMaxOut = center + extent; } /// conservative test for overlap between two aabbs -inline bool b3TestAabbAgainstAabb(b3Float4ConstArg aabbMin1,b3Float4ConstArg aabbMax1, - b3Float4ConstArg aabbMin2, b3Float4ConstArg aabbMax2) +inline bool b3TestAabbAgainstAabb(b3Float4ConstArg aabbMin1, b3Float4ConstArg aabbMax1, + b3Float4ConstArg aabbMin2, b3Float4ConstArg aabbMax2) { bool overlap = true; overlap = (aabbMin1.x > aabbMax2.x || aabbMax1.x < aabbMin2.x) ? false : overlap; @@ -56,4 +53,4 @@ inline bool b3TestAabbAgainstAabb(b3Float4ConstArg aabbMin1,b3Float4ConstArg aab return overlap; } -#endif //B3_AABB_H +#endif //B3_AABB_H |