Bullet Collision Detection & Physics Library: btCollisionDispatcherMt.cpp Source File

Bullet Collision Detection & Physics Library

btCollisionDispatcherMt.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
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 #include "btCollisionDispatcherMt.h"
17 #include "LinearMath/btQuickprof.h"
18
19 #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
20
21 #include "BulletCollision/CollisionShapes/btCollisionShape.h"
22 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
23 #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
24 #include "LinearMath/btPoolAllocator.h"
25 #include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h"
26 #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
27
28 btCollisionDispatcherMt::btCollisionDispatcherMt(btCollisionConfiguration* config, int grainSize)
29 : btCollisionDispatcher(config)
30 {
31 m_batchUpdating = false;
32 m_grainSize = grainSize; // iterations per task
33 }
34
35 btPersistentManifold* btCollisionDispatcherMt::getNewManifold(const btCollisionObject* body0, const btCollisionObject* body1)
36 {
37 //optional relative contact breaking threshold, turned on by default (use setDispatcherFlags to switch off feature for improved performance)
38
39 btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold), body1->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold))
40 : gContactBreakingThreshold;
41
42 btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(), body1->getContactProcessingThreshold());
43
44 void* mem = m_persistentManifoldPoolAllocator->allocate(sizeof(btPersistentManifold));
45 if (NULL == mem)
46 {
47 //we got a pool memory overflow, by default we fallback to dynamically allocate memory. If we require a contiguous contact pool then assert.
48 if ((m_dispatcherFlags & CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION) == 0)
49 {
50 mem = btAlignedAlloc(sizeof(btPersistentManifold), 16);
51 }
52 else
53 {
54 btAssert(0);
55 //make sure to increase the m_defaultMaxPersistentManifoldPoolSize in the btDefaultCollisionConstructionInfo/btDefaultCollisionConfiguration
56 return 0;
57 }
58 }
59 btPersistentManifold* manifold = new (mem) btPersistentManifold(body0, body1, 0, contactBreakingThreshold, contactProcessingThreshold);
60 if (!m_batchUpdating)
61 {
62 // batch updater will update manifold pointers array after finishing, so
63 // only need to update array when not batch-updating
64 //btAssert( !btThreadsAreRunning() );
65 manifold->m_index1a = m_manifoldsPtr.size();
66 m_manifoldsPtr.push_back(manifold);
67 }
68
69 return manifold;
70 }
71
72 void btCollisionDispatcherMt::releaseManifold(btPersistentManifold* manifold)
73 {
74 clearManifold(manifold);
75 //btAssert( !btThreadsAreRunning() );
76 if (!m_batchUpdating)
77 {
78 // batch updater will update manifold pointers array after finishing, so
79 // only need to update array when not batch-updating
80 int findIndex = manifold->m_index1a;
81 btAssert(findIndex < m_manifoldsPtr.size());
82 m_manifoldsPtr.swap(findIndex, m_manifoldsPtr.size() - 1);
83 m_manifoldsPtr[findIndex]->m_index1a = findIndex;
84 m_manifoldsPtr.pop_back();
85 }
86
87 manifold->~btPersistentManifold();
88 if (m_persistentManifoldPoolAllocator->validPtr(manifold))
89 {
90 m_persistentManifoldPoolAllocator->freeMemory(manifold);
91 }
92 else
93 {
94 btAlignedFree(manifold);
95 }
96 }
97
98 struct CollisionDispatcherUpdater : public btIParallelForBody
99 {
100 btBroadphasePair* mPairArray;
101 btNearCallback mCallback;
102 btCollisionDispatcher* mDispatcher;
103 const btDispatcherInfo* mInfo;
104
105 CollisionDispatcherUpdater()
106 {
107 mPairArray = NULL;
108 mCallback = NULL;
109 mDispatcher = NULL;
110 mInfo = NULL;
111 }
112 void forLoop(int iBegin, int iEnd) const
113 {
114 for (int i = iBegin; i < iEnd; ++i)
115 {
116 btBroadphasePair* pair = &mPairArray[i];
117 mCallback(*pair, *mDispatcher, *mInfo);
118 }
119 }
120 };
121
122 void btCollisionDispatcherMt::dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& info, btDispatcher* dispatcher)
123 {
124 int pairCount = pairCache->getNumOverlappingPairs();
125 if (pairCount == 0)
126 {
127 return;
128 }
129 CollisionDispatcherUpdater updater;
130 updater.mCallback = getNearCallback();
131 updater.mPairArray = pairCache->getOverlappingPairArrayPtr();
132 updater.mDispatcher = this;
133 updater.mInfo = &info;
134
135 m_batchUpdating = true;
136 btParallelFor(0, pairCount, m_grainSize, updater);
137 m_batchUpdating = false;
138
139 // reconstruct the manifolds array to ensure determinism
140 m_manifoldsPtr.resizeNoInitialize(0);
141
142 btBroadphasePair* pairs = pairCache->getOverlappingPairArrayPtr();
143 for (int i = 0; i < pairCount; ++i)
144 {
145 if (btCollisionAlgorithm* algo = pairs[i].m_algorithm)
146 {
147 algo->getAllContactManifolds(m_manifoldsPtr);
148 }
149 }
150
151 // update the indices (used when releasing manifolds)
152 for (int i = 0; i < m_manifoldsPtr.size(); ++i)
153 {
154 m_manifoldsPtr[i]->m_index1a = i;
155 }
156 }
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:63
CollisionDispatcherUpdater::mPairArray
btBroadphasePair * mPairArray
Definition: btCollisionDispatcherMt.cpp:100
btNearCallback
void(* btNearCallback)(btBroadphasePair &collisionPair, btCollisionDispatcher &dispatcher, const btDispatcherInfo &dispatchInfo)
user can override this nearcallback for collision filtering and more finegrained control over collisi...
Definition: btCollisionDispatcher.h:38
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:264
btCollisionDispatcher::CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION
Definition: btCollisionDispatcher.h:68
btCollisionDispatcherMt::btCollisionDispatcherMt
btCollisionDispatcherMt(btCollisionConfiguration *config, int grainSize=40)
Definition: btCollisionDispatcherMt.cpp:28
btCollisionDispatcher::m_dispatcherFlags
int m_dispatcherFlags
Definition: btCollisionDispatcher.h:45
CollisionDispatcherUpdater::mDispatcher
btCollisionDispatcher * mDispatcher
Definition: btCollisionDispatcherMt.cpp:102
btAlignedObjectArray::resizeNoInitialize
void resizeNoInitialize(int newsize)
resize changes the number of elements in the array.
Definition: btAlignedObjectArray.h:201
btAssert
#define btAssert(x)
Definition: btScalar.h:133
CollisionDispatcherUpdater::mCallback
btNearCallback mCallback
Definition: btCollisionDispatcherMt.cpp:101
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
Definition: btCollisionConfiguration.h:26
btCollisionDispatcherMt::getNewManifold
virtual btPersistentManifold * getNewManifold(const btCollisionObject *body0, const btCollisionObject *body1) BT_OVERRIDE
Definition: btCollisionDispatcherMt.cpp:35
btCollisionDispatcher
btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs...
Definition: btCollisionDispatcher.h:42
CollisionDispatcherUpdater::forLoop
void forLoop(int iBegin, int iEnd) const
Definition: btCollisionDispatcherMt.cpp:112
btPoolAllocator::validPtr
bool validPtr(void *ptr)
Definition: btPoolAllocator.h:88
btCollisionDispatcher::getNearCallback
btNearCallback getNearCallback() const
Definition: btCollisionDispatcher.h:129
btAlignedObjectArray::swap
void swap(int index0, int index1)
Definition: btAlignedObjectArray.h:389
btCollisionDispatcherMt::m_grainSize
int m_grainSize
Definition: btCollisionDispatcherMt.h:34
btOverlappingPairCache.h
btOverlappingPairCache
The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases.
Definition: btOverlappingPairCache.h:50
CollisionDispatcherUpdater::CollisionDispatcherUpdater
CollisionDispatcherUpdater()
Definition: btCollisionDispatcherMt.cpp:105
btCollisionDispatcher::m_manifoldsPtr
btAlignedObjectArray< btPersistentManifold * > m_manifoldsPtr
Definition: btCollisionDispatcher.h:47
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:47
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:48
btCollisionConfiguration.h
btCollisionDispatcher::clearManifold
virtual void clearManifold(btPersistentManifold *manifold)
Definition: btCollisionDispatcher.cpp:101
btCollisionShape::getContactBreakingThreshold
virtual btScalar getContactBreakingThreshold(btScalar defaultContactThresholdFactor) const
Definition: btCollisionShape.cpp:42
btPersistentManifold::m_index1a
int m_index1a
Definition: btPersistentManifold.h:88
CollisionDispatcherUpdater::mInfo
const btDispatcherInfo * mInfo
Definition: btCollisionDispatcherMt.cpp:103
btCollisionObjectWrapper.h
btAlignedObjectArray::pop_back
void pop_back()
Definition: btAlignedObjectArray.h:192
btCollisionDispatcherMt::releaseManifold
virtual void releaseManifold(btPersistentManifold *manifold) BT_OVERRIDE
Definition: btCollisionDispatcherMt.cpp:72
btOverlappingPairCache::getNumOverlappingPairs
virtual int getNumOverlappingPairs() const =0
btCollisionObject::getContactProcessingThreshold
btScalar getContactProcessingThreshold() const
Definition: btCollisionObject.h:188
btCollisionShape.h
btPoolAllocator.h
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
btQuickprof.h
btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD
Definition: btCollisionDispatcher.h:67
btPoolAllocator::allocate
void * allocate(int size)
Definition: btPoolAllocator.h:71
btCollisionObject.h
btCollisionDispatcherMt.h
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:46
btCollisionDispatcherMt::dispatchAllCollisionPairs
virtual void dispatchAllCollisionPairs(btOverlappingPairCache *pairCache, const btDispatcherInfo &info, btDispatcher *dispatcher) BT_OVERRIDE
Definition: btCollisionDispatcherMt.cpp:122
btParallelFor
void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody &body)
Definition: btThreads.cpp:412
btIParallelForBody
Definition: btThreads.h:101
btDispatcherInfo
Definition: btDispatcher.h:30
btPoolAllocator::freeMemory
void freeMemory(void *ptr)
Definition: btPoolAllocator.h:100
btOverlappingPairCache::getOverlappingPairArrayPtr
virtual btBroadphasePair * getOverlappingPairArrayPtr()=0
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:76
btMin
const T & btMin(const T &a, const T &b)
Definition: btMinMax.h:21
btCollisionAlgorithm
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
Definition: btCollisionAlgorithm.h:53
btCollisionDispatcher::m_persistentManifoldPoolAllocator
btPoolAllocator * m_persistentManifoldPoolAllocator
Definition: btCollisionDispatcher.h:55
gContactBreakingThreshold
btScalar gContactBreakingThreshold
Definition: btPersistentManifold.cpp:26
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:294
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:224
CollisionDispatcherUpdater
Definition: btCollisionDispatcherMt.cpp:98
btCollisionAlgorithm.h
btCollisionDispatcherMt::m_batchUpdating
bool m_batchUpdating
Definition: btCollisionDispatcherMt.h:33
btBroadphasePair
The btBroadphasePair class contains a pair of aabb-overlapping objects.
Definition: btBroadphaseProxy.h:177