Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

support compound versus compound collision shape acceleration on GPU, using aabb tree versus aabb tree.

Browse Source 
Remove constructor from b3Vector3,  to make it a POD type, so it can go into a union (and more compatible with OpenCL float4)
Use b3MakeVector3 instead of constructor
Share some code between C++ and GPU in a shared file: see b3TransformAabb2 in src/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h
Improve PairBench a bit, show timings and #overlapping pairs.
Increase shadowmap default size to 8192x8192 (hope the GPU supports it)
This commit is contained in:
erwincoumans
2013-08-20 03:19:59 -07:00
parent 41ba48b10d
commit 677722bba3
62 changed files with 1827 additions and 564 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.cpp
View File

@@ -300,9 +300,9 @@ static b3DbvtNode* b3TopDown(b3DynamicBvh* pdbvt,
b3NodeArray& leaves,
int bu_treshold)
{
static const b3Vector3 axis[]={b3Vector3(1,0,0),
b3Vector3(0,1,0),
b3Vector3(0,0,1)};
static const b3Vector3 axis[]={b3MakeVector3(1,0,0),
b3MakeVector3(0,1,0),
b3MakeVector3(0,0,1)};
if(leaves.size()>1)
{
if(leaves.size()>bu_treshold)
@@ -527,7 +527,7 @@ void b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume)
bool b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume,const b3Vector3& velocity,b3Scalar margin)
{
if(leaf->volume.Contain(volume)) return(false);
volume.Expand(b3Vector3(margin,margin,margin));
volume.Expand(b3MakeVector3(margin,margin,margin));
volume.SignedExpand(velocity);
update(leaf,volume);
return(true);
@@ -546,7 +546,7 @@ bool b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume,const b3Vector
bool b3DynamicBvh::update(b3DbvtNode* leaf,b3DbvtVolume& volume,b3Scalar margin)
{
if(leaf->volume.Contain(volume)) return(false);
volume.Expand(b3Vector3(margin,margin,margin));
volume.Expand(b3MakeVector3(margin,margin,margin));
update(leaf,volume);
return(true);
}

36
src/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h
View File

@@ -404,7 +404,7 @@ inline b3DbvtAabbMm b3DbvtAabbMm::FromCE(const b3Vector3& c,const b3Vector3& e
//
inline b3DbvtAabbMm b3DbvtAabbMm::FromCR(const b3Vector3& c,b3Scalar r)
{
return(FromCE(c,b3Vector3(r,r,r)));
return(FromCE(c,b3MakeVector3(r,r,r)));
}
//
@@ -472,22 +472,22 @@ B3_DBVT_INLINE int b3DbvtAabbMm::Classify(const b3Vector3& n,b3Scalar o,int s)
b3Vector3 pi,px;
switch(s)
{
case (0+0+0): px=b3Vector3(mi.x,mi.y,mi.z);
pi=b3Vector3(mx.x,mx.y,mx.z);break;
case (1+0+0): px=b3Vector3(mx.x,mi.y,mi.z);
pi=b3Vector3(mi.x,mx.y,mx.z);break;
case (0+2+0): px=b3Vector3(mi.x,mx.y,mi.z);
pi=b3Vector3(mx.x,mi.y,mx.z);break;
case (1+2+0): px=b3Vector3(mx.x,mx.y,mi.z);
pi=b3Vector3(mi.x,mi.y,mx.z);break;
case (0+0+4): px=b3Vector3(mi.x,mi.y,mx.z);
pi=b3Vector3(mx.x,mx.y,mi.z);break;
case (1+0+4): px=b3Vector3(mx.x,mi.y,mx.z);
pi=b3Vector3(mi.x,mx.y,mi.z);break;
case (0+2+4): px=b3Vector3(mi.x,mx.y,mx.z);
pi=b3Vector3(mx.x,mi.y,mi.z);break;
case (1+2+4): px=b3Vector3(mx.x,mx.y,mx.z);
pi=b3Vector3(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);
@@ -498,7 +498,7 @@ B3_DBVT_INLINE int b3DbvtAabbMm::Classify(const b3Vector3& n,b3Scalar o,int s)
B3_DBVT_INLINE b3Scalar b3DbvtAabbMm::ProjectMinimum(const b3Vector3& v,unsigned signs) const
{
const b3Vector3* b[]={&mx,&mi};
const b3Vector3 p( b[(signs>>0)&1]->x,
const b3Vector3 p = b3MakeVector3( b[(signs>>0)&1]->x,
b[(signs>>1)&1]->y,
b[(signs>>2)&1]->z);
return(b3Dot(p,v));

2
src/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.cpp
View File

@@ -622,7 +622,7 @@ void b3DynamicBvhBroadphase::getBroadphaseAabb(b3Vector3& aabbMin,b3Vector
bounds=m_sets[0].m_root->volume;
else if(!m_sets[1].empty()) bounds=m_sets[1].m_root->volume;
else
bounds=b3DbvtVolume::FromCR(b3Vector3(0,0,0),0);
bounds=b3DbvtVolume::FromCR(b3MakeVector3(0,0,0),0);
aabbMin=bounds.Mins();
aabbMax=bounds.Maxs();
}

2
src/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h
View File

@@ -168,7 +168,7 @@ struct b3DynamicBvhBroadphase
b3BroadphaseProxy* createProxy(const b3Vector3& aabbMin,const b3Vector3& aabbMax,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask);
virtual void destroyProxy(b3BroadphaseProxy* proxy,b3Dispatcher* dispatcher);
virtual void setAabb(b3BroadphaseProxy* proxy,const b3Vector3& aabbMin,const b3Vector3& aabbMax,b3Dispatcher* dispatcher);
virtual void rayTest(const b3Vector3& rayFrom,const b3Vector3& rayTo, b3BroadphaseRayCallback& rayCallback, const b3Vector3& aabbMin=b3Vector3(0,0,0), const b3Vector3& aabbMax = b3Vector3(0,0,0));
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;

42
src/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h
View File

@@ -2,18 +2,58 @@
#ifndef B3_AABB_H
#define B3_AABB_H
#include "Bullet3Common/shared/b3Float4.h"
#include "Bullet3Common/shared/b3Mat3x3.h"
typedef struct b3Aabb b3Aabb_t;
struct b3Aabb
{
union
{
float m_min[4];
b3Float4 m_minVec;
int m_minIndices[4];
};
union
{
float m_max[4];
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)
{
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)
{
bool overlap = true;
overlap = (aabbMin1.x > aabbMax2.x || aabbMax1.x < aabbMin2.x) ? false : overlap;
overlap = (aabbMin1.z > aabbMax2.z || aabbMax1.z < aabbMin2.z) ? false : overlap;
overlap = (aabbMin1.y > aabbMax2.y || aabbMax1.y < aabbMin2.y) ? false : overlap;
return overlap;
}
#endif //B3_AABB_H