1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans  https://bulletphysics.org
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
16 #ifndef BT_COLLISION__DISPATCHER_H
17 #define BT_COLLISION__DISPATCHER_H
18 
19 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
20 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
21 
22 #include "BulletCollision/CollisionDispatch/btManifoldResult.h"
23 
24 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
25 #include "LinearMath/btAlignedObjectArray.h"
26 
27 class btIDebugDraw;
28 class btOverlappingPairCache;
29 class btPoolAllocator;
30 class btCollisionConfiguration;
31 
32 #include "btCollisionCreateFunc.h"
33 
34 #define USE_DISPATCH_REGISTRY_ARRAY 1
35 
36 class btCollisionDispatcher;
37 ///user can override this nearcallback for collision filtering and more finegrained control over collision detection
38 typedef void (*btNearCallback)(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo);
39 
40 ///btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
41 ///Time of Impact, Closest Points and Penetration Depth.
42 class btCollisionDispatcher : public btDispatcher
43 {
44 protected:
45 	int m_dispatcherFlags;
46 
47 	btAlignedObjectArray<btPersistentManifold*> m_manifoldsPtr;
48 
49 	btNearCallback m_nearCallback;
50 
51 	btPoolAllocator* m_collisionAlgorithmPoolAllocator;
52 
53 	btPoolAllocator* m_persistentManifoldPoolAllocator;
54 
55 	btCollisionAlgorithmCreateFunc* m_doubleDispatchContactPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
56 
57 	btCollisionAlgorithmCreateFunc* m_doubleDispatchClosestPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
58 
59 	btCollisionConfiguration* m_collisionConfiguration;
60 
61 public:
62 	enum DispatcherFlags
63 	{
64 		CD_STATIC_STATIC_REPORTED = 1,
65 		CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2,
66 		CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION = 4
67 	};
68 
getDispatcherFlags()69 	int getDispatcherFlags() const
70 	{
71 		return m_dispatcherFlags;
72 	}
73 
setDispatcherFlags(int flags)74 	void setDispatcherFlags(int flags)
75 	{
76 		m_dispatcherFlags = flags;
77 	}
78 
79 	///registerCollisionCreateFunc allows registration of custom/alternative collision create functions
80 	void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc);
81 
82 	void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc);
83 
getNumManifolds()84 	int getNumManifolds() const
85 	{
86 		return int(m_manifoldsPtr.size());
87 	}
88 
getInternalManifoldPointer()89 	btPersistentManifold** getInternalManifoldPointer()
90 	{
91 		return m_manifoldsPtr.size() ? &m_manifoldsPtr[0] : 0;
92 	}
93 
getManifoldByIndexInternal(int index)94 	btPersistentManifold* getManifoldByIndexInternal(int index)
95 	{
96 		btAssert(index>=0);
97 		btAssert(index<m_manifoldsPtr.size());
98 		return m_manifoldsPtr[index];
99 	}
100 
getManifoldByIndexInternal(int index)101 	const btPersistentManifold* getManifoldByIndexInternal(int index) const
102 	{
103 		btAssert(index>=0);
104 		btAssert(index<m_manifoldsPtr.size());
105 		return m_manifoldsPtr[index];
106 	}
107 
108 	btCollisionDispatcher(btCollisionConfiguration* collisionConfiguration);
109 
110 	virtual ~btCollisionDispatcher();
111 
112 	virtual btPersistentManifold* getNewManifold(const btCollisionObject* b0, const btCollisionObject* b1);
113 
114 	virtual void releaseManifold(btPersistentManifold* manifold);
115 
116 	virtual void clearManifold(btPersistentManifold* manifold);
117 
118 	btCollisionAlgorithm* findAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btPersistentManifold* sharedManifold, ebtDispatcherQueryType queryType);
119 
120 	virtual bool needsCollision(const btCollisionObject* body0, const btCollisionObject* body1);
121 
122 	virtual bool needsResponse(const btCollisionObject* body0, const btCollisionObject* body1);
123 
124 	virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& dispatchInfo, btDispatcher* dispatcher);
125 
setNearCallback(btNearCallback nearCallback)126 	void setNearCallback(btNearCallback nearCallback)
127 	{
128 		m_nearCallback = nearCallback;
129 	}
130 
getNearCallback()131 	btNearCallback getNearCallback() const
132 	{
133 		return m_nearCallback;
134 	}
135 
136 	//by default, Bullet will use this near callback
137 	static void defaultNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo);
138 
139 	virtual void* allocateCollisionAlgorithm(int size);
140 
141 	virtual void freeCollisionAlgorithm(void* ptr);
142 
getCollisionConfiguration()143 	btCollisionConfiguration* getCollisionConfiguration()
144 	{
145 		return m_collisionConfiguration;
146 	}
147 
getCollisionConfiguration()148 	const btCollisionConfiguration* getCollisionConfiguration() const
149 	{
150 		return m_collisionConfiguration;
151 	}
152 
setCollisionConfiguration(btCollisionConfiguration * config)153 	void setCollisionConfiguration(btCollisionConfiguration* config)
154 	{
155 		m_collisionConfiguration = config;
156 	}
157 
getInternalManifoldPool()158 	virtual btPoolAllocator* getInternalManifoldPool()
159 	{
160 		return m_persistentManifoldPoolAllocator;
161 	}
162 
getInternalManifoldPool()163 	virtual const btPoolAllocator* getInternalManifoldPool() const
164 	{
165 		return m_persistentManifoldPoolAllocator;
166 	}
167 };
168 
169 #endif  //BT_COLLISION__DISPATCHER_H
170