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

Bullet Collision Detection & Physics Library

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