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

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btSoftBodyConcaveCollisionAlgorithm.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16#include "btSoftBodyConcaveCollisionAlgorithm.h"
17#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
18#include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
19#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
20#include "BulletCollision/CollisionShapes/btConcaveShape.h"
21#include "BulletCollision/CollisionDispatch/btManifoldResult.h"
22#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
23#include "BulletCollision/CollisionShapes/btTriangleShape.h"
24#include "BulletCollision/CollisionShapes/btSphereShape.h"
25#include "BulletCollision/CollisionShapes/btTetrahedronShape.h"
26#include "BulletCollision/CollisionShapes/btConvexHullShape.h"
27#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
28
29#include "LinearMath/btIDebugDraw.h"
30#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
31#include "BulletSoftBody/btSoftBody.h"
32
33#define BT_SOFTBODY_TRIANGLE_EXTRUSION btScalar(0.06) //make this configurable
34
35btSoftBodyConcaveCollisionAlgorithm::btSoftBodyConcaveCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped)
36 : btCollisionAlgorithm(ci),
37 m_isSwapped(isSwapped),
38 m_btSoftBodyTriangleCallback(ci.m_dispatcher1, body0Wrap, body1Wrap, isSwapped)
39{
40}
41
42btSoftBodyConcaveCollisionAlgorithm::~btSoftBodyConcaveCollisionAlgorithm()
43{
44}
45
46btSoftBodyTriangleCallback::btSoftBodyTriangleCallback(btDispatcher* dispatcher, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped) : m_dispatcher(dispatcher),
47 m_dispatchInfoPtr(0)
48{
49 m_softBody = (isSwapped ? (btSoftBody*)body1Wrap->getCollisionObject() : (btSoftBody*)body0Wrap->getCollisionObject());
50 m_triBody = isSwapped ? body0Wrap->getCollisionObject() : body1Wrap->getCollisionObject();
51
52 //
53 // create the manifold from the dispatcher 'manifold pool'
54 //
55 // m_manifoldPtr = m_dispatcher->getNewManifold(m_convexBody,m_triBody);
56
57 clearCache();
58}
59
60btSoftBodyTriangleCallback::~btSoftBodyTriangleCallback()
61{
62 clearCache();
63 // m_dispatcher->releaseManifold( m_manifoldPtr );
64}
65
66 void btSoftBodyTriangleCallback::clearCache()
67{
68 for (int i = 0; i < m_shapeCache.size(); i++)
69 {
70 btTriIndex* tmp = m_shapeCache.getAtIndex(i);
71 btAssert(tmp);
72 btAssert(tmp->m_childShape);
73 m_softBody->getWorldInfo()->m_sparsesdf.RemoveReferences(tmp->m_childShape); //necessary?
74 delete tmp->m_childShape;
75 }
76 m_shapeCache.clear();
77}
78
79 void btSoftBodyTriangleCallback::processTriangle(btVector3* triangle, int partId, int triangleIndex)
80{
81 //just for debugging purposes
82 //printf("triangle %d",m_triangleCount++);
83
84 btCollisionAlgorithmConstructionInfo ci;
85 ci.m_dispatcher1 = m_dispatcher;
86
88 if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && (m_dispatchInfoPtr->m_debugDraw->getDebugMode() & btIDebugDraw::DBG_DrawWireframe))
89 {
90 btVector3 color(1, 1, 0);
91 const btTransform& tr = m_triBody->getWorldTransform();
92 m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]), tr(triangle[1]), color);
93 m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]), tr(triangle[2]), color);
94 m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]), tr(triangle[0]), color);
95 }
96
97 btTriIndex triIndex(partId, triangleIndex, 0);
98 btHashKey<btTriIndex> triKey(triIndex.getUid());
99
100 btTriIndex* shapeIndex = m_shapeCache[triKey];
101 if (shapeIndex)
102 {
103 btCollisionShape* tm = shapeIndex->m_childShape;
104 btAssert(tm);
105
106 //copy over user pointers to temporary shape
107 tm->setUserPointer(m_triBody->getCollisionShape()->getUserPointer());
108
109 btCollisionObjectWrapper softBody(0, m_softBody->getCollisionShape(), m_softBody, m_softBody->getWorldTransform(), -1, -1);
110 //btCollisionObjectWrapper triBody(0,tm, ob, btTransform::getIdentity());//ob->getWorldTransform());//??
111 btCollisionObjectWrapper triBody(0, tm, m_triBody, m_triBody->getWorldTransform(), partId, triangleIndex);
112 ebtDispatcherQueryType algoType = m_resultOut->m_closestPointDistanceThreshold > 0 ? BT_CLOSEST_POINT_ALGORITHMS : BT_CONTACT_POINT_ALGORITHMS;
113 btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(&softBody, &triBody, 0, algoType); //m_manifoldPtr);
114
115 colAlgo->processCollision(&softBody, &triBody, *m_dispatchInfoPtr, m_resultOut);
116 colAlgo->~btCollisionAlgorithm();
117 ci.m_dispatcher1->freeCollisionAlgorithm(colAlgo);
118
119 return;
120 }
121
122 //aabb filter is already applied!
123
124 //btCollisionObject* colObj = static_cast<btCollisionObject*>(m_convexProxy->m_clientObject);
125
126 // if (m_softBody->getCollisionShape()->getShapeType()==
127 {
128 // btVector3 other;
129 btVector3 normal = (triangle[1] - triangle[0]).cross(triangle[2] - triangle[0]);
130 normal.normalize();
131 normal *= BT_SOFTBODY_TRIANGLE_EXTRUSION;
132 // other=(triangle[0]+triangle[1]+triangle[2])*0.333333f;
133 // other+=normal*22.f;
134 btVector3 pts[6] = {triangle[0] + normal,
135 triangle[1] + normal,
136 triangle[2] + normal,
137 triangle[0] - normal,
138 triangle[1] - normal,
139 triangle[2] - normal};
140
141 btConvexHullShape* tm = new btConvexHullShape(&pts[0].getX(), 6);
142
143 // btBU_Simplex1to4 tm(triangle[0],triangle[1],triangle[2],other);
144
145 //btTriangleShape tm(triangle[0],triangle[1],triangle[2]);
146 // tm.setMargin(m_collisionMarginTriangle);
147
148 //copy over user pointers to temporary shape
149 tm->setUserPointer(m_triBody->getCollisionShape()->getUserPointer());
150
151 btCollisionObjectWrapper softBody(0, m_softBody->getCollisionShape(), m_softBody, m_softBody->getWorldTransform(), -1, -1);
152 btCollisionObjectWrapper triBody(0, tm, m_triBody, m_triBody->getWorldTransform(), partId, triangleIndex); //btTransform::getIdentity());//??
153
154 ebtDispatcherQueryType algoType = m_resultOut->m_closestPointDistanceThreshold > 0 ? BT_CLOSEST_POINT_ALGORITHMS : BT_CONTACT_POINT_ALGORITHMS;
155 btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(&softBody, &triBody, 0, algoType); //m_manifoldPtr);
156
157 colAlgo->processCollision(&softBody, &triBody, *m_dispatchInfoPtr, m_resultOut);
158 colAlgo->~btCollisionAlgorithm();
159 ci.m_dispatcher1->freeCollisionAlgorithm(colAlgo);
160
161 triIndex.m_childShape = tm;
162 m_shapeCache.insert(triKey, triIndex);
163 }
164}
165
166 void btSoftBodyTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTriangle, const btCollisionObjectWrapper* triBodyWrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut)
167{
168 m_dispatchInfoPtr = &dispatchInfo;
169 m_collisionMarginTriangle = collisionMarginTriangle + btScalar(BT_SOFTBODY_TRIANGLE_EXTRUSION);
170 m_resultOut = resultOut;
171
172 btVector3 aabbWorldSpaceMin, aabbWorldSpaceMax;
173 m_softBody->getAabb(aabbWorldSpaceMin, aabbWorldSpaceMax);
174 btVector3 halfExtents = (aabbWorldSpaceMax - aabbWorldSpaceMin) * btScalar(0.5);
175 btVector3 softBodyCenter = (aabbWorldSpaceMax + aabbWorldSpaceMin) * btScalar(0.5);
176
177 btTransform softTransform;
178 softTransform.setIdentity();
179 softTransform.setOrigin(softBodyCenter);
180
181 btTransform convexInTriangleSpace;
182 convexInTriangleSpace = triBodyWrap->getWorldTransform().inverse() * softTransform;
183 btTransformAabb(halfExtents, m_collisionMarginTriangle, convexInTriangleSpace, m_aabbMin, m_aabbMax);
184}
185
186 void btSoftBodyConcaveCollisionAlgorithm::clearCache()
187{
188 m_btSoftBodyTriangleCallback.clearCache();
189}
190
191 void btSoftBodyConcaveCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut)
192{
193 //btCollisionObject* convexBody = m_isSwapped ? body1 : body0;
194 const btCollisionObjectWrapper* triBody = m_isSwapped ? body0Wrap : body1Wrap;
195
196 if (triBody->getCollisionShape()->isConcave())
197 {
198 const btConcaveShape* concaveShape = static_cast<const btConcaveShape*>(triBody->getCollisionShape());
199
200 // if (convexBody->getCollisionShape()->isConvex())
201 {
202 btScalar collisionMarginTriangle = concaveShape->getMargin();
203
204 // resultOut->setPersistentManifold(m_btSoftBodyTriangleCallback.m_manifoldPtr);
205 m_btSoftBodyTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle, triBody, dispatchInfo, resultOut);
206
207 concaveShape->processAllTriangles(&m_btSoftBodyTriangleCallback, m_btSoftBodyTriangleCallback.getAabbMin(), m_btSoftBodyTriangleCallback.getAabbMax());
208
209 // resultOut->refreshContactPoints();
210 }
211 }
212}
213
214 btScalar btSoftBodyConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut)
215{
216 (void)resultOut;
217 (void)dispatchInfo;
218 btCollisionObject* convexbody = m_isSwapped ? body1 : body0;
219 btCollisionObject* triBody = m_isSwapped ? body0 : body1;
220
221 //quick approximation using raycast, todo: hook up to the continuous collision detection (one of the btConvexCast)
222
223 //only perform CCD above a certain threshold, this prevents blocking on the long run
224 //because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
225 btScalar squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
226 if (squareMot0 < convexbody->getCcdSquareMotionThreshold())
227 {
228 return btScalar(1.);
229 }
230
231 //const btVector3& from = convexbody->m_worldTransform.getOrigin();
232 //btVector3 to = convexbody->m_interpolationWorldTransform.getOrigin();
233 //todo: only do if the motion exceeds the 'radius'
234
235 btTransform triInv = triBody->getWorldTransform().inverse();
236 btTransform convexFromLocal = triInv * convexbody->getWorldTransform();
237 btTransform convexToLocal = triInv * convexbody->getInterpolationWorldTransform();
238
239 struct LocalTriangleSphereCastCallback : public btTriangleCallback
240 {
241 btTransform m_ccdSphereFromTrans;
242 btTransform m_ccdSphereToTrans;
243 btTransform m_meshTransform;
244
245 btScalar m_ccdSphereRadius;
246 btScalar m_hitFraction;
247
248 LocalTriangleSphereCastCallback(const btTransform& from, const btTransform& to, btScalar ccdSphereRadius, btScalar hitFraction)
249 : m_ccdSphereFromTrans(from),
250 m_ccdSphereToTrans(to),
251 m_ccdSphereRadius(ccdSphereRadius),
252 m_hitFraction(hitFraction)
253 {
254 }
255
256 virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex)
257 {
258 (void)partId;
259 (void)triangleIndex;
260 //do a swept sphere for now
261 btTransform ident;
262 ident.setIdentity();
263 btConvexCast::CastResult castResult;
264 castResult.m_fraction = m_hitFraction;
265 btSphereShape pointShape(m_ccdSphereRadius);
266 btTriangleShape triShape(triangle[0], triangle[1], triangle[2]);
267 btVoronoiSimplexSolver simplexSolver;
268 btSubsimplexConvexCast convexCaster(&pointShape, &triShape, &simplexSolver);
269 //GjkConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
270 //ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0);
271 //local space?
272
273 if (convexCaster.calcTimeOfImpact(m_ccdSphereFromTrans, m_ccdSphereToTrans,
274 ident, ident, castResult))
275 {
276 if (m_hitFraction > castResult.m_fraction)
277 m_hitFraction = castResult.m_fraction;
278 }
279 }
280 };
281
282 if (triBody->getCollisionShape()->isConcave())
283 {
284 btVector3 rayAabbMin = convexFromLocal.getOrigin();
285 rayAabbMin.setMin(convexToLocal.getOrigin());
286 btVector3 rayAabbMax = convexFromLocal.getOrigin();
287 rayAabbMax.setMax(convexToLocal.getOrigin());
288 btScalar ccdRadius0 = convexbody->getCcdSweptSphereRadius();
289 rayAabbMin -= btVector3(ccdRadius0, ccdRadius0, ccdRadius0);
290 rayAabbMax += btVector3(ccdRadius0, ccdRadius0, ccdRadius0);
291
292 btScalar curHitFraction = btScalar(1.); //is this available?
293 LocalTriangleSphereCastCallback raycastCallback(convexFromLocal, convexToLocal,
294 convexbody->getCcdSweptSphereRadius(), curHitFraction);
295
296 raycastCallback.m_hitFraction = convexbody->getHitFraction();
297
298 btCollisionObject* concavebody = triBody;
299
300 btConcaveShape* triangleMesh = (btConcaveShape*)concavebody->getCollisionShape();
301
302 if (triangleMesh)
303 {
304 triangleMesh->processAllTriangles(&raycastCallback, rayAabbMin, rayAabbMax);
305 }
306
307 if (raycastCallback.m_hitFraction < convexbody->getHitFraction())
308 {
309 convexbody->setHitFraction(raycastCallback.m_hitFraction);
310 return raycastCallback.m_hitFraction;
311 }
312 }
313
314 return btScalar(1.);
315}
btTransformAabb
void btTransformAabb(const btVector3 &halfExtents, btScalar margin, const btTransform &t, btVector3 &aabbMinOut, btVector3 &aabbMaxOut)
Definition btAabbUtil2.h:172
btBroadphaseProxy.h
btCollisionObjectWrapper.h
btCollisionObject.h
btConcaveShape.h
btConvexHullShape.h
ebtDispatcherQueryType
ebtDispatcherQueryType
Definition btDispatcher.h:69
BT_CLOSEST_POINT_ALGORITHMS
@ BT_CLOSEST_POINT_ALGORITHMS
Definition btDispatcher.h:71
BT_CONTACT_POINT_ALGORITHMS
@ BT_CONTACT_POINT_ALGORITHMS
Definition btDispatcher.h:70
btIDebugDraw.h
btManifoldResult.h
btMultiSphereShape.h
btRaycastCallback.h
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition btScalar.h:314
btAssert
#define btAssert(x)
Definition btScalar.h:153
BT_SOFTBODY_TRIANGLE_EXTRUSION
#define BT_SOFTBODY_TRIANGLE_EXTRUSION
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:33
btSoftBodyConcaveCollisionAlgorithm.h
btSoftBody.h
btSphereShape.h
btSubSimplexConvexCast.h
btTetrahedronShape.h
btTriangleShape.h
btCollisionAlgorithm
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
Definition btCollisionAlgorithm.h:54
btCollisionAlgorithm::processCollision
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0
btCollisionAlgorithm::~btCollisionAlgorithm
virtual ~btCollisionAlgorithm()
Definition btCollisionAlgorithm.h:66
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition btCollisionObject.h:51
btCollisionObject::getHitFraction
btScalar getHitFraction() const
Definition btCollisionObject.h:479
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition btCollisionObject.h:379
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition btCollisionObject.h:410
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition btCollisionObject.h:228
btCollisionObject::setHitFraction
void setHitFraction(btScalar hitFraction)
Definition btCollisionObject.h:484
btCollisionObject::getCcdSweptSphereRadius
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition btCollisionObject.h:500
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition btCollisionShape.h:28
btCollisionShape::setUserPointer
void setUserPointer(void *userPtr)
optional user data pointer
Definition btCollisionShape.h:122
btCollisionShape::getUserPointer
void * getUserPointer() const
Definition btCollisionShape.h:127
btCollisionShape::isConcave
bool isConcave() const
Definition btCollisionShape.h:78
btConcaveShape
The btConcaveShape class provides an interface for non-moving (static) concave shapes.
Definition btConcaveShape.h:39
btConcaveShape::getMargin
virtual btScalar getMargin() const
Definition btConcaveShape.h:52
btConcaveShape::processAllTriangles
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const =0
btConvexHullShape
The btConvexHullShape implements an implicit convex hull of an array of vertices.
Definition btConvexHullShape.h:27
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition btDispatcher.h:77
btDispatcher::freeCollisionAlgorithm
virtual void freeCollisionAlgorithm(void *ptr)=0
btDispatcher::findAlgorithm
virtual btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold, ebtDispatcherQueryType queryType)=0
btHashKey
Definition btHashMap.h:184
btHashMap::insert
void insert(const Key &key, const Value &value)
Definition btHashMap.h:264
btHashMap::clear
void clear()
Definition btHashMap.h:461
btHashMap::size
int size() const
Definition btHashMap.h:373
btHashMap::getAtIndex
const Value * getAtIndex(int index) const
Definition btHashMap.h:378
btIDebugDraw::drawLine
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
btIDebugDraw::getDebugMode
virtual int getDebugMode() const =0
btIDebugDraw::DBG_DrawWireframe
@ DBG_DrawWireframe
Definition btIDebugDraw.h:55
btManifoldResult
btManifoldResult is a helper class to manage contact results.
Definition btManifoldResult.h:48
btManifoldResult::m_closestPointDistanceThreshold
btScalar m_closestPointDistanceThreshold
Definition btManifoldResult.h:152
btSoftBodyConcaveCollisionAlgorithm::clearCache
void clearCache()
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:186
btSoftBodyConcaveCollisionAlgorithm::processCollision
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:191
btSoftBodyConcaveCollisionAlgorithm::m_btSoftBodyTriangleCallback
btSoftBodyTriangleCallback m_btSoftBodyTriangleCallback
Definition btSoftBodyConcaveCollisionAlgorithm.h:110
btSoftBodyConcaveCollisionAlgorithm::btSoftBodyConcaveCollisionAlgorithm
btSoftBodyConcaveCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo &ci, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, bool isSwapped)
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:35
btSoftBodyConcaveCollisionAlgorithm::m_isSwapped
bool m_isSwapped
Definition btSoftBodyConcaveCollisionAlgorithm.h:108
btSoftBodyConcaveCollisionAlgorithm::calculateTimeOfImpact
btScalar calculateTimeOfImpact(btCollisionObject *body0, btCollisionObject *body1, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:214
btSoftBodyConcaveCollisionAlgorithm::~btSoftBodyConcaveCollisionAlgorithm
virtual ~btSoftBodyConcaveCollisionAlgorithm()
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:42
btSoftBodyTriangleCallback::m_triBody
const btCollisionObject * m_triBody
Definition btSoftBodyConcaveCollisionAlgorithm.h:67
btSoftBodyTriangleCallback::processTriangle
virtual void processTriangle(btVector3 *triangle, int partId, int triangleIndex)
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:79
btSoftBodyTriangleCallback::m_dispatchInfoPtr
const btDispatcherInfo * m_dispatchInfoPtr
Definition btSoftBodyConcaveCollisionAlgorithm.h:75
btSoftBodyTriangleCallback::btSoftBodyTriangleCallback
btSoftBodyTriangleCallback(btDispatcher *dispatcher, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, bool isSwapped)
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:46
btSoftBodyTriangleCallback::m_shapeCache
btHashMap< btHashKey< btTriIndex >, btTriIndex > m_shapeCache
Definition btSoftBodyConcaveCollisionAlgorithm.h:78
btSoftBodyTriangleCallback::getAabbMax
const btVector3 & getAabbMax() const
Definition btSoftBodyConcaveCollisionAlgorithm.h:99
btSoftBodyTriangleCallback::m_aabbMax
btVector3 m_aabbMax
Definition btSoftBodyConcaveCollisionAlgorithm.h:70
btSoftBodyTriangleCallback::m_aabbMin
btVector3 m_aabbMin
Definition btSoftBodyConcaveCollisionAlgorithm.h:69
btSoftBodyTriangleCallback::m_collisionMarginTriangle
btScalar m_collisionMarginTriangle
Definition btSoftBodyConcaveCollisionAlgorithm.h:76
btSoftBodyTriangleCallback::clearCache
void clearCache()
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:66
btSoftBodyTriangleCallback::m_resultOut
btManifoldResult * m_resultOut
Definition btSoftBodyConcaveCollisionAlgorithm.h:72
btSoftBodyTriangleCallback::m_softBody
btSoftBody * m_softBody
Definition btSoftBodyConcaveCollisionAlgorithm.h:66
btSoftBodyTriangleCallback::~btSoftBodyTriangleCallback
virtual ~btSoftBodyTriangleCallback()
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:60
btSoftBodyTriangleCallback::getAabbMin
const btVector3 & getAabbMin() const
Definition btSoftBodyConcaveCollisionAlgorithm.h:95
btSoftBodyTriangleCallback::setTimeStepAndCounters
void setTimeStepAndCounters(btScalar collisionMarginTriangle, const btCollisionObjectWrapper *triObjWrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
Definition btSoftBodyConcaveCollisionAlgorithm.cpp:166
btSoftBodyTriangleCallback::m_dispatcher
btDispatcher * m_dispatcher
Definition btSoftBodyConcaveCollisionAlgorithm.h:74
btSoftBody
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition btSoftBody.h:75
btSoftBody::getWorldInfo
btSoftBodyWorldInfo * getWorldInfo()
Definition btSoftBody.h:881
btSoftBody::getAabb
virtual void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
Definition btSoftBody.h:1174
btSphereShape
The btSphereShape implements an implicit sphere, centered around a local origin with radius.
Definition btSphereShape.h:25
btSubsimplexConvexCast
btSubsimplexConvexCast implements Gino van den Bergens' paper "Ray Casting against bteral Convex Obje...
Definition btSubSimplexConvexCast.h:28
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
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition btTransform.h:30
btTransform::inverse
btTransform inverse() const
Return the inverse of this transform.
Definition btTransform.h:183
btTransform::setIdentity
void setIdentity()
Set this transformation to the identity.
Definition btTransform.h:167
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition btTransform.h:114
btTransform::setOrigin
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition btTransform.h:147
btTriangleCallback
The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTrian...
Definition btTriangleCallback.h:24
btTriangleShape
Definition btTriangleShape.h:24
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition btVector3.h:82
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
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
btVector3::normalize
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
Definition btVector3.h:303
btVoronoiSimplexSolver
btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points...
Definition btVoronoiSimplexSolver.h:99
btCollisionAlgorithmConstructionInfo
Definition btCollisionAlgorithm.h:33
btCollisionAlgorithmConstructionInfo::m_dispatcher1
btDispatcher * m_dispatcher1
Definition btCollisionAlgorithm.h:45
btCollisionObjectWrapper
Definition btCollisionObjectWrapper.h:18
btCollisionObjectWrapper::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition btCollisionObjectWrapper.h:46
btCollisionObjectWrapper::getCollisionObject
const btCollisionObject * getCollisionObject() const
Definition btCollisionObjectWrapper.h:45
btCollisionObjectWrapper::getWorldTransform
const btTransform & getWorldTransform() const
Definition btCollisionObjectWrapper.h:44
btConvexCast::CastResult
RayResult stores the closest result alternatively, add a callback method to decide about closest/all ...
Definition btConvexCast.h:47
btConvexCast::CastResult::m_fraction
btScalar m_fraction
Definition btConvexCast.h:72
btDispatcherInfo
Definition btDispatcher.h:31
btDispatcherInfo::m_debugDraw
class btIDebugDraw * m_debugDraw
Definition btDispatcher.h:58
btSoftBodyWorldInfo::m_sparsesdf
btSparseSdf< 3 > m_sparsesdf
Definition btSoftBody.h:57
btSparseSdf::RemoveReferences
int RemoveReferences(btCollisionShape *pcs)
Definition btSparseSDF.h:168
btTriIndex
Definition btSoftBodyConcaveCollisionAlgorithm.h:35
btTriIndex::getUid
int getUid() const
Definition btSoftBodyConcaveCollisionAlgorithm.h:57
btTriIndex::m_childShape
class btCollisionShape * m_childShape
Definition btSoftBodyConcaveCollisionAlgorithm.h:37