diff --git a/Bullet/BroadphaseCollision/BroadphaseProxy.h b/Bullet/BroadphaseCollision/BroadphaseProxy.h index 35b2dc866..0e64d0632 100644 --- a/Bullet/BroadphaseCollision/BroadphaseProxy.h +++ b/Bullet/BroadphaseCollision/BroadphaseProxy.h @@ -70,6 +70,26 @@ struct BroadphaseProxy m_collisionFilterMask(collisionFilterMask) { } + + static inline bool IsPolyhedral(int proxyType) + { + return (proxyType < IMPLICIT_CONVEX_SHAPES_START_HERE); + } + + static inline bool IsConvex(int proxyType) + { + return (proxyType < CONCAVE_SHAPES_START_HERE); + } + + static inline bool IsConcave(int proxyType) + { + return ((proxyType > CONCAVE_SHAPES_START_HERE) && + (proxyType < CONCAVE_SHAPES_END_HERE)); + } + static inline bool IsCompound(int proxyType) + { + return (proxyType == COMPOUND_SHAPE_PROXYTYPE); + } }; @@ -77,7 +97,8 @@ class CollisionAlgorithm; struct BroadphaseProxy; -#define SIMPLE_MAX_ALGORITHMS 2 +//Increase SIMPLE_MAX_ALGORITHMS to allow multiple Dispatchers caching their own algorithms +#define SIMPLE_MAX_ALGORITHMS 1 /// contains a pair of aabb-overlapping objects struct BroadphasePair diff --git a/Bullet/CollisionDispatch/CollisionCreateFunc.h b/Bullet/CollisionDispatch/CollisionCreateFunc.h index 7c7510fc8..6f12b7af5 100644 --- a/Bullet/CollisionDispatch/CollisionCreateFunc.h +++ b/Bullet/CollisionDispatch/CollisionCreateFunc.h @@ -21,7 +21,7 @@ subject to the following restrictions: typedef std::vector CollisionObjectArray; class CollisionAlgorithm; struct BroadphaseProxy; - +struct CollisionAlgorithmConstructionInfo; struct CollisionAlgorithmCreateFunc @@ -34,7 +34,7 @@ struct CollisionAlgorithmCreateFunc } virtual ~CollisionAlgorithmCreateFunc(){}; - virtual CollisionAlgorithm* CreateCollisionAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1) + virtual CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) { return 0; } diff --git a/Bullet/CollisionDispatch/CollisionDispatcher.cpp b/Bullet/CollisionDispatch/CollisionDispatcher.cpp index 06e999fbe..8ea1522cc 100644 --- a/Bullet/CollisionDispatch/CollisionDispatcher.cpp +++ b/Bullet/CollisionDispatch/CollisionDispatcher.cpp @@ -40,17 +40,37 @@ CollisionDispatcher::CollisionDispatcher (): { int i; + //default CreationFunctions, filling the m_doubleDispatch table + m_convexConvexCreateFunc = new ConvexConvexAlgorithm::CreateFunc; + m_convexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm::CreateFunc; + m_swappedConvexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm::SwappedCreateFunc; + m_compoundCreateFunc = new CompoundCollisionAlgorithm::CreateFunc; + m_swappedCompoundCreateFunc = new CompoundCollisionAlgorithm::SwappedCreateFunc; + m_emptyCreateFunc = new EmptyAlgorithm::CreateFunc; + for (i=0;im_collisionShape->GetShapeType()][body1->m_collisionShape->GetShapeType()] + ->CreateCollisionAlgorithm(ci,&proxy0,&proxy1); +#else + CollisionAlgorithm* algo = InternalFindAlgorithm(proxy0,proxy1); +#endif //USE_DISPATCH_REGISTRY_ARRAY + return algo; +} + + +CollisionAlgorithmCreateFunc* CollisionDispatcher::InternalFindCreateFunc(int proxyType0,int proxyType1) +{ + + if (BroadphaseProxy::IsConvex(proxyType0) && BroadphaseProxy::IsConvex(proxyType1)) + { + return m_convexConvexCreateFunc; + } + + if (BroadphaseProxy::IsConvex(proxyType0) && BroadphaseProxy::IsConcave(proxyType1)) + { + return m_convexConcaveCreateFunc; + } + + if (BroadphaseProxy::IsConvex(proxyType1) && BroadphaseProxy::IsConcave(proxyType0)) + { + return m_swappedConvexConcaveCreateFunc; + } + + if (BroadphaseProxy::IsCompound(proxyType0)) + { + return m_compoundCreateFunc; + } else + { + if (BroadphaseProxy::IsCompound(proxyType1)) + { + return m_swappedCompoundCreateFunc; + } + } + + //failed to find an algorithm + return m_emptyCreateFunc; +} + CollisionAlgorithm* CollisionDispatcher::InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1) diff --git a/Bullet/CollisionDispatch/CollisionDispatcher.h b/Bullet/CollisionDispatch/CollisionDispatcher.h index 773978b92..85679b95f 100644 --- a/Bullet/CollisionDispatch/CollisionDispatcher.h +++ b/Bullet/CollisionDispatch/CollisionDispatcher.h @@ -40,20 +40,26 @@ class CollisionDispatcher : public Dispatcher std::vector m_manifoldsPtr; - - bool m_useIslands; ManifoldResult m_defaultManifoldResult; CollisionAlgorithmCreateFunc* m_doubleDispatch[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES]; + CollisionAlgorithmCreateFunc* InternalFindCreateFunc(int proxyType0,int proxyType1); + + //default CreationFunctions, filling the m_doubleDispatch table + CollisionAlgorithmCreateFunc* m_convexConvexCreateFunc; + CollisionAlgorithmCreateFunc* m_convexConcaveCreateFunc; + CollisionAlgorithmCreateFunc* m_swappedConvexConcaveCreateFunc; + CollisionAlgorithmCreateFunc* m_compoundCreateFunc; + CollisionAlgorithmCreateFunc* m_swappedCompoundCreateFunc; + CollisionAlgorithmCreateFunc* m_emptyCreateFunc; + public: - - - - + ///RegisterCollisionCreateFunc allows registration of custom/alternative collision create functions + void RegisterCollisionCreateFunc(int proxyType0,int proxyType1, CollisionAlgorithmCreateFunc* createFunc); int GetNumManifolds() const { @@ -73,7 +79,7 @@ public: int m_count; CollisionDispatcher (); - virtual ~CollisionDispatcher() {}; + virtual ~CollisionDispatcher(); virtual PersistentManifold* GetNewManifold(void* b0,void* b1); @@ -89,11 +95,7 @@ public: virtual void ClearManifold(PersistentManifold* manifold); - CollisionAlgorithm* FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1) - { - CollisionAlgorithm* algo = InternalFindAlgorithm(proxy0,proxy1); - return algo; - } + CollisionAlgorithm* FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1); CollisionAlgorithm* InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1); diff --git a/Bullet/CollisionDispatch/CompoundCollisionAlgorithm.h b/Bullet/CollisionDispatch/CompoundCollisionAlgorithm.h index a41d3a8f4..3c080ca5f 100644 --- a/Bullet/CollisionDispatch/CompoundCollisionAlgorithm.h +++ b/Bullet/CollisionDispatch/CompoundCollisionAlgorithm.h @@ -24,7 +24,7 @@ subject to the following restrictions: class Dispatcher; #include "BroadphaseCollision/BroadphaseProxy.h" #include - +#include "CollisionCreateFunc.h" /// CompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision shapes /// Place holder, not fully implemented yet @@ -51,6 +51,22 @@ public: float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo); + struct CreateFunc :public CollisionAlgorithmCreateFunc + { + virtual CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) + { + return new CompoundCollisionAlgorithm(ci,proxy0,proxy1); + } + }; + + struct SwappedCreateFunc :public CollisionAlgorithmCreateFunc + { + virtual CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) + { + return new CompoundCollisionAlgorithm(ci,proxy1,proxy0); + } + }; + }; #endif //COMPOUND_COLLISION_ALGORITHM_H diff --git a/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h b/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h index 47b4de3bb..53bf37449 100644 --- a/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h +++ b/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h @@ -23,7 +23,7 @@ subject to the following restrictions: #include "NarrowPhaseCollision/PersistentManifold.h" class Dispatcher; #include "BroadphaseCollision/BroadphaseProxy.h" - +#include "CollisionCreateFunc.h" ///For each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), ProcessTriangle is called. class ConvexTriangleCallback : public TriangleCallback @@ -90,6 +90,22 @@ public: void ClearCache(); + struct CreateFunc :public CollisionAlgorithmCreateFunc + { + virtual CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) + { + return new ConvexConcaveCollisionAlgorithm(ci,proxy0,proxy1); + } + }; + + struct SwappedCreateFunc :public CollisionAlgorithmCreateFunc + { + virtual CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) + { + return new ConvexConcaveCollisionAlgorithm(ci,proxy1,proxy0); + } + }; + }; #endif //CONVEX_CONCAVE_COLLISION_ALGORITHM_H diff --git a/Bullet/CollisionDispatch/ConvexConvexAlgorithm.h b/Bullet/CollisionDispatch/ConvexConvexAlgorithm.h index a1cadabe7..939d9ea42 100644 --- a/Bullet/CollisionDispatch/ConvexConvexAlgorithm.h +++ b/Bullet/CollisionDispatch/ConvexConvexAlgorithm.h @@ -21,6 +21,7 @@ subject to the following restrictions: #include "NarrowPhaseCollision/PersistentManifold.h" #include "BroadphaseCollision/BroadphaseProxy.h" #include "NarrowPhaseCollision/VoronoiSimplexSolver.h" +#include "CollisionCreateFunc.h" class ConvexPenetrationDepthSolver; @@ -68,6 +69,15 @@ public: return m_manifoldPtr; } + struct CreateFunc :public CollisionAlgorithmCreateFunc + { + virtual CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) + { + return new ConvexConvexAlgorithm(0,ci,proxy0,proxy1); + } + }; + + }; #endif //CONVEX_CONVEX_ALGORITHM_H diff --git a/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.h b/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.h index c85efac99..d337bcd58 100644 --- a/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.h +++ b/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.h @@ -16,6 +16,7 @@ subject to the following restrictions: #ifndef EMPTY_ALGORITH #define EMPTY_ALGORITH #include "BroadphaseCollision/CollisionAlgorithm.h" +#include "CollisionCreateFunc.h" #define ATTRIBUTE_ALIGNED(a) @@ -32,8 +33,13 @@ public: virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo); - - + struct CreateFunc :public CollisionAlgorithmCreateFunc + { + virtual CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) + { + return new EmptyAlgorithm(ci); + } + }; } ATTRIBUTE_ALIGNED(16); diff --git a/Bullet/CollisionShapes/CollisionShape.h b/Bullet/CollisionShapes/CollisionShape.h index 57bf97874..14132acf5 100644 --- a/Bullet/CollisionShapes/CollisionShape.h +++ b/Bullet/CollisionShapes/CollisionShape.h @@ -48,23 +48,22 @@ public: ///result is conservative void CalculateTemporalAabb(const SimdTransform& curTrans,const SimdVector3& linvel,const SimdVector3& angvel,SimdScalar timeStep, SimdVector3& temporalAabbMin,SimdVector3& temporalAabbMax); - bool IsPolyhedral() const + inline bool IsPolyhedral() const { - return (GetShapeType() < IMPLICIT_CONVEX_SHAPES_START_HERE); + return BroadphaseProxy::IsPolyhedral(GetShapeType()); } - bool IsConvex() const + inline bool IsConvex() const { - return (GetShapeType() < CONCAVE_SHAPES_START_HERE); + return BroadphaseProxy::IsConvex(GetShapeType()); } - bool IsConcave() const + inline bool IsConcave() const { - return ((GetShapeType() > CONCAVE_SHAPES_START_HERE) && - (GetShapeType() < CONCAVE_SHAPES_END_HERE)); + return BroadphaseProxy::IsConcave(GetShapeType()); } - bool IsCompound() const + inline bool IsCompound() const { - return (GetShapeType() == COMPOUND_SHAPE_PROXYTYPE); + return BroadphaseProxy::IsCompound(GetShapeType()); } virtual void setLocalScaling(const SimdVector3& scaling) =0;