[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [16569] trunk/blender/extern/bullet2/src: Applied some fixes from Bullet: issues with btDbvtBroadphase, and btSoftBody, and better fix for 64-bit issue in btCompoundCollisionAlgorithm.
Erwin Coumans
blender at erwincoumans.com
Wed Sep 17 04:31:12 CEST 2008
Revision: 16569
http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=16569
Author: erwin
Date: 2008-09-17 04:30:19 +0200 (Wed, 17 Sep 2008)
Log Message:
-----------
Applied some fixes from Bullet: issues with btDbvtBroadphase, and btSoftBody, and better fix for 64-bit issue in btCompoundCollisionAlgorithm.
Modified Paths:
--------------
trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvt.h
trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp
trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h
trunk/blender/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
trunk/blender/extern/bullet2/src/BulletSoftBody/btSoftBody.cpp
trunk/blender/extern/bullet2/src/BulletSoftBody/btSoftBody.h
Modified: trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvt.h
===================================================================
--- trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvt.h 2008-09-17 01:49:47 UTC (rev 16568)
+++ trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvt.h 2008-09-17 02:30:19 UTC (rev 16569)
@@ -188,6 +188,7 @@
union {
btDbvtNode* childs[2];
void* data;
+ int dataAsInt;
};
};
Modified: trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp
===================================================================
--- trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp 2008-09-17 01:49:47 UTC (rev 16568)
+++ trunk/blender/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp 2008-09-17 02:30:19 UTC (rev 16569)
@@ -20,17 +20,18 @@
// Profiling
//
+#if DBVT_BP_PROFILE||DBVT_BP_ENABLE_BENCHMARK
+#include <stdio.h>
+#endif
+
#if DBVT_BP_PROFILE
-#include <stdio.h>
struct ProfileScope
{
- ProfileScope(btClock& clock,unsigned long& value)
+ __forceinline ProfileScope(btClock& clock,unsigned long& value) :
+ m_clock(&clock),m_value(&value),m_base(clock.getTimeMicroseconds())
{
- m_clock=&clock;
- m_value=&value;
- m_base=clock.getTimeMicroseconds();
}
- ~ProfileScope()
+ __forceinline ~ProfileScope()
{
(*m_value)+=m_clock->getTimeMicroseconds()-m_base;
}
@@ -90,19 +91,25 @@
struct btDbvtTreeCollider : btDbvt::ICollide
{
btDbvtBroadphase* pbp;
+btDbvtProxy* proxy;
btDbvtTreeCollider(btDbvtBroadphase* p) : pbp(p) {}
void Process(const btDbvtNode* na,const btDbvtNode* nb)
{
- btDbvtProxy* pa=(btDbvtProxy*)na->data;
- btDbvtProxy* pb=(btDbvtProxy*)nb->data;
- #if DBVT_BP_DISCRETPAIRS
- if(Intersect(pa->aabb,pb->aabb))
- #endif
+ if(na!=nb)
{
+ btDbvtProxy* pa=(btDbvtProxy*)na->data;
+ btDbvtProxy* pb=(btDbvtProxy*)nb->data;
+ #if DBVT_BP_SORTPAIRS
if(pa>pb) btSwap(pa,pb);
+ #endif
pbp->m_paircache->addOverlappingPair(pa,pb);
+ ++pbp->m_newpairs;
}
}
+void Process(const btDbvtNode* n)
+ {
+ Process(n,proxy->leaf);
+ }
};
//
@@ -112,16 +119,25 @@
//
btDbvtBroadphase::btDbvtBroadphase(btOverlappingPairCache* paircache)
{
+m_deferedcollide = false;
+m_needcleanup = true;
m_releasepaircache = (paircache!=0)?false:true;
-m_predictedframes = 2;
+m_prediction = 1/(btScalar)2;
m_stageCurrent = 0;
+m_fixedleft = 0;
m_fupdates = 1;
-m_dupdates = 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(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
+ paircache :
+ new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
m_gid = 0;
m_pid = 0;
+m_cid = 0;
for(int i=0;i<=STAGECOUNT;++i)
{
m_stageRoots[i]=0;
@@ -148,17 +164,23 @@
void* userPtr,
short int collisionFilterGroup,
short int collisionFilterMask,
- btDispatcher* /*dispatcher*/,
+ btDispatcher* dispatcher,
void* /*multiSapProxy*/)
{
-btDbvtProxy* proxy=new(btAlignedAlloc(sizeof(btDbvtProxy),16)) btDbvtProxy( userPtr,
- collisionFilterGroup,
- collisionFilterMask);
+btDbvtProxy* proxy=new(btAlignedAlloc(sizeof(btDbvtProxy),16)) btDbvtProxy( userPtr,
+ collisionFilterGroup,
+ collisionFilterMask);
proxy->aabb = btDbvtVolume::FromMM(aabbMin,aabbMax);
-proxy->leaf = m_sets[0].insert(proxy->aabb,proxy);
proxy->stage = m_stageCurrent;
proxy->m_uniqueId = ++m_gid;
+proxy->leaf = m_sets[0].insert(proxy->aabb,proxy);
listappend(proxy,m_stageRoots[m_stageCurrent]);
+if(!m_deferedcollide)
+ {
+ btDbvtTreeCollider collider(this);
+ collider.proxy=proxy;
+ btDbvt::collideTV(m_sets[0].m_root,proxy->aabb,collider);
+ }
return(proxy);
}
@@ -174,6 +196,7 @@
listremove(proxy,m_stageRoots[proxy->stage]);
m_paircache->removeOverlappingPairsContainingProxy(proxy,dispatcher);
btAlignedFree(proxy);
+m_needcleanup=true;
}
//
@@ -182,35 +205,62 @@
const btVector3& aabbMax,
btDispatcher* /*dispatcher*/)
{
-btDbvtProxy* proxy=(btDbvtProxy*)absproxy;
-btDbvtVolume aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
+btDbvtProxy* proxy=(btDbvtProxy*)absproxy;
+ATTRIBUTE_ALIGNED16(btDbvtVolume) aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
+#if DBVT_BP_PREVENTFALSEUPDATE
if(NotEqual(aabb,proxy->leaf->volume))
+#endif
{
+ 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;
}
else
{/* dynamic set */
+ ++m_updates_call;
if(Intersect(proxy->leaf->volume,aabb))
{/* Moving */
- const btVector3 delta=(aabbMin+aabbMax)/2-proxy->aabb.Center();
- #ifdef DBVT_BP_MARGIN
- m_sets[0].update(proxy->leaf,aabb,delta*m_predictedframes,DBVT_BP_MARGIN);
- #else
- m_sets[0].update(proxy->leaf,aabb,delta*m_predictedframes);
- #endif
+ const btVector3 delta=aabbMin-proxy->aabb.Mins();
+ btVector3 velocity(aabb.Extents()*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 DBVT_BP_MARGIN
+ m_sets[0].update(proxy->leaf,aabb,velocity,DBVT_BP_MARGIN)
+ #else
+ m_sets[0].update(proxy->leaf,aabb,velocity)
+ #endif
+ )
+ {
+ ++m_updates_done;
+ docollide=true;
+ }
}
else
{/* Teleporting */
- m_sets[0].update(proxy->leaf,aabb);
+ m_sets[0].update(proxy->leaf,aabb);
+ ++m_updates_done;
+ docollide=true;
}
}
listremove(proxy,m_stageRoots[proxy->stage]);
proxy->aabb = aabb;
proxy->stage = m_stageCurrent;
listappend(proxy,m_stageRoots[m_stageCurrent]);
+ if(docollide)
+ {
+ m_needcleanup=true;
+ if(!m_deferedcollide)
+ {
+ btDbvtTreeCollider collider(this);
+ btDbvt::collideTT(m_sets[1].m_root,proxy->leaf,collider);
+ btDbvt::collideTT(m_sets[0].m_root,proxy->leaf,collider);
+ }
+ }
}
}
@@ -245,7 +295,12 @@
SPC(m_profiling.m_total);
/* optimize */
m_sets[0].optimizeIncremental(1+(m_sets[0].m_leaves*m_dupdates)/100);
-m_sets[1].optimizeIncremental(1+(m_sets[1].m_leaves*m_fupdates)/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=btMax<int>(0,m_fixedleft-count);
+ }
/* dynamic -> fixed set */
m_stageCurrent=(m_stageCurrent+1)%STAGECOUNT;
btDbvtProxy* current=m_stageRoots[m_stageCurrent];
@@ -256,46 +311,69 @@
btDbvtProxy* next=current->links[1];
listremove(current,m_stageRoots[current->stage]);
listappend(current,m_stageRoots[STAGECOUNT]);
- btDbvt::collideTT(m_sets[1].m_root,current->leaf,collider);
+ #if DBVT_BP_ACCURATESLEEPING
+ m_paircache->removeOverlappingPairsContainingProxy(current,dispatcher);
+ collider.proxy=current;
+ btDbvt::collideTV(m_sets[0].m_root,current->aabb,collider);
+ btDbvt::collideTV(m_sets[1].m_root,current->aabb,collider);
+ #endif
m_sets[0].remove(current->leaf);
current->leaf = m_sets[1].insert(current->aabb,current);
current->stage = STAGECOUNT;
current = next;
} while(current);
+ m_fixedleft=m_sets[1].m_leaves;
+ m_needcleanup=true;
}
/* collide dynamics */
{
btDbvtTreeCollider collider(this);
+ if(m_deferedcollide)
{
SPC(m_profiling.m_fdcollide);
btDbvt::collideTT(m_sets[0].m_root,m_sets[1].m_root,collider);
}
+ if(m_deferedcollide)
{
SPC(m_profiling.m_ddcollide);
btDbvt::collideTT(m_sets[0].m_root,m_sets[0].m_root,collider);
}
}
/* clean up */
+if(m_needcleanup)
{
SPC(m_profiling.m_cleanup);
btBroadphasePairArray& pairs=m_paircache->getOverlappingPairArray();
if(pairs.size()>0)
{
- for(int i=0,ni=pairs.size();i<ni;++i)
+ const int ci=pairs.size();
+ int ni=btMin(ci,btMax<int>(m_newpairs,(ci*m_cupdates)/100));
+ for(int i=0;i<ni;++i)
{
- btBroadphasePair& p=pairs[i];
- btDbvtProxy* pa=(btDbvtProxy*)p.m_pProxy0;
- btDbvtProxy* pb=(btDbvtProxy*)p.m_pProxy1;
- if(!Intersect(pa->aabb,pb->aabb))
+ btBroadphasePair& p=pairs[(m_cid+i)%ci];
+ btDbvtProxy* pa=(btDbvtProxy*)p.m_pProxy0;
+ btDbvtProxy* pb=(btDbvtProxy*)p.m_pProxy1;
+ if(!Intersect(pa->leaf->volume,pb->leaf->volume))
{
+ #if DBVT_BP_SORTPAIRS
if(pa>pb) btSwap(pa,pb);
+ #endif
m_paircache->removeOverlappingPair(pa,pb,dispatcher);
--ni;--i;
}
}
+ 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/(btScalar)m_updates_call; }
+ else
+ { m_updates_ratio=0; }
+m_updates_done/=2;
+m_updates_call/=2;
}
//
@@ -339,6 +417,131 @@
void btDbvtBroadphase::printStats()
{}
+//
+#if DBVT_BP_ENABLE_BENCHMARK
+
+struct btBroadphaseBenchmark
+ {
+ struct Experiment
+ {
+ const char* name;
+ int object_count;
+ int update_count;
+ int spawn_count;
+ int iterations;
+ btScalar speed;
+ btScalar amplitude;
+ };
+ struct Object
+ {
+ btVector3 center;
+ btVector3 extents;
+ btBroadphaseProxy* proxy;
+ btScalar time;
+ void update(btScalar speed,btScalar amplitude,btBroadphaseInterface* pbi)
+ {
+ time += speed;
+ center[0] = btCos(time*(btScalar)2.17)*amplitude+
+ btSin(time)*amplitude/2;
+ center[1] = btCos(time*(btScalar)1.38)*amplitude+
+ btSin(time)*amplitude;
+ center[2] = btSin(time*(btScalar)0.777)*amplitude;
+ pbi->setAabb(proxy,center-extents,center+extents,0);
+ }
+ };
+ static int UnsignedRand(int range=RAND_MAX-1) { return(rand()%(range+1)); }
+ static btScalar UnitRand() { return(UnsignedRand(16384)/(btScalar)16384); }
+ static void OutputTime(const char* name,btClock& c,unsigned count=0)
+ {
+ const unsigned long us=c.getTimeMicroseconds();
+ const unsigned long ms=(us+500)/1000;
+ const btScalar sec=us/(btScalar)(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);
+ }
+ };
+
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list