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

rename HasHit method to hasHit

Browse Source 
rename AddSingleResult to addSingleResult
moved collision filtering for btCollisionWorld::rayTest and btCollisionWorld::convexSweepTest from argument to the callback needsCollision
This commit is contained in:
erwin.coumans
2008-07-09 23:30:21 +00:00
parent 9996da6f2d
commit b66e5350d0
18 changed files with 108 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Demos/Benchmarks/BenchmarkDemo.cpp
View File

@@ -141,7 +141,7 @@ public:
btCollisionWorld::ClosestRayResultCallback cb(source[i], dest[i]); btCollisionWorld::ClosestRayResultCallback cb(source[i], dest[i]);
cw->rayTest (source[i], dest[i], cb); cw->rayTest (source[i], dest[i], cb);
if (cb.HasHit ()) if (cb.hasHit ())
{ {
hit[i] = cb.m_hitPointWorld; hit[i] = cb.m_hitPointWorld;
normal[i] = cb.m_hitNormalWorld; normal[i] = cb.m_hitNormalWorld;

7
Demos/CharacterDemo/CharacterDemo.cpp
View File

@@ -46,7 +46,7 @@ static int gJump = 0;
///playerStepCallback is the main function that is updating the character. ///playerStepCallback is the main function that is updating the character.
///Register this callback using: m_dynamicsWorld->setInternalTickCallback(playerStepCallback,m_character); ///Register this callback using: m_dynamicsWorld->setInternalTickCallback(playerStepCallback,m_character);
///This function will be called at the end of each internal simulation time step ///This function will be called at the end of each internal simulation time step
void playerStepCallback(const btDynamicsWorld* dynamicsWorld, btScalar timeStep) void playerStepCallback(btDynamicsWorld* dynamicsWorld, btScalar timeStep)
{ {
CharacterControllerInterface* characterInterface= (CharacterControllerInterface*) dynamicsWorld->getWorldUserInfo(); CharacterControllerInterface* characterInterface= (CharacterControllerInterface*) dynamicsWorld->getWorldUserInfo();
characterInterface->preStep (dynamicsWorld); characterInterface->preStep (dynamicsWorld);
@@ -501,10 +501,9 @@ const float TRIANGLE_SIZE=20.f;
sweepBP->setOverlappingPairUserCallback(m_customPairCallback); sweepBP->setOverlappingPairUserCallback(m_customPairCallback);
m_character->registerPairCacheAndDispatcher (m_customPairCallback->getOverlappingPairCache(), m_dispatcher); m_character->registerPairCacheAndDispatcher (m_customPairCallback->getOverlappingPairCache(), m_dispatcher);
m_dynamicsWorld->addCollisionObject(m_character->getCollisionObject(),btBroadphaseProxy::DebrisFilter, btBroadphaseProxy::StaticFilter);//AllFilter); ///only collide with static for now (no interaction with dynamic objects)
m_dynamicsWorld->addCollisionObject(m_character->getCollisionObject(),btBroadphaseProxy::DebrisFilter, btBroadphaseProxy::StaticFilter);
clientResetScene(); clientResetScene();
setCameraDistance(26.f); setCameraDistance(26.f);

6
Demos/CharacterDemo/DynamicCharacterController.cpp
View File

@@ -90,12 +90,12 @@ void DynamicCharacterController::preStep (const btCollisionWorld* collisionWorld
m_me = me; m_me = me;
} }
virtual btScalar AddSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace) virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace)
{ {
if (rayResult.m_collisionObject == m_me) if (rayResult.m_collisionObject == m_me)
return 1.0; return 1.0;
return ClosestRayResultCallback::AddSingleResult (rayResult, normalInWorldSpace return ClosestRayResultCallback::addSingleResult (rayResult, normalInWorldSpace
); );
} }
protected: protected:
@@ -109,7 +109,7 @@ void DynamicCharacterController::preStep (const btCollisionWorld* collisionWorld
{ {
rayCallback.m_closestHitFraction = 1.0; rayCallback.m_closestHitFraction = 1.0;
collisionWorld->rayTest (m_raySource[i], m_rayTarget[i], rayCallback); collisionWorld->rayTest (m_raySource[i], m_rayTarget[i], rayCallback);
if (rayCallback.HasHit()) if (rayCallback.hasHit())
{ {
m_rayLambda[i] = rayCallback.m_closestHitFraction; m_rayLambda[i] = rayCallback.m_closestHitFraction;
} else { } else {

22
Demos/CharacterDemo/KinematicCharacterController.cpp
View File

@@ -9,7 +9,6 @@
#include "KinematicCharacterController.h" #include "KinematicCharacterController.h"
/* TODO: /* TODO:
* Fix jitter
* Interact with dynamic objects * Interact with dynamic objects
* Ride kinematicly animated platforms properly * Ride kinematicly animated platforms properly
* More realistic (or maybe just a config option) falling * More realistic (or maybe just a config option) falling
@@ -25,12 +24,12 @@ public:
m_me = me; m_me = me;
} }
virtual btScalar AddSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace) virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace)
{ {
if (rayResult.m_collisionObject == m_me) if (rayResult.m_collisionObject == m_me)
return 1.0; return 1.0;
return ClosestRayResultCallback::AddSingleResult (rayResult, normalInWorldSpace); return ClosestRayResultCallback::addSingleResult (rayResult, normalInWorldSpace);
} }
protected: protected:
btCollisionObject* m_me; btCollisionObject* m_me;
@@ -44,12 +43,12 @@ public:
m_me = me; m_me = me;
} }
virtual btScalar AddSingleResult(btCollisionWorld::LocalConvexResult& convexResult,bool normalInWorldSpace) virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult,bool normalInWorldSpace)
{ {
if (convexResult.m_hitCollisionObject == m_me) if (convexResult.m_hitCollisionObject == m_me)
return 1.0; return 1.0;
return ClosestConvexResultCallback::AddSingleResult (convexResult, normalInWorldSpace); return ClosestConvexResultCallback::addSingleResult (convexResult, normalInWorldSpace);
} }
protected: protected:
btCollisionObject* m_me; btCollisionObject* m_me;
@@ -213,10 +212,12 @@ void KinematicCharacterController::stepUp (const btCollisionWorld* world)
end.setOrigin (m_targetPosition); end.setOrigin (m_targetPosition);
ClosestNotMeConvexResultCallback callback (m_collisionObject); ClosestNotMeConvexResultCallback callback (m_collisionObject);
callback.m_collisionFilterGroup = getCollisionObject()->getBroadphaseHandle()->m_collisionFilterGroup;
callback.m_collisionFilterMask = getCollisionObject()->getBroadphaseHandle()->m_collisionFilterMask;
world->convexSweepTest (m_shape, start, end, callback); world->convexSweepTest (m_shape, start, end, callback);
if (callback.HasHit()) if (callback.hasHit())
{ {
// we moved up only a fraction of the step height // we moved up only a fraction of the step height
m_currentStepOffset = m_stepHeight * callback.m_closestHitFraction; m_currentStepOffset = m_stepHeight * callback.m_closestHitFraction;
@@ -296,6 +297,9 @@ void KinematicCharacterController::stepForwardAndStrafe (const btCollisionWorld*
end.setOrigin (m_targetPosition); end.setOrigin (m_targetPosition);
ClosestNotMeConvexResultCallback callback (m_collisionObject); ClosestNotMeConvexResultCallback callback (m_collisionObject);
callback.m_collisionFilterGroup = getCollisionObject()->getBroadphaseHandle()->m_collisionFilterGroup;
callback.m_collisionFilterMask = getCollisionObject()->getBroadphaseHandle()->m_collisionFilterMask;
//btScalar margin = m_shape->getMargin(); //btScalar margin = m_shape->getMargin();
//m_shape->setMargin(margin - 0.06f); //m_shape->setMargin(margin - 0.06f);
@@ -305,7 +309,7 @@ void KinematicCharacterController::stepForwardAndStrafe (const btCollisionWorld*
fraction -= callback.m_closestHitFraction; fraction -= callback.m_closestHitFraction;
if (callback.HasHit()) if (callback.hasHit())
{ {
// we moved only a fraction // we moved only a fraction
btScalar hitDistance = (callback.m_hitPointWorld - m_currentPosition).length(); btScalar hitDistance = (callback.m_hitPointWorld - m_currentPosition).length();
@@ -364,10 +368,12 @@ void KinematicCharacterController::stepDown (const btCollisionWorld* collisionWo
end.setOrigin (m_targetPosition); end.setOrigin (m_targetPosition);
ClosestNotMeConvexResultCallback callback (m_collisionObject); ClosestNotMeConvexResultCallback callback (m_collisionObject);
callback.m_collisionFilterGroup = getCollisionObject()->getBroadphaseHandle()->m_collisionFilterGroup;
callback.m_collisionFilterMask = getCollisionObject()->getBroadphaseHandle()->m_collisionFilterMask;
collisionWorld->convexSweepTest (m_shape, start, end, callback); collisionWorld->convexSweepTest (m_shape, start, end, callback);
if (callback.HasHit()) if (callback.hasHit())
{ {
// we dropped a fraction of the height -> hit floor // we dropped a fraction of the height -> hit floor
m_currentPosition.setInterpolate3 (m_currentPosition, m_targetPosition, callback.m_closestHitFraction); m_currentPosition.setInterpolate3 (m_currentPosition, m_targetPosition, callback.m_closestHitFraction);

2
Demos/ConcaveConvexcastDemo/ConcaveConvexcastDemo.cpp
View File

@@ -162,7 +162,7 @@ public:
btTransform from(qFrom, source[i]); btTransform from(qFrom, source[i]);
btTransform to(qTo, dest[i]); btTransform to(qTo, dest[i]);
cw->convexSweepTest (&boxShape, from, to, cb); cw->convexSweepTest (&boxShape, from, to, cb);
if (cb.HasHit ()) if (cb.hasHit ())
{ {
hit_surface[i] = cb.m_hitPointWorld; hit_surface[i] = cb.m_hitPointWorld;
hit_com[i].setInterpolate3(source[i], dest[i], cb.m_closestHitFraction); hit_com[i].setInterpolate3(source[i], dest[i], cb.m_closestHitFraction);

2
Demos/ConcaveRaycastDemo/ConcaveRaycastDemo.cpp
View File

@@ -181,7 +181,7 @@ public:
btCollisionWorld::ClosestRayResultCallback cb(source[i], dest[i]); btCollisionWorld::ClosestRayResultCallback cb(source[i], dest[i]);
cw->rayTest (source[i], dest[i], cb); cw->rayTest (source[i], dest[i], cb);
if (cb.HasHit ()) if (cb.hasHit ())
{ {
hit[i] = cb.m_hitPointWorld; hit[i] = cb.m_hitPointWorld;
normal[i] = cb.m_hitNormalWorld; normal[i] = cb.m_hitNormalWorld;

4
Demos/OpenGL/DemoApplication.cpp
View File

@@ -626,7 +626,7 @@ void DemoApplication::mouseFunc(int button, int state, int x, int y)
{ {
btCollisionWorld::ClosestRayResultCallback rayCallback(m_cameraPosition,rayTo); btCollisionWorld::ClosestRayResultCallback rayCallback(m_cameraPosition,rayTo);
m_dynamicsWorld->rayTest(m_cameraPosition,rayTo,rayCallback); m_dynamicsWorld->rayTest(m_cameraPosition,rayTo,rayCallback);
if (rayCallback.HasHit()) if (rayCallback.hasHit())
{ {
btRigidBody* body = btRigidBody::upcast(rayCallback.m_collisionObject); btRigidBody* body = btRigidBody::upcast(rayCallback.m_collisionObject);
@@ -662,7 +662,7 @@ void DemoApplication::mouseFunc(int button, int state, int x, int y)
{ {
btCollisionWorld::ClosestRayResultCallback rayCallback(m_cameraPosition,rayTo); btCollisionWorld::ClosestRayResultCallback rayCallback(m_cameraPosition,rayTo);
m_dynamicsWorld->rayTest(m_cameraPosition,rayTo,rayCallback); m_dynamicsWorld->rayTest(m_cameraPosition,rayTo,rayCallback);
if (rayCallback.HasHit()) if (rayCallback.hasHit())
{ {

6
Demos/Raytracer/Raytracer.cpp
View File

@@ -189,7 +189,7 @@ bool Raytracer::worldRaytest(const btVector3& rayFrom,const btVector3& rayTo,btV
btVector3 m_hitNormalWorld; btVector3 m_hitNormalWorld;
btVector3 m_hitPointWorld; btVector3 m_hitPointWorld;
virtual btScalar AddSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace) virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace)
{ {
//caller already does the filter on the m_closestHitFraction //caller already does the filter on the m_closestHitFraction
@@ -215,7 +215,7 @@ bool Raytracer::worldRaytest(const btVector3& rayFrom,const btVector3& rayTo,btV
AllRayResultCallback resultCallback(rayFrom,rayTo); AllRayResultCallback resultCallback(rayFrom,rayTo);
// btCollisionWorld::ClosestRayResultCallback resultCallback(rayFrom,rayTo); // btCollisionWorld::ClosestRayResultCallback resultCallback(rayFrom,rayTo);
m_collisionWorld->rayTest(rayFrom,rayTo,resultCallback); m_collisionWorld->rayTest(rayFrom,rayTo,resultCallback);
if (resultCallback.HasHit()) if (resultCallback.hasHit())
{ {
worldNormal = resultCallback.m_hitNormalWorld; worldNormal = resultCallback.m_hitNormalWorld;
return true; return true;
@@ -261,7 +261,7 @@ bool Raytracer::singleObjectRaytest(const btVector3& rayFrom,const btVector3& ra
//reset previous result //reset previous result
btCollisionWorld::rayTestSingle(rayFromTrans,rayToTrans, &tmpObj, shapePtr[s], transforms[s], resultCallback); btCollisionWorld::rayTestSingle(rayFromTrans,rayToTrans, &tmpObj, shapePtr[s], transforms[s], resultCallback);
if (resultCallback.HasHit()) if (resultCallback.hasHit())
{ {
//float fog = 1.f - 0.1f * rayResult.m_fraction; //float fog = 1.f - 0.1f * rayResult.m_fraction;
resultCallback.m_hitNormalWorld.normalize();//.m_normal.normalize(); resultCallback.m_hitNormalWorld.normalize();//.m_normal.normalize();

4
Extras/BulletMultiThreaded/SpuRaycastTaskProcess.cpp
View File

@@ -16,7 +16,7 @@ subject to the following restrictions:
#include "SpuRaycastTaskProcess.h" #include "SpuRaycastTaskProcess.h"
SpuRaycastTaskProcess::SpuRaycastTaskProcess(class btThreadSupportInterface* threadInterface, unsigned int maxNumOutstandingTasks) SpuRaycastTaskProcess::SpuRaycastTaskProcess(class btThreadSupportInterface* threadInterface, int maxNumOutstandingTasks)
:m_threadInterface(threadInterface), :m_threadInterface(threadInterface),
m_maxNumOutstandingTasks(maxNumOutstandingTasks) m_maxNumOutstandingTasks(maxNumOutstandingTasks)
{ {
@@ -122,7 +122,7 @@ void SpuRaycastTaskProcess::addWorkToTask(SpuRaycastTaskWorkUnit& workunit)
m_currentWorkUnitInTask = 0; m_currentWorkUnitInTask = 0;
// find new task buffer // find new task buffer
for (unsigned int i = 0; i < m_maxNumOutstandingTasks; i++) for (int i = 0; i < m_maxNumOutstandingTasks; i++)
{ {
if (!m_taskBusy[i]) if (!m_taskBusy[i])
{ {

10
Extras/BulletMultiThreaded/SpuRaycastTaskProcess.h
View File

@@ -40,20 +40,20 @@ class SpuRaycastTaskProcess
btThreadSupportInterface* m_threadInterface; btThreadSupportInterface* m_threadInterface;
unsigned int m_maxNumOutstandingTasks; int m_maxNumOutstandingTasks;
unsigned int m_numBusyTasks; int m_numBusyTasks;
// the current task and the current entry to insert a new work unit // the current task and the current entry to insert a new work unit
unsigned int m_currentTask; int m_currentTask;
unsigned int m_currentWorkUnitInTask; int m_currentWorkUnitInTask;
int m_numSpuCollisionObjectWrappers; int m_numSpuCollisionObjectWrappers;
void* m_spuCollisionObjectWrappers; void* m_spuCollisionObjectWrappers;
void issueTask2(); void issueTask2();
//void postProcess(unsigned int taskId, int outputSize); //void postProcess(unsigned int taskId, int outputSize);
public: public:
SpuRaycastTaskProcess(btThreadSupportInterface* threadInterface, unsigned int maxNumOutstandingTasks); SpuRaycastTaskProcess(btThreadSupportInterface* threadInterface, int maxNumOutstandingTasks);
~SpuRaycastTaskProcess(); ~SpuRaycastTaskProcess();

2
src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h
View File

@@ -79,7 +79,7 @@ BT_DECLARE_ALIGNED_ALLOCATOR();
KinematicFilter = 4, KinematicFilter = 4,
DebrisFilter = 8, DebrisFilter = 8,
SensorTrigger = 16, SensorTrigger = 16,
AllFilter = DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger AllFilter = -1 //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger
}; };
//Usually the client btCollisionObject or Rigidbody class //Usually the client btCollisionObject or Rigidbody class

2
src/BulletCollision/BroadphaseCollision/btDbvt.cpp
View File

@@ -1162,4 +1162,4 @@ if(cfgBenchmark15_Enable)
} }
printf("\r\n\r\n"); printf("\r\n\r\n");
} }
#endif #endif

6
src/BulletCollision/BroadphaseCollision/btDbvt.h
View File

@@ -191,7 +191,7 @@ struct btDbvt
// Constants // Constants
enum { enum {
SIMPLE_STACKSIZE = 64, SIMPLE_STACKSIZE = 64,
DOUBLE_STACKSIZE = SIMPLE_STACKSIZE*2, DOUBLE_STACKSIZE = SIMPLE_STACKSIZE*2
}; };
// Fields // Fields
@@ -759,7 +759,7 @@ if(root)
const int inside=(1<<count)-1; const int inside=(1<<count)-1;
btAlignedObjectArray<sStkNP> stack; btAlignedObjectArray<sStkNP> stack;
int signs[sizeof(unsigned)*8]; int signs[sizeof(unsigned)*8];
btAssert(count<(sizeof(signs)/sizeof(signs[0]))); btAssert(count<int (sizeof(signs)/sizeof(signs[0])));
for(int i=0;i<count;++i) for(int i=0;i<count;++i)
{ {
signs[i]= ((normals[i].x()>=0)?1:0)+ signs[i]= ((normals[i].x()>=0)?1:0)+
@@ -821,7 +821,7 @@ if(root)
btAlignedObjectArray<int> ifree; btAlignedObjectArray<int> ifree;
btAlignedObjectArray<int> stack; btAlignedObjectArray<int> stack;
int signs[sizeof(unsigned)*8]; int signs[sizeof(unsigned)*8];
btAssert(count<(sizeof(signs)/sizeof(signs[0]))); btAssert(count<int (sizeof(signs)/sizeof(signs[0])));
for(int i=0;i<count;++i) for(int i=0;i<count;++i)
{ {
signs[i]= ((normals[i].x()>=0)?1:0)+ signs[i]= ((normals[i].x()>=0)?1:0)+

31
src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
View File

@@ -213,7 +213,7 @@ void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
btCollisionObject* collisionObject, btCollisionObject* collisionObject,
const btCollisionShape* collisionShape, const btCollisionShape* collisionShape,
const btTransform& colObjWorldTransform, const btTransform& colObjWorldTransform,
RayResultCallback& resultCallback,short int collisionFilterMask) RayResultCallback& resultCallback)
{ {
btSphereShape pointShape(btScalar(0.0)); btSphereShape pointShape(btScalar(0.0));
pointShape.setMargin(0.f); pointShape.setMargin(0.f);
@@ -256,7 +256,7 @@ void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
); );
bool normalInWorldSpace = true; bool normalInWorldSpace = true;
resultCallback.AddSingleResult(localRayResult, normalInWorldSpace); resultCallback.addSingleResult(localRayResult, normalInWorldSpace);
} }
} }
@@ -302,7 +302,7 @@ void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
hitFraction); hitFraction);
bool normalInWorldSpace = false; bool normalInWorldSpace = false;
return m_resultCallback->AddSingleResult(rayResult,normalInWorldSpace); return m_resultCallback->addSingleResult(rayResult,normalInWorldSpace);
} }
}; };
@@ -350,7 +350,7 @@ void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
hitFraction); hitFraction);
bool normalInWorldSpace = false; bool normalInWorldSpace = false;
return m_resultCallback->AddSingleResult(rayResult,normalInWorldSpace); return m_resultCallback->addSingleResult(rayResult,normalInWorldSpace);
} }
@@ -383,7 +383,7 @@ void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
collisionObject, collisionObject,
childCollisionShape, childCollisionShape,
childWorldTrans, childWorldTrans,
resultCallback, collisionFilterMask); resultCallback);
} }
} }
@@ -395,7 +395,7 @@ void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape,const bt
btCollisionObject* collisionObject, btCollisionObject* collisionObject,
const btCollisionShape* collisionShape, const btCollisionShape* collisionShape,
const btTransform& colObjWorldTransform, const btTransform& colObjWorldTransform,
ConvexResultCallback& resultCallback, btScalar allowedPenetration,short int collisionFilterMask) ConvexResultCallback& resultCallback, btScalar allowedPenetration)
{ {
if (collisionShape->isConvex()) if (collisionShape->isConvex())
{ {
@@ -435,7 +435,7 @@ void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape,const bt
); );
bool normalInWorldSpace = true; bool normalInWorldSpace = true;
resultCallback.AddSingleResult(localConvexResult, normalInWorldSpace); resultCallback.addSingleResult(localConvexResult, normalInWorldSpace);
} }
} }
@@ -487,7 +487,7 @@ void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape,const bt
bool normalInWorldSpace = true; bool normalInWorldSpace = true;
return m_resultCallback->AddSingleResult(convexResult,normalInWorldSpace); return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
} }
return hitFraction; return hitFraction;
} }
@@ -542,7 +542,7 @@ void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape,const bt
bool normalInWorldSpace = false; bool normalInWorldSpace = false;
return m_resultCallback->AddSingleResult(convexResult,normalInWorldSpace); return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
} }
return hitFraction; return hitFraction;
} }
@@ -577,14 +577,14 @@ void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape,const bt
collisionObject, collisionObject,
childCollisionShape, childCollisionShape,
childWorldTrans, childWorldTrans,
resultCallback, allowedPenetration,collisionFilterMask); resultCallback, allowedPenetration);
} }
} }
} }
} }
} }
void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback,short int collisionFilterMask) const void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
{ {
@@ -606,7 +606,7 @@ void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r
btCollisionObject* collisionObject= m_collisionObjects[i]; btCollisionObject* collisionObject= m_collisionObjects[i];
//only perform raycast if filterMask matches //only perform raycast if filterMask matches
if(collisionObject->getBroadphaseHandle()->m_collisionFilterGroup & collisionFilterMask) { if(resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject(); //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
btVector3 collisionObjectAabbMin,collisionObjectAabbMax; btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax); collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
@@ -627,7 +627,7 @@ void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r
} }
void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, ConvexResultCallback& resultCallback,short int collisionFilterMask) const void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, ConvexResultCallback& resultCallback) const
{ {
btTransform convexFromTrans,convexToTrans; btTransform convexFromTrans,convexToTrans;
convexFromTrans = convexFromWorld; convexFromTrans = convexFromWorld;
@@ -650,7 +650,7 @@ void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btT
{ {
btCollisionObject* collisionObject= m_collisionObjects[i]; btCollisionObject* collisionObject= m_collisionObjects[i];
//only perform raycast if filterMask matches //only perform raycast if filterMask matches
if(collisionObject->getBroadphaseHandle()->m_collisionFilterGroup & collisionFilterMask) { if(resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject(); //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
btVector3 collisionObjectAabbMin,collisionObjectAabbMax; btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax); collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
@@ -664,8 +664,7 @@ void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btT
collisionObject->getCollisionShape(), collisionObject->getCollisionShape(),
collisionObject->getWorldTransform(), collisionObject->getWorldTransform(),
resultCallback, resultCallback,
getDispatchInfo().m_allowedCcdPenetration, getDispatchInfo().m_allowedCcdPenetration);
collisionFilterMask);
} }
} }
} }

59
src/BulletCollision/CollisionDispatch/btCollisionWorld.h
View File

@@ -177,21 +177,34 @@ public:
{ {
btScalar m_closestHitFraction; btScalar m_closestHitFraction;
btCollisionObject* m_collisionObject; btCollisionObject* m_collisionObject;
short int m_collisionFilterGroup;
short int m_collisionFilterMask;
virtual ~RayResultCallback() virtual ~RayResultCallback()
{ {
} }
bool HasHit() bool hasHit()
{ {
return (m_collisionObject != 0); return (m_collisionObject != 0);
} }
RayResultCallback() RayResultCallback()
:m_closestHitFraction(btScalar(1.)), :m_closestHitFraction(btScalar(1.)),
m_collisionObject(0) m_collisionObject(0),
m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
m_collisionFilterMask(btBroadphaseProxy::AllFilter)
{ {
} }
virtual btScalar AddSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) = 0;
virtual bool needsCollision(btBroadphaseProxy* proxy0) const
{
bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
return collides;
}
virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) = 0;
}; };
struct ClosestRayResultCallback : public RayResultCallback struct ClosestRayResultCallback : public RayResultCallback
@@ -208,7 +221,7 @@ public:
btVector3 m_hitNormalWorld; btVector3 m_hitNormalWorld;
btVector3 m_hitPointWorld; btVector3 m_hitPointWorld;
virtual btScalar AddSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
{ {
//caller already does the filter on the m_closestHitFraction //caller already does the filter on the m_closestHitFraction
btAssert(rayResult.m_hitFraction <= m_closestHitFraction); btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
@@ -255,20 +268,36 @@ public:
///RayResultCallback is used to report new raycast results ///RayResultCallback is used to report new raycast results
struct ConvexResultCallback struct ConvexResultCallback
{ {
btScalar m_closestHitFraction;
short int m_collisionFilterGroup;
short int m_collisionFilterMask;
ConvexResultCallback()
:m_closestHitFraction(btScalar(1.)),
m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
m_collisionFilterMask(btBroadphaseProxy::AllFilter)
{
}
virtual ~ConvexResultCallback() virtual ~ConvexResultCallback()
{ {
} }
btScalar m_closestHitFraction;
bool HasHit() bool hasHit()
{ {
return (m_closestHitFraction < btScalar(1.)); return (m_closestHitFraction < btScalar(1.));
} }
ConvexResultCallback()
:m_closestHitFraction(btScalar(1.))
virtual bool needsCollision(btBroadphaseProxy* proxy0) const
{ {
bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
return collides;
} }
virtual btScalar AddSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) = 0;
virtual btScalar addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) = 0;
}; };
struct ClosestConvexResultCallback : public ConvexResultCallback struct ClosestConvexResultCallback : public ConvexResultCallback
@@ -287,7 +316,7 @@ public:
btVector3 m_hitPointWorld; btVector3 m_hitPointWorld;
btCollisionObject* m_hitCollisionObject; btCollisionObject* m_hitCollisionObject;
virtual btScalar AddSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) virtual btScalar addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
{ {
//caller already does the filter on the m_closestHitFraction //caller already does the filter on the m_closestHitFraction
btAssert(convexResult.m_hitFraction <= m_closestHitFraction); btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
@@ -314,11 +343,11 @@ public:
/// rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback /// rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback
/// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback. /// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.
void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback, short int collisionFilterMask=-1) const; void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
// convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback // convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback
// This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback. // This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback.
void convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback, short int collisionFilterMask=-1) const; void convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback) const;
/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. /// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
@@ -328,16 +357,16 @@ public:
btCollisionObject* collisionObject, btCollisionObject* collisionObject,
const btCollisionShape* collisionShape, const btCollisionShape* collisionShape,
const btTransform& colObjWorldTransform, const btTransform& colObjWorldTransform,
RayResultCallback& resultCallback, short int collisionFilterMask=-1); RayResultCallback& resultCallback);
/// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest. /// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans, static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans,
btCollisionObject* collisionObject, btCollisionObject* collisionObject,
const btCollisionShape* collisionShape, const btCollisionShape* collisionShape,
const btTransform& colObjWorldTransform, const btTransform& colObjWorldTransform,
ConvexResultCallback& resultCallback, btScalar allowedPenetration, short int collisionFilterMask=-1); ConvexResultCallback& resultCallback, btScalar allowedPenetration);
void addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=1,short int collisionFilterMask=1); void addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter);
btCollisionObjectArray& getCollisionObjectArray() btCollisionObjectArray& getCollisionObjectArray()
{ {

4
src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp
View File

@@ -133,8 +133,8 @@ void btDiscreteDynamicsWorld::debugDrawWorld()
for (int i=0;i<numManifolds;i++) for (int i=0;i<numManifolds;i++)
{ {
btPersistentManifold* contactManifold = getDispatcher()->getManifoldByIndexInternal(i); btPersistentManifold* contactManifold = getDispatcher()->getManifoldByIndexInternal(i);
btCollisionObject* obA = static_cast<btCollisionObject*>(contactManifold->getBody0()); //btCollisionObject* obA = static_cast<btCollisionObject*>(contactManifold->getBody0());
btCollisionObject* obB = static_cast<btCollisionObject*>(contactManifold->getBody1()); //btCollisionObject* obB = static_cast<btCollisionObject*>(contactManifold->getBody1());
int numContacts = contactManifold->getNumContacts(); int numContacts = contactManifold->getNumContacts();
for (int j=0;j<numContacts;j++) for (int j=0;j<numContacts;j++)

7
src/BulletDynamics/Dynamics/btDynamicsWorld.h
View File

@@ -25,7 +25,7 @@ class btConstraintSolver;
class btDynamicsWorld; class btDynamicsWorld;
/// Type for the callback for each tick /// Type for the callback for each tick
typedef void (*btInternalTickCallback)(const btDynamicsWorld *world, btScalar timeStep); typedef void (*btInternalTickCallback)(btDynamicsWorld *world, btScalar timeStep);
enum btDynamicsWorldType enum btDynamicsWorldType
{ {
@@ -103,6 +103,11 @@ public:
m_worldUserInfo = worldUserInfo; m_worldUserInfo = worldUserInfo;
} }
void setWorldUserInfo(void* worldUserInfo)
{
m_worldUserInfo = worldUserInfo;
}
void* getWorldUserInfo() const void* getWorldUserInfo() const
{ {
return m_worldUserInfo; return m_worldUserInfo;

2
src/BulletDynamics/Vehicle/btRaycastVehicle.cpp
View File

@@ -712,7 +712,7 @@ void* btDefaultVehicleRaycaster::castRay(const btVector3& from,const btVector3&
m_dynamicsWorld->rayTest(from, to, rayCallback); m_dynamicsWorld->rayTest(from, to, rayCallback);
if (rayCallback.HasHit()) if (rayCallback.hasHit())
{ {
btRigidBody* body = btRigidBody::upcast(rayCallback.m_collisionObject); btRigidBody* body = btRigidBody::upcast(rayCallback.m_collisionObject);