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

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btConvexConcaveCollisionAlgorithm.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
17 #include "btConvexConcaveCollisionAlgorithm.h"
18 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
19 #include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
20 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
21 #include "BulletCollision/CollisionShapes/btConcaveShape.h"
22 #include "BulletCollision/CollisionDispatch/btManifoldResult.h"
23 #include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
24 #include "BulletCollision/CollisionShapes/btTriangleShape.h"
25 #include "BulletCollision/CollisionShapes/btSphereShape.h"
26 #include "LinearMath/btIDebugDraw.h"
27 #include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
28 #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
29
30 btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,bool isSwapped)
31 : btActivatingCollisionAlgorithm(ci,body0Wrap,body1Wrap),
32 m_isSwapped(isSwapped),
33 m_btConvexTriangleCallback(ci.m_dispatcher1,body0Wrap,body1Wrap,isSwapped)
34 {
35 }
36
37 btConvexConcaveCollisionAlgorithm::~btConvexConcaveCollisionAlgorithm()
38 {
39 }
40
41 void btConvexConcaveCollisionAlgorithm::getAllContactManifolds(btManifoldArray& manifoldArray)
42 {
43 if (m_btConvexTriangleCallback.m_manifoldPtr)
44 {
45 manifoldArray.push_back(m_btConvexTriangleCallback.m_manifoldPtr);
46 }
47 }
48
49
50 btConvexTriangleCallback::btConvexTriangleCallback(btDispatcher* dispatcher,const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,bool isSwapped):
51 m_dispatcher(dispatcher),
52 m_dispatchInfoPtr(0)
53 {
54 m_convexBodyWrap = isSwapped? body1Wrap:body0Wrap;
55 m_triBodyWrap = isSwapped? body0Wrap:body1Wrap;
56
57 //
58 // create the manifold from the dispatcher 'manifold pool'
59 //
60 m_manifoldPtr = m_dispatcher->getNewManifold(m_convexBodyWrap->getCollisionObject(),m_triBodyWrap->getCollisionObject());
61
62 clearCache();
63 }
64
65 btConvexTriangleCallback::~btConvexTriangleCallback()
66 {
67 clearCache();
68 m_dispatcher->releaseManifold( m_manifoldPtr );
69
70 }
71
72
73 void btConvexTriangleCallback::clearCache()
74 {
75 m_dispatcher->clearManifold(m_manifoldPtr);
76 }
77
78
79 void btConvexTriangleCallback::processTriangle(btVector3* triangle,int
80 partId, int triangleIndex)
81 {
82
83 if (!TestTriangleAgainstAabb2(triangle, m_aabbMin, m_aabbMax))
84 {
85 return;
86 }
87
88 //just for debugging purposes
89 //printf("triangle %d",m_triangleCount++);
90
91
92
93 btCollisionAlgorithmConstructionInfo ci;
94 ci.m_dispatcher1 = m_dispatcher;
95
96
97
98 #if 0
99
101 if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && (m_dispatchInfoPtr->m_debugDraw->getDebugMode() &btIDebugDraw::DBG_DrawWireframe ))
102 {
103 const btCollisionObject* ob = const_cast<btCollisionObject*>(m_triBodyWrap->getCollisionObject());
104 btVector3 color(1,1,0);
105 btTransform& tr = ob->getWorldTransform();
106 m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(triangle[1]),color);
107 m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(triangle[2]),color);
108 m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color);
109 }
110 #endif
111
112 if (m_convexBodyWrap->getCollisionShape()->isConvex())
113 {
114 btTriangleShape tm(triangle[0],triangle[1],triangle[2]);
115 tm.setMargin(m_collisionMarginTriangle);
116
117
118 btCollisionObjectWrapper triObWrap(m_triBodyWrap,&tm,m_triBodyWrap->getCollisionObject(),m_triBodyWrap->getWorldTransform(),partId,triangleIndex);//correct transform?
119 btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(m_convexBodyWrap,&triObWrap,m_manifoldPtr);
120
121 const btCollisionObjectWrapper* tmpWrap = 0;
122
123 if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject())
124 {
125 tmpWrap = m_resultOut->getBody0Wrap();
126 m_resultOut->setBody0Wrap(&triObWrap);
127 m_resultOut->setShapeIdentifiersA(partId,triangleIndex);
128 }
129 else
130 {
131 tmpWrap = m_resultOut->getBody1Wrap();
132 m_resultOut->setBody1Wrap(&triObWrap);
133 m_resultOut->setShapeIdentifiersB(partId,triangleIndex);
134 }
135
136 colAlgo->processCollision(m_convexBodyWrap,&triObWrap,*m_dispatchInfoPtr,m_resultOut);
137
138 if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject())
139 {
140 m_resultOut->setBody0Wrap(tmpWrap);
141 } else
142 {
143 m_resultOut->setBody1Wrap(tmpWrap);
144 }
145
146
147
148 colAlgo->~btCollisionAlgorithm();
149 ci.m_dispatcher1->freeCollisionAlgorithm(colAlgo);
150 }
151
152 }
153
154
155
156 void btConvexTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,const btCollisionObjectWrapper* convexBodyWrap, const btCollisionObjectWrapper* triBodyWrap, btManifoldResult* resultOut)
157 {
158 m_convexBodyWrap = convexBodyWrap;
159 m_triBodyWrap = triBodyWrap;
160
161 m_dispatchInfoPtr = &dispatchInfo;
162 m_collisionMarginTriangle = collisionMarginTriangle;
163 m_resultOut = resultOut;
164
165 //recalc aabbs
166 btTransform convexInTriangleSpace;
167 convexInTriangleSpace = m_triBodyWrap->getWorldTransform().inverse() * m_convexBodyWrap->getWorldTransform();
168 const btCollisionShape* convexShape = static_cast<const btCollisionShape*>(m_convexBodyWrap->getCollisionShape());
169 //CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
170 convexShape->getAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
171 btScalar extraMargin = collisionMarginTriangle;
172 btVector3 extra(extraMargin,extraMargin,extraMargin);
173
174 m_aabbMax += extra;
175 m_aabbMin -= extra;
176
177 }
178
179 void btConvexConcaveCollisionAlgorithm::clearCache()
180 {
181 m_btConvexTriangleCallback.clearCache();
182
183 }
184
185 void btConvexConcaveCollisionAlgorithm::processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
186 {
187
188
189 const btCollisionObjectWrapper* convexBodyWrap = m_isSwapped ? body1Wrap : body0Wrap;
190 const btCollisionObjectWrapper* triBodyWrap = m_isSwapped ? body0Wrap : body1Wrap;
191
192 if (triBodyWrap->getCollisionShape()->isConcave())
193 {
194
195
196
197 const btConcaveShape* concaveShape = static_cast<const btConcaveShape*>( triBodyWrap->getCollisionShape());
198
199 if (convexBodyWrap->getCollisionShape()->isConvex())
200 {
201 btScalar collisionMarginTriangle = concaveShape->getMargin();
202
203 resultOut->setPersistentManifold(m_btConvexTriangleCallback.m_manifoldPtr);
204 m_btConvexTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle,dispatchInfo,convexBodyWrap,triBodyWrap,resultOut);
205
206 m_btConvexTriangleCallback.m_manifoldPtr->setBodies(convexBodyWrap->getCollisionObject(),triBodyWrap->getCollisionObject());
207
208 concaveShape->processAllTriangles( &m_btConvexTriangleCallback,m_btConvexTriangleCallback.getAabbMin(),m_btConvexTriangleCallback.getAabbMax());
209
210 resultOut->refreshContactPoints();
211
212 m_btConvexTriangleCallback.clearWrapperData();
213
214 }
215
216 }
217
218 }
219
220
221 btScalar btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
222 {
223 (void)resultOut;
224 (void)dispatchInfo;
225 btCollisionObject* convexbody = m_isSwapped ? body1 : body0;
226 btCollisionObject* triBody = m_isSwapped ? body0 : body1;
227
228
229 //quick approximation using raycast, todo: hook up to the continuous collision detection (one of the btConvexCast)
230
231 //only perform CCD above a certain threshold, this prevents blocking on the long run
232 //because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
233 btScalar squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
234 if (squareMot0 < convexbody->getCcdSquareMotionThreshold())
235 {
236 return btScalar(1.);
237 }
238
239 //const btVector3& from = convexbody->m_worldTransform.getOrigin();
240 //btVector3 to = convexbody->m_interpolationWorldTransform.getOrigin();
241 //todo: only do if the motion exceeds the 'radius'
242
243 btTransform triInv = triBody->getWorldTransform().inverse();
244 btTransform convexFromLocal = triInv * convexbody->getWorldTransform();
245 btTransform convexToLocal = triInv * convexbody->getInterpolationWorldTransform();
246
247 struct LocalTriangleSphereCastCallback : public btTriangleCallback
248 {
249 btTransform m_ccdSphereFromTrans;
250 btTransform m_ccdSphereToTrans;
251 btTransform m_meshTransform;
252
253 btScalar m_ccdSphereRadius;
254 btScalar m_hitFraction;
255
256
257 LocalTriangleSphereCastCallback(const btTransform& from,const btTransform& to,btScalar ccdSphereRadius,btScalar hitFraction)
258 :m_ccdSphereFromTrans(from),
259 m_ccdSphereToTrans(to),
260 m_ccdSphereRadius(ccdSphereRadius),
261 m_hitFraction(hitFraction)
262 {
263 }
264
265
266 virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex)
267 {
268 (void)partId;
269 (void)triangleIndex;
270 //do a swept sphere for now
271 btTransform ident;
272 ident.setIdentity();
273 btConvexCast::CastResult castResult;
274 castResult.m_fraction = m_hitFraction;
275 btSphereShape pointShape(m_ccdSphereRadius);
276 btTriangleShape triShape(triangle[0],triangle[1],triangle[2]);
277 btVoronoiSimplexSolver simplexSolver;
278 btSubsimplexConvexCast convexCaster(&pointShape,&triShape,&simplexSolver);
279 //GjkConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
280 //ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0);
281 //local space?
282
283 if (convexCaster.calcTimeOfImpact(m_ccdSphereFromTrans,m_ccdSphereToTrans,
284 ident,ident,castResult))
285 {
286 if (m_hitFraction > castResult.m_fraction)
287 m_hitFraction = castResult.m_fraction;
288 }
289
290 }
291
292 };
293
294
295
296
297
298 if (triBody->getCollisionShape()->isConcave())
299 {
300 btVector3 rayAabbMin = convexFromLocal.getOrigin();
301 rayAabbMin.setMin(convexToLocal.getOrigin());
302 btVector3 rayAabbMax = convexFromLocal.getOrigin();
303 rayAabbMax.setMax(convexToLocal.getOrigin());
304 btScalar ccdRadius0 = convexbody->getCcdSweptSphereRadius();
305 rayAabbMin -= btVector3(ccdRadius0,ccdRadius0,ccdRadius0);
306 rayAabbMax += btVector3(ccdRadius0,ccdRadius0,ccdRadius0);
307
308 btScalar curHitFraction = btScalar(1.); //is this available?
309 LocalTriangleSphereCastCallback raycastCallback(convexFromLocal,convexToLocal,
310 convexbody->getCcdSweptSphereRadius(),curHitFraction);
311
312 raycastCallback.m_hitFraction = convexbody->getHitFraction();
313
314 btCollisionObject* concavebody = triBody;
315
316 btConcaveShape* triangleMesh = (btConcaveShape*) concavebody->getCollisionShape();
317
318 if (triangleMesh)
319 {
320 triangleMesh->processAllTriangles(&raycastCallback,rayAabbMin,rayAabbMax);
321 }
322
323
324
325 if (raycastCallback.m_hitFraction < convexbody->getHitFraction())
326 {
327 convexbody->setHitFraction( raycastCallback.m_hitFraction);
328 return raycastCallback.m_hitFraction;
329 }
330 }
331
332 return btScalar(1.);
333
334 }
btConvexConcaveCollisionAlgorithm::~btConvexConcaveCollisionAlgorithm
virtual ~btConvexConcaveCollisionAlgorithm()
Definition: btConvexConcaveCollisionAlgorithm.cpp:37
btDispatcher::releaseManifold
virtual void releaseManifold(btPersistentManifold *manifold)=0
btConvexConcaveCollisionAlgorithm::processCollision
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
Definition: btConvexConcaveCollisionAlgorithm.cpp:185
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:268
btConvexTriangleCallback::m_dispatchInfoPtr
const btDispatcherInfo * m_dispatchInfoPtr
Definition: btConvexConcaveCollisionAlgorithm.h:40
btConvexCast::CastResult::m_fraction
btScalar m_fraction
Definition: btConvexCast.h:57
btConvexTriangleCallback::m_dispatcher
btDispatcher * m_dispatcher
Definition: btConvexConcaveCollisionAlgorithm.h:39
btCollisionObject::getCcdSweptSphereRadius
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:440
btDispatcher::findAlgorithm
virtual btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold=0)=0
btConvexConcaveCollisionAlgorithm::m_btConvexTriangleCallback
btConvexTriangleCallback m_btConvexTriangleCallback
Definition: btConvexConcaveCollisionAlgorithm.h:83
btAlignedObjectArray< btPersistentManifold * >
btManifoldResult.h
btIDebugDraw::drawLine
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
btConvexTriangleCallback::~btConvexTriangleCallback
virtual ~btConvexTriangleCallback()
Definition: btConvexConcaveCollisionAlgorithm.cpp:65
btConvexTriangleCallback::clearCache
void clearCache()
Definition: btConvexConcaveCollisionAlgorithm.cpp:73
btManifoldResult::setPersistentManifold
void setPersistentManifold(btPersistentManifold *manifoldPtr)
Definition: btManifoldResult.h:70
btConvexTriangleCallback::m_collisionMarginTriangle
btScalar m_collisionMarginTriangle
Definition: btConvexConcaveCollisionAlgorithm.h:41
btTransform::setIdentity
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:172
btActivatingCollisionAlgorithm
This class is not enabled yet (work-in-progress) to more aggressively activate objects.
Definition: btActivatingCollisionAlgorithm.h:22
btRaycastCallback.h
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:27
btCollisionObject::setHitFraction
void setHitFraction(btScalar hitFraction)
Definition: btCollisionObject.h:423
btManifoldResult::refreshContactPoints
void refreshContactPoints()
Definition: btManifoldResult.h:99
btSphereShape
The btSphereShape implements an implicit sphere, centered around a local origin with radius...
Definition: btSphereShape.h:22
btTriangleShape.h
btTriangleShape
Definition: btTriangleShape.h:22
btManifoldResult
btManifoldResult is a helper class to manage contact results.
Definition: btManifoldResult.h:39
btDispatcherInfo::m_debugDraw
class btIDebugDraw * m_debugDraw
Definition: btDispatcher.h:58
btManifoldResult::getBody1Wrap
const btCollisionObjectWrapper * getBody1Wrap() const
Definition: btManifoldResult.h:120
btConcaveShape::processAllTriangles
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const =0
btCollisionShape::getAabb
virtual void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t...
btConcaveShape.h
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition: btCollisionObject.h:360
btManifoldResult::setShapeIdentifiersA
virtual void setShapeIdentifiersA(int partId0, int index0)
setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material comb...
Definition: btManifoldResult.h:84
btCollisionShape::isConcave
bool isConcave() const
Definition: btCollisionShape.h:81
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:327
btConvexInternalShape::setMargin
virtual void setMargin(btScalar margin)
Definition: btConvexInternalShape.h:109
btConvexCast::CastResult
RayResult stores the closest result alternatively, add a callback method to decide about closest/all ...
Definition: btConvexCast.h:36
btConvexTriangleCallback::m_convexBodyWrap
const btCollisionObjectWrapper * m_convexBodyWrap
Definition: btConvexConcaveCollisionAlgorithm.h:31
btIDebugDraw::DBG_DrawWireframe
Definition: btIDebugDraw.h:59
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:117
btConvexConcaveCollisionAlgorithm.h
btVoronoiSimplexSolver
btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points...
Definition: btVoronoiSimplexSolver.h:95
btTriangleCallback
The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTrian...
Definition: btTriangleCallback.h:24
btManifoldResult::getBody0Wrap
const btCollisionObjectWrapper * getBody0Wrap() const
Definition: btManifoldResult.h:116
btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact
btScalar calculateTimeOfImpact(btCollisionObject *body0, btCollisionObject *body1, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
Definition: btConvexConcaveCollisionAlgorithm.cpp:221
btSubsimplexConvexCast::calcTimeOfImpact
virtual bool calcTimeOfImpact(const btTransform &fromA, const btTransform &toA, const btTransform &fromB, const btTransform &toB, CastResult &result)
SimsimplexConvexCast calculateTimeOfImpact calculates the time of impact+normal for the linear cast (...
Definition: btSubSimplexConvexCast.cpp:38
btConvexConcaveCollisionAlgorithm::m_isSwapped
bool m_isSwapped
Definition: btConvexConcaveCollisionAlgorithm.h:81
btCollisionObjectWrapper::getWorldTransform
const btTransform & getWorldTransform() const
Definition: btCollisionObjectWrapper.h:38
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:49
btBroadphaseProxy.h
btConvexTriangleCallback::setTimeStepAndCounters
void setTimeStepAndCounters(btScalar collisionMarginTriangle, const btDispatcherInfo &dispatchInfo, const btCollisionObjectWrapper *convexBodyWrap, const btCollisionObjectWrapper *triBodyWrap, btManifoldResult *resultOut)
Definition: btConvexConcaveCollisionAlgorithm.cpp:156
btManifoldResult::getBody0Internal
const btCollisionObject * getBody0Internal() const
Definition: btManifoldResult.h:135
btDispatcher::freeCollisionAlgorithm
virtual void freeCollisionAlgorithm(void *ptr)=0
btDispatcher::getNewManifold
virtual btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)=0
btTransform::inverse
btTransform inverse() const
Return the inverse of this transform.
Definition: btTransform.h:188
btConvexTriangleCallback::getAabbMax
const btVector3 & getAabbMax() const
Definition: btConvexConcaveCollisionAlgorithm.h:67
btCollisionObjectWrapper.h
btManifoldResult::setShapeIdentifiersB
virtual void setShapeIdentifiersB(int partId1, int index1)
Definition: btManifoldResult.h:90
btConvexTriangleCallback::m_aabbMax
btVector3 m_aabbMax
Definition: btConvexConcaveCollisionAlgorithm.h:35
btCollisionObjectWrapper::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObjectWrapper.h:40
btCollisionObject::getHitFraction
btScalar getHitFraction() const
Definition: btCollisionObject.h:418
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
btMultiSphereShape.h
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btSubsimplexConvexCast
btSubsimplexConvexCast implements Gino van den Bergens' paper "Ray Casting against bteral Convex Obje...
Definition: btSubSimplexConvexCast.h:28
btCollisionShape::isConvex
bool isConvex() const
Definition: btCollisionShape.h:73
btIDebugDraw.h
btConcaveShape
The btConcaveShape class provides an interface for non-moving (static) concave shapes.
Definition: btConcaveShape.h:36
btSubSimplexConvexCast.h
btConvexTriangleCallback::clearWrapperData
void clearWrapperData()
Definition: btConvexConcaveCollisionAlgorithm.h:52
btIDebugDraw::getDebugMode
virtual int getDebugMode() const =0
btManifoldResult::setBody1Wrap
void setBody1Wrap(const btCollisionObjectWrapper *obj1Wrap)
Definition: btManifoldResult.h:130
btConvexTriangleCallback::processTriangle
virtual void processTriangle(btVector3 *triangle, int partId, int triangleIndex)
Definition: btConvexConcaveCollisionAlgorithm.cpp:79
btCollisionObject.h
btConvexConcaveCollisionAlgorithm::getAllContactManifolds
virtual void getAllContactManifolds(btManifoldArray &manifoldArray)
Definition: btConvexConcaveCollisionAlgorithm.cpp:41
btConvexTriangleCallback::m_triBodyWrap
const btCollisionObjectWrapper * m_triBodyWrap
Definition: btConvexConcaveCollisionAlgorithm.h:32
btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm
btConvexConcaveCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo &ci, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, bool isSwapped)
Definition: btConvexConcaveCollisionAlgorithm.cpp:30
btConvexTriangleCallback::btConvexTriangleCallback
btConvexTriangleCallback(btDispatcher *dispatcher, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, bool isSwapped)
Definition: btConvexConcaveCollisionAlgorithm.cpp:50
btConvexTriangleCallback::m_aabbMin
btVector3 m_aabbMin
Definition: btConvexConcaveCollisionAlgorithm.h:34
btConcaveShape::getMargin
virtual btScalar getMargin() const
Definition: btConcaveShape.h:50
btManifoldResult::setBody0Wrap
void setBody0Wrap(const btCollisionObjectWrapper *obj0Wrap)
Definition: btManifoldResult.h:125
btVector3::setMax
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3.
Definition: btVector3.h:609
btDispatcherInfo
Definition: btDispatcher.h:30
btCollisionAlgorithmConstructionInfo::m_dispatcher1
btDispatcher * m_dispatcher1
Definition: btCollisionAlgorithm.h:45
btConvexTriangleCallback::m_manifoldPtr
btPersistentManifold * m_manifoldPtr
Definition: btConvexConcaveCollisionAlgorithm.h:46
btCollisionAlgorithmConstructionInfo
Definition: btCollisionAlgorithm.h:32
btConvexTriangleCallback::getAabbMin
const btVector3 & getAabbMin() const
Definition: btConvexConcaveCollisionAlgorithm.h:63
btSphereShape.h
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:69
btConvexConcaveCollisionAlgorithm::clearCache
void clearCache()
Definition: btConvexConcaveCollisionAlgorithm.cpp:179
btCollisionAlgorithm
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
Definition: btCollisionAlgorithm.h:55
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:215
btCollisionObjectWrapper
Definition: btCollisionObjectWrapper.h:17
TestTriangleAgainstAabb2
bool TestTriangleAgainstAabb2(const btVector3 *vertices, const btVector3 &aabbMin, const btVector3 &aabbMax)
conservative test for overlap between triangle and aabb
Definition: btAabbUtil2.h:59
btPersistentManifold::setBodies
void setBodies(const btCollisionObject *body0, const btCollisionObject *body1)
Definition: btPersistentManifold.h:97
btVector3::setMin
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3.
Definition: btVector3.h:626
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btConvexTriangleCallback::m_resultOut
btManifoldResult * m_resultOut
Definition: btConvexConcaveCollisionAlgorithm.h:38
btCollisionObjectWrapper::getCollisionObject
const btCollisionObject * getCollisionObject() const
Definition: btCollisionObjectWrapper.h:39
btDispatcher::clearManifold
virtual void clearManifold(btPersistentManifold *manifold)=0