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

Bullet Collision Detection & Physics Library

btSoftMultiBodyDynamicsWorld.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 "btSoftMultiBodyDynamicsWorld.h"
18 #include "LinearMath/btQuickprof.h"
19
20 //softbody & helpers
21 #include "BulletSoftBody/btSoftBody.h"
22 #include "BulletSoftBody/btSoftBodyHelpers.h"
23 #include "BulletSoftBody/btSoftBodySolvers.h"
24 #include "BulletSoftBody/btDefaultSoftBodySolver.h"
25 #include "LinearMath/btSerializer.h"
26
27
28 btSoftMultiBodyDynamicsWorld::btSoftMultiBodyDynamicsWorld(
29 btDispatcher* dispatcher,
30 btBroadphaseInterface* pairCache,
31 btMultiBodyConstraintSolver* constraintSolver,
32 btCollisionConfiguration* collisionConfiguration,
33 btSoftBodySolver *softBodySolver ) :
34 btMultiBodyDynamicsWorld(dispatcher,pairCache,constraintSolver,collisionConfiguration),
35 m_softBodySolver( softBodySolver ),
36 m_ownsSolver(false)
37 {
38 if( !m_softBodySolver )
39 {
40 void* ptr = btAlignedAlloc(sizeof(btDefaultSoftBodySolver),16);
41 m_softBodySolver = new(ptr) btDefaultSoftBodySolver();
42 m_ownsSolver = true;
43 }
44
45 m_drawFlags = fDrawFlags::Std;
46 m_drawNodeTree = true;
47 m_drawFaceTree = false;
48 m_drawClusterTree = false;
49 m_sbi.m_broadphase = pairCache;
50 m_sbi.m_dispatcher = dispatcher;
51 m_sbi.m_sparsesdf.Initialize();
52 m_sbi.m_sparsesdf.Reset();
53
54 m_sbi.air_density = (btScalar)1.2;
55 m_sbi.water_density = 0;
56 m_sbi.water_offset = 0;
57 m_sbi.water_normal = btVector3(0,0,0);
58 m_sbi.m_gravity.setValue(0,-10,0);
59
60 m_sbi.m_sparsesdf.Initialize();
61
62
63 }
64
65 btSoftMultiBodyDynamicsWorld::~btSoftMultiBodyDynamicsWorld()
66 {
67 if (m_ownsSolver)
68 {
69 m_softBodySolver->~btSoftBodySolver();
70 btAlignedFree(m_softBodySolver);
71 }
72 }
73
74 void btSoftMultiBodyDynamicsWorld::predictUnconstraintMotion(btScalar timeStep)
75 {
76 btDiscreteDynamicsWorld::predictUnconstraintMotion( timeStep );
77 {
78 BT_PROFILE("predictUnconstraintMotionSoftBody");
79 m_softBodySolver->predictMotion( float(timeStep) );
80 }
81 }
82
83 void btSoftMultiBodyDynamicsWorld::internalSingleStepSimulation( btScalar timeStep )
84 {
85
86 // Let the solver grab the soft bodies and if necessary optimize for it
87 m_softBodySolver->optimize( getSoftBodyArray() );
88
89 if( !m_softBodySolver->checkInitialized() )
90 {
91 btAssert( "Solver initialization failed\n" );
92 }
93
94 btDiscreteDynamicsWorld::internalSingleStepSimulation( timeStep );
95
97 solveSoftBodiesConstraints( timeStep );
98
99 //self collisions
100 for ( int i=0;i<m_softBodies.size();i++)
101 {
102 btSoftBody* psb=(btSoftBody*)m_softBodies[i];
103 psb->defaultCollisionHandler(psb);
104 }
105
107 m_softBodySolver->updateSoftBodies( );
108
109 // End solver-wise simulation step
110 // ///////////////////////////////
111
112 }
113
114 void btSoftMultiBodyDynamicsWorld::solveSoftBodiesConstraints( btScalar timeStep )
115 {
116 BT_PROFILE("solveSoftConstraints");
117
118 if(m_softBodies.size())
119 {
120 btSoftBody::solveClusters(m_softBodies);
121 }
122
123 // Solve constraints solver-wise
124 m_softBodySolver->solveConstraints( timeStep * m_softBodySolver->getTimeScale() );
125
126 }
127
128 void btSoftMultiBodyDynamicsWorld::addSoftBody(btSoftBody* body, int collisionFilterGroup, int collisionFilterMask)
129 {
130 m_softBodies.push_back(body);
131
132 // Set the soft body solver that will deal with this body
133 // to be the world's solver
134 body->setSoftBodySolver( m_softBodySolver );
135
136 btCollisionWorld::addCollisionObject(body,
137 collisionFilterGroup,
138 collisionFilterMask);
139
140 }
141
142 void btSoftMultiBodyDynamicsWorld::removeSoftBody(btSoftBody* body)
143 {
144 m_softBodies.remove(body);
145
146 btCollisionWorld::removeCollisionObject(body);
147 }
148
149 void btSoftMultiBodyDynamicsWorld::removeCollisionObject(btCollisionObject* collisionObject)
150 {
151 btSoftBody* body = btSoftBody::upcast(collisionObject);
152 if (body)
153 removeSoftBody(body);
154 else
155 btDiscreteDynamicsWorld::removeCollisionObject(collisionObject);
156 }
157
158 void btSoftMultiBodyDynamicsWorld::debugDrawWorld()
159 {
160 btDiscreteDynamicsWorld::debugDrawWorld();
161
162 if (getDebugDrawer())
163 {
164 int i;
165 for ( i=0;i<this->m_softBodies.size();i++)
166 {
167 btSoftBody* psb=(btSoftBody*)this->m_softBodies[i];
168 if (getDebugDrawer() && (getDebugDrawer()->getDebugMode() & (btIDebugDraw::DBG_DrawWireframe)))
169 {
170 btSoftBodyHelpers::DrawFrame(psb,m_debugDrawer);
171 btSoftBodyHelpers::Draw(psb,m_debugDrawer,m_drawFlags);
172 }
173
174 if (m_debugDrawer && (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawAabb))
175 {
176 if(m_drawNodeTree) btSoftBodyHelpers::DrawNodeTree(psb,m_debugDrawer);
177 if(m_drawFaceTree) btSoftBodyHelpers::DrawFaceTree(psb,m_debugDrawer);
178 if(m_drawClusterTree) btSoftBodyHelpers::DrawClusterTree(psb,m_debugDrawer);
179 }
180 }
181 }
182 }
183
184
185
186
187 struct btSoftSingleRayCallback : public btBroadphaseRayCallback
188 {
189 btVector3 m_rayFromWorld;
190 btVector3 m_rayToWorld;
191 btTransform m_rayFromTrans;
192 btTransform m_rayToTrans;
193 btVector3 m_hitNormal;
194
195 const btSoftMultiBodyDynamicsWorld* m_world;
196 btCollisionWorld::RayResultCallback& m_resultCallback;
197
198 btSoftSingleRayCallback(const btVector3& rayFromWorld,const btVector3& rayToWorld,const btSoftMultiBodyDynamicsWorld* world,btCollisionWorld::RayResultCallback& resultCallback)
199 :m_rayFromWorld(rayFromWorld),
200 m_rayToWorld(rayToWorld),
201 m_world(world),
202 m_resultCallback(resultCallback)
203 {
204 m_rayFromTrans.setIdentity();
205 m_rayFromTrans.setOrigin(m_rayFromWorld);
206 m_rayToTrans.setIdentity();
207 m_rayToTrans.setOrigin(m_rayToWorld);
208
209 btVector3 rayDir = (rayToWorld-rayFromWorld);
210
211 rayDir.normalize ();
213 m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[0];
214 m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[1];
215 m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[2];
216 m_signs[0] = m_rayDirectionInverse[0] < 0.0;
217 m_signs[1] = m_rayDirectionInverse[1] < 0.0;
218 m_signs[2] = m_rayDirectionInverse[2] < 0.0;
219
220 m_lambda_max = rayDir.dot(m_rayToWorld-m_rayFromWorld);
221
222 }
223
224
225
226 virtual bool process(const btBroadphaseProxy* proxy)
227 {
229 if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
230 return false;
231
232 btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
233
234 //only perform raycast if filterMask matches
235 if(m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
236 {
237 //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
238 //btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
239 #if 0
240 #ifdef RECALCULATE_AABB
241 btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
242 collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
243 #else
244 //getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
245 const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
246 const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
247 #endif
248 #endif
249 //btScalar hitLambda = m_resultCallback.m_closestHitFraction;
250 //culling already done by broadphase
251 //if (btRayAabb(m_rayFromWorld,m_rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,m_hitNormal))
252 {
253 m_world->rayTestSingle(m_rayFromTrans,m_rayToTrans,
254 collisionObject,
255 collisionObject->getCollisionShape(),
256 collisionObject->getWorldTransform(),
257 m_resultCallback);
258 }
259 }
260 return true;
261 }
262 };
263
264 void btSoftMultiBodyDynamicsWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
265 {
266 BT_PROFILE("rayTest");
269 btSoftSingleRayCallback rayCB(rayFromWorld,rayToWorld,this,resultCallback);
270
271 #ifndef USE_BRUTEFORCE_RAYBROADPHASE
272 m_broadphasePairCache->rayTest(rayFromWorld,rayToWorld,rayCB);
273 #else
274 for (int i=0;i<this->getNumCollisionObjects();i++)
275 {
276 rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
277 }
278 #endif //USE_BRUTEFORCE_RAYBROADPHASE
279
280 }
281
282
283 void btSoftMultiBodyDynamicsWorld::rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
284 btCollisionObject* collisionObject,
285 const btCollisionShape* collisionShape,
286 const btTransform& colObjWorldTransform,
287 RayResultCallback& resultCallback)
288 {
289 if (collisionShape->isSoftBody()) {
290 btSoftBody* softBody = btSoftBody::upcast(collisionObject);
291 if (softBody) {
292 btSoftBody::sRayCast softResult;
293 if (softBody->rayTest(rayFromTrans.getOrigin(), rayToTrans.getOrigin(), softResult))
294 {
295
296 if (softResult.fraction<= resultCallback.m_closestHitFraction)
297 {
298
299 btCollisionWorld::LocalShapeInfo shapeInfo;
300 shapeInfo.m_shapePart = 0;
301 shapeInfo.m_triangleIndex = softResult.index;
302 // get the normal
303 btVector3 rayDir = rayToTrans.getOrigin() - rayFromTrans.getOrigin();
304 btVector3 normal=-rayDir;
305 normal.normalize();
306
307 if (softResult.feature == btSoftBody::eFeature::Face)
308 {
309 normal = softBody->m_faces[softResult.index].m_normal;
310 if (normal.dot(rayDir) > 0) {
311 // normal always point toward origin of the ray
312 normal = -normal;
313 }
314 }
315
316 btCollisionWorld::LocalRayResult rayResult
317 (collisionObject,
318 &shapeInfo,
319 normal,
320 softResult.fraction);
321 bool normalInWorldSpace = true;
322 resultCallback.addSingleResult(rayResult,normalInWorldSpace);
323 }
324 }
325 }
326 }
327 else {
328 btCollisionWorld::rayTestSingle(rayFromTrans,rayToTrans,collisionObject,collisionShape,colObjWorldTransform,resultCallback);
329 }
330 }
331
332
333 void btSoftMultiBodyDynamicsWorld::serializeSoftBodies(btSerializer* serializer)
334 {
335 int i;
336 //serialize all collision objects
337 for (i=0;i<m_collisionObjects.size();i++)
338 {
339 btCollisionObject* colObj = m_collisionObjects[i];
340 if (colObj->getInternalType() & btCollisionObject::CO_SOFT_BODY)
341 {
342 int len = colObj->calculateSerializeBufferSize();
343 btChunk* chunk = serializer->allocate(len,1);
344 const char* structType = colObj->serialize(chunk->m_oldPtr, serializer);
345 serializer->finalizeChunk(chunk,structType,BT_SOFTBODY_CODE,colObj);
346 }
347 }
348
349 }
350
351 void btSoftMultiBodyDynamicsWorld::serialize(btSerializer* serializer)
352 {
353
354 serializer->startSerialization();
355
356 serializeDynamicsWorldInfo( serializer);
357
358 serializeSoftBodies(serializer);
359
360 serializeRigidBodies(serializer);
361
362 serializeCollisionObjects(serializer);
363
364 serializer->finishSerialization();
365 }
366
367
btTransform::setOrigin
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition: btTransform.h:150
btCollisionObject::CO_SOFT_BODY
Definition: btCollisionObject.h:153
btDiscreteDynamicsWorld::internalSingleStepSimulation
virtual void internalSingleStepSimulation(btScalar timeStep)
Definition: btDiscreteDynamicsWorld.cpp:473
btSoftMultiBodyDynamicsWorld::removeCollisionObject
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
Definition: btSoftMultiBodyDynamicsWorld.cpp:149
btSerializer::finishSerialization
virtual void finishSerialization()=0
btSoftMultiBodyDynamicsWorld.h
btDiscreteDynamicsWorld::serializeDynamicsWorldInfo
void serializeDynamicsWorldInfo(btSerializer *serializer)
Definition: btDiscreteDynamicsWorld.cpp:1472
btSoftMultiBodyDynamicsWorld::debugDrawWorld
virtual void debugDrawWorld()
Definition: btSoftMultiBodyDynamicsWorld.cpp:158
btBroadphaseRayCallback::m_lambda_max
btScalar m_lambda_max
Definition: btBroadphaseInterface.h:41
btSoftSingleRayCallback::m_rayToWorld
btVector3 m_rayToWorld
Definition: btSoftMultiBodyDynamicsWorld.cpp:190
btCollisionWorld::serializeCollisionObjects
void serializeCollisionObjects(btSerializer *serializer)
Definition: btCollisionWorld.cpp:1609
btIDebugDraw::DBG_DrawAabb
Definition: btIDebugDraw.h:60
btSoftBody::sRayCast::feature
eFeature::_ feature
soft body
Definition: btSoftBody.h:166
btSoftSingleRayCallback::m_rayFromWorld
btVector3 m_rayFromWorld
Definition: btSoftMultiBodyDynamicsWorld.cpp:189
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:274
btSoftBody::sRayCast::index
int index
feature type
Definition: btSoftBody.h:167
btSoftMultiBodyDynamicsWorld::m_softBodySolver
btSoftBodySolver * m_softBodySolver
Solver classes that encapsulate multiple soft bodies for solving.
Definition: btSoftMultiBodyDynamicsWorld.h:39
btChunk
Definition: btSerializer.h:51
btSoftBodySolver::checkInitialized
virtual bool checkInitialized()=0
Ensure that this solver is initialized.
btSoftBodySolvers.h
btCollisionObject::serialize
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btCollisionObject.cpp:80
btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:652
btSoftBodyWorldInfo::water_offset
btScalar water_offset
Definition: btSoftBody.h:47
btSoftBody::defaultCollisionHandler
void defaultCollisionHandler(const btCollisionObjectWrapper *pcoWrap)
Definition: btSoftBody.cpp:3205
btSoftMultiBodyDynamicsWorld::getSoftBodyArray
btSoftBodyArray & getSoftBodyArray()
Definition: btSoftMultiBodyDynamicsWorld.h:84
btSoftMultiBodyDynamicsWorld::solveSoftBodiesConstraints
void solveSoftBodiesConstraints(btScalar timeStep)
Definition: btSoftMultiBodyDynamicsWorld.cpp:114
btSoftMultiBodyDynamicsWorld::addSoftBody
void addSoftBody(btSoftBody *body, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
Definition: btSoftMultiBodyDynamicsWorld.cpp:128
btSoftMultiBodyDynamicsWorld
Definition: btSoftMultiBodyDynamicsWorld.h:29
btCollisionWorld::addCollisionObject
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
Definition: btCollisionWorld.cpp:111
btBroadphaseProxy::m_aabbMax
btVector3 m_aabbMax
Definition: btBroadphaseProxy.h:110
btSerializer::startSerialization
virtual void startSerialization()=0
btCollisionWorld::LocalShapeInfo::m_triangleIndex
int m_triangleIndex
Definition: btCollisionWorld.h:177
btTransform::setIdentity
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:172
btAssert
#define btAssert(x)
Definition: btScalar.h:131
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
Definition: btCollisionConfiguration.h:26
btSoftMultiBodyDynamicsWorld::m_sbi
btSoftBodyWorldInfo m_sbi
Definition: btSoftMultiBodyDynamicsWorld.h:37
btSoftBodyWorldInfo::m_dispatcher
btDispatcher * m_dispatcher
Definition: btSoftBody.h:51
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:27
btSoftMultiBodyDynamicsWorld::rayTestSingle
static void rayTestSingle(const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, RayResultCallback &resultCallback)
rayTestSingle performs a raycast call and calls the resultCallback.
Definition: btSoftMultiBodyDynamicsWorld.cpp:283
btSoftBody::sRayCast::fraction
btScalar fraction
feature index
Definition: btSoftBody.h:168
BT_SOFTBODY_CODE
#define BT_SOFTBODY_CODE
Definition: btSerializer.h:118
btCollisionWorld::RayResultCallback
RayResultCallback is used to report new raycast results.
Definition: btCollisionWorld.h:204
btDefaultSoftBodySolver.h
btDiscreteDynamicsWorld::removeCollisionObject
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
Definition: btDiscreteDynamicsWorld.cpp:546
btSoftMultiBodyDynamicsWorld::rayTest
virtual void rayTest(const btVector3 &rayFromWorld, const btVector3 &rayToWorld, RayResultCallback &resultCallback) const
rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback This ...
Definition: btSoftMultiBodyDynamicsWorld.cpp:264
btSoftMultiBodyDynamicsWorld::serialize
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see B...
Definition: btSoftMultiBodyDynamicsWorld.cpp:351
btSoftBodyWorldInfo::water_normal
btVector3 water_normal
Definition: btSoftBody.h:49
btSoftBodyHelpers::DrawFaceTree
static void DrawFaceTree(btSoftBody *psb, btIDebugDraw *idraw, int mindepth=0, int maxdepth=-1)
Definition: btSoftBodyHelpers.cpp:468
btCollisionWorld::RayResultCallback::m_closestHitFraction
btScalar m_closestHitFraction
Definition: btCollisionWorld.h:206
btSoftBody::rayTest
bool rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, sRayCast &results)
Ray casting using rayFrom and rayTo in worldspace, (not direction!)
Definition: btSoftBody.cpp:1699
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...
btSerializer
Definition: btSerializer.h:68
btVector3::normalize
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
Definition: btVector3.h:309
btSoftSingleRayCallback::m_resultCallback
btCollisionWorld::RayResultCallback & m_resultCallback
Definition: btSoftMultiBodyDynamicsWorld.cpp:196
btCollisionWorld::getNumCollisionObjects
int getNumCollisionObjects() const
Definition: btCollisionWorld.h:440
btSoftBodyHelpers::Draw
static void Draw(btSoftBody *psb, btIDebugDraw *idraw, int drawflags=fDrawFlags::Std)
Definition: btSoftBodyHelpers.cpp:161
btSoftMultiBodyDynamicsWorld::internalSingleStepSimulation
virtual void internalSingleStepSimulation(btScalar timeStep)
Definition: btSoftMultiBodyDynamicsWorld.cpp:83
btSoftBodyWorldInfo::m_sparsesdf
btSparseSdf< 3 > m_sparsesdf
Definition: btSoftBody.h:53
btSoftBody::solveClusters
static void solveClusters(const btAlignedObjectArray< btSoftBody *> &bodies)
Definition: btSoftBody.cpp:1961
btSoftBody::sRayCast
Definition: btSoftBody.h:163
btCollisionWorld::RayResultCallback::addSingleResult
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)=0
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:372
btSoftBody.h
btSoftBodySolver::optimize
virtual void optimize(btAlignedObjectArray< btSoftBody * > &softBodies, bool forceUpdate=false)=0
Optimize soft bodies in this solver.
btIDebugDraw::DBG_DrawWireframe
Definition: btIDebugDraw.h:59
btDefaultSoftBodySolver
Definition: btDefaultSoftBodySolver.h:24
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:117
btCollisionObject::getBroadphaseHandle
btBroadphaseProxy * getBroadphaseHandle()
Definition: btCollisionObject.h:389
btSoftBodySolver::predictMotion
virtual void predictMotion(float solverdt)=0
Predict motion of soft bodies into next timestep.
btSoftBodySolver::solveConstraints
virtual void solveConstraints(float solverdt)=0
Solve constraints for a set of soft bodies.
btSoftMultiBodyDynamicsWorld::m_ownsSolver
bool m_ownsSolver
Definition: btSoftMultiBodyDynamicsWorld.h:40
btSoftMultiBodyDynamicsWorld::m_softBodies
btSoftBodyArray m_softBodies
Definition: btSoftMultiBodyDynamicsWorld.h:32
btCollisionWorld::m_debugDrawer
btIDebugDraw * m_debugDrawer
Definition: btCollisionWorld.h:102
btSoftSingleRayCallback::btSoftSingleRayCallback
btSoftSingleRayCallback(const btVector3 &rayFromWorld, const btVector3 &rayToWorld, const btSoftMultiBodyDynamicsWorld *world, btCollisionWorld::RayResultCallback &resultCallback)
Definition: btSoftMultiBodyDynamicsWorld.cpp:198
btCollisionWorld::getDebugDrawer
virtual btIDebugDraw * getDebugDrawer()
Definition: btCollisionWorld.h:162
btSoftSingleRayCallback::m_world
const btSoftMultiBodyDynamicsWorld * m_world
Definition: btSoftMultiBodyDynamicsWorld.cpp:195
btDiscreteDynamicsWorld::debugDrawWorld
virtual void debugDrawWorld()
Definition: btDiscreteDynamicsWorld.cpp:283
btSoftBody::upcast
static const btSoftBody * upcast(const btCollisionObject *colObj)
Definition: btSoftBody.h:936
btSoftBodySolver::~btSoftBodySolver
virtual ~btSoftBodySolver()
Definition: btSoftBodySolvers.h:59
btCollisionWorld::RayResultCallback::needsCollision
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
Definition: btCollisionWorld.h:231
btVector3::dot
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition: btVector3.h:235
btSoftSingleRayCallback::m_rayFromTrans
btTransform m_rayFromTrans
Definition: btSoftMultiBodyDynamicsWorld.cpp:191
btDiscreteDynamicsWorld::predictUnconstraintMotion
virtual void predictUnconstraintMotion(btScalar timeStep)
Definition: btDiscreteDynamicsWorld.cpp:1143
btSoftMultiBodyDynamicsWorld::~btSoftMultiBodyDynamicsWorld
virtual ~btSoftMultiBodyDynamicsWorld()
Definition: btSoftMultiBodyDynamicsWorld.cpp:65
btBroadphaseRayCallback
Definition: btBroadphaseInterface.h:36
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:48
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:49
btBroadphaseProxy::m_clientObject
void * m_clientObject
Definition: btBroadphaseProxy.h:103
btSoftMultiBodyDynamicsWorld::btSoftMultiBodyDynamicsWorld
btSoftMultiBodyDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btMultiBodyConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration, btSoftBodySolver *softBodySolver=0)
Definition: btSoftMultiBodyDynamicsWorld.cpp:28
btMultiBodyConstraintSolver
Definition: btMultiBodyConstraintSolver.h:30
btCollisionWorld::rayTestSingle
static void rayTestSingle(const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, RayResultCallback &resultCallback)
rayTestSingle performs a raycast call and calls the resultCallback.
Definition: btCollisionWorld.cpp:280
btSoftSingleRayCallback::m_hitNormal
btVector3 m_hitNormal
Definition: btSoftMultiBodyDynamicsWorld.cpp:193
btCollisionWorld::LocalShapeInfo
LocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is avai...
Definition: btCollisionWorld.h:174
btCollisionWorld::removeCollisionObject
virtual void removeCollisionObject(btCollisionObject *collisionObject)
Definition: btCollisionWorld.cpp:237
btSoftSingleRayCallback
Definition: btSoftMultiBodyDynamicsWorld.cpp:187
btCollisionObject::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btCollisionObject.h:672
btCollisionWorld::LocalShapeInfo::m_shapePart
int m_shapePart
Definition: btCollisionWorld.h:176
btBroadphaseInterface
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
Definition: btBroadphaseInterface.h:55
btSoftMultiBodyDynamicsWorld::m_drawFaceTree
bool m_drawFaceTree
Definition: btSoftMultiBodyDynamicsWorld.h:35
btBroadphaseProxy
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
Definition: btBroadphaseProxy.h:85
btSoftBodyHelpers::DrawNodeTree
static void DrawNodeTree(btSoftBody *psb, btIDebugDraw *idraw, int mindepth=0, int maxdepth=-1)
Definition: btSoftBodyHelpers.cpp:459
btSoftBodySolver
Definition: btSoftBodySolvers.h:30
fDrawFlags::Std
Definition: btSoftBodyHelpers.h:41
btSoftMultiBodyDynamicsWorld::m_drawFlags
int m_drawFlags
Definition: btSoftMultiBodyDynamicsWorld.h:33
btSoftBodyHelpers::DrawClusterTree
static void DrawClusterTree(btSoftBody *psb, btIDebugDraw *idraw, int mindepth=0, int maxdepth=-1)
Definition: btSoftBodyHelpers.cpp:477
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
btSoftBodySolver::updateSoftBodies
virtual void updateSoftBodies()=0
Perform necessary per-step updates of soft bodies such as recomputing normals and bounding boxes...
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:155
BT_PROFILE
#define BT_PROFILE(name)
Definition: btQuickprof.h:215
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btSerializer::finalizeChunk
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
btBroadphaseProxy::m_aabbMin
btVector3 m_aabbMin
Definition: btBroadphaseProxy.h:109
btSoftSingleRayCallback::process
virtual bool process(const btBroadphaseProxy *proxy)
Definition: btSoftMultiBodyDynamicsWorld.cpp:226
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:505
btBroadphaseRayCallback::m_signs
unsigned int m_signs[3]
Definition: btBroadphaseInterface.h:40
btSoftMultiBodyDynamicsWorld::serializeSoftBodies
void serializeSoftBodies(btSerializer *serializer)
Definition: btSoftMultiBodyDynamicsWorld.cpp:333
btQuickprof.h
btCollisionShape::isSoftBody
bool isSoftBody() const
Definition: btCollisionShape.h:90
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition: btCollisionObject.h:367
btIDebugDraw::getDebugMode
virtual int getDebugMode() const =0
btCollisionWorld::m_collisionObjects
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
Definition: btCollisionWorld.h:94
btSoftBody::setSoftBodySolver
void setSoftBodySolver(btSoftBodySolver *softBodySolver)
Definition: btSoftBody.h:910
btBroadphaseRayCallback::m_rayDirectionInverse
btVector3 m_rayDirectionInverse
added some cached data to accelerate ray-AABB tests
Definition: btBroadphaseInterface.h:39
btSoftBodySolver::getTimeScale
float getTimeScale()
Return the timescale that the simulation is using.
Definition: btSoftBodySolvers.h:118
btSoftBodyWorldInfo::water_density
btScalar water_density
Definition: btSoftBody.h:46
btCollisionWorld::m_broadphasePairCache
btBroadphaseInterface * m_broadphasePairCache
Definition: btCollisionWorld.h:100
btSoftMultiBodyDynamicsWorld::m_drawNodeTree
bool m_drawNodeTree
Definition: btSoftMultiBodyDynamicsWorld.h:34
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:47
btSoftBodyHelpers.h
btSoftBodyWorldInfo::m_broadphase
btBroadphaseInterface * m_broadphase
Definition: btSoftBody.h:50
btSoftBodyWorldInfo::air_density
btScalar air_density
Definition: btSoftBody.h:45
btDiscreteDynamicsWorld::serializeRigidBodies
void serializeRigidBodies(btSerializer *serializer)
Definition: btDiscreteDynamicsWorld.cpp:1443
btSoftBodyWorldInfo::m_gravity
btVector3 m_gravity
Definition: btSoftBody.h:52
btSoftBody
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition: btSoftBody.h:71
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:75
btSoftBody::eFeature::Face
Definition: btSoftBody.h:123
btChunk::m_oldPtr
void * m_oldPtr
Definition: btSerializer.h:56
btSoftSingleRayCallback::m_rayToTrans
btTransform m_rayToTrans
Definition: btSoftMultiBodyDynamicsWorld.cpp:192
btSoftMultiBodyDynamicsWorld::removeSoftBody
void removeSoftBody(btSoftBody *body)
Definition: btSoftMultiBodyDynamicsWorld.cpp:142
btSerializer::allocate
virtual btChunk * allocate(size_t size, int numElements)=0
btBroadphaseInterface::rayTest
virtual void rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, btBroadphaseRayCallback &rayCallback, const btVector3 &aabbMin=btVector3(0, 0, 0), const btVector3 &aabbMax=btVector3(0, 0, 0))=0
btMultiBodyDynamicsWorld
The btMultiBodyDynamicsWorld adds Featherstone multi body dynamics to Bullet This implementation is s...
Definition: btMultiBodyDynamicsWorld.h:30
btSoftMultiBodyDynamicsWorld::predictUnconstraintMotion
virtual void predictUnconstraintMotion(btScalar timeStep)
Definition: btSoftMultiBodyDynamicsWorld.cpp:74
btCollisionWorld::LocalRayResult
Definition: btCollisionWorld.h:183
btSoftBodyHelpers::DrawFrame
static void DrawFrame(btSoftBody *psb, btIDebugDraw *idraw)
Definition: btSoftBodyHelpers.cpp:648
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:228
btSoftMultiBodyDynamicsWorld::m_drawClusterTree
bool m_drawClusterTree
Definition: btSoftMultiBodyDynamicsWorld.h:36
btSparseSdf::Reset
void Reset()
Definition: btSparseSDF.h:90
btSparseSdf::Initialize
void Initialize(int hashsize=2383, int clampCells=256 *1024)
Definition: btSparseSDF.h:81
btSerializer.h
btSoftBody::m_faces
tFaceArray m_faces
Definition: btSoftBody.h:661