Bullet Collision Detection & Physics Library: btSoftBody.h Source File

Bullet Collision Detection & Physics Library

btSoftBody.h
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*/
16
17#ifndef _BT_SOFT_BODY_H
18#define _BT_SOFT_BODY_H
19
20#include "LinearMath/btAlignedObjectArray.h"
21#include "LinearMath/btTransform.h"
22#include "LinearMath/btIDebugDraw.h"
23#include "LinearMath/btVector3.h"
24#include "BulletDynamics/Dynamics/btRigidBody.h"
25
26#include "BulletCollision/CollisionShapes/btConcaveShape.h"
27#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
28#include "btSparseSDF.h"
29#include "BulletCollision/BroadphaseCollision/btDbvt.h"
30#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
31#include "BulletDynamics/Featherstone/btMultiBodyConstraint.h"
32//#ifdef BT_USE_DOUBLE_PRECISION
33//#define btRigidBodyData btRigidBodyDoubleData
34//#define btRigidBodyDataName "btRigidBodyDoubleData"
35//#else
36#define btSoftBodyData btSoftBodyFloatData
37#define btSoftBodyDataName "btSoftBodyFloatData"
38 static const btScalar OVERLAP_REDUCTION_FACTOR = 0.1;
39 static unsigned long seed = 243703;
40//#endif //BT_USE_DOUBLE_PRECISION
41
42class btBroadphaseInterface;
43class btDispatcher;
44class btSoftBodySolver;
45
46/* btSoftBodyWorldInfo */
47 struct btSoftBodyWorldInfo
48{
49 btScalar air_density;
50 btScalar water_density;
51 btScalar water_offset;
52 btScalar m_maxDisplacement;
53 btVector3 water_normal;
54 btBroadphaseInterface* m_broadphase;
55 btDispatcher* m_dispatcher;
56 btVector3 m_gravity;
57 btSparseSdf<3> m_sparsesdf;
58
59 btSoftBodyWorldInfo()
60 : air_density((btScalar)1.2),
61 water_density(0),
62 water_offset(0),
63 m_maxDisplacement(1000.f), //avoid soft body from 'exploding' so use some upper threshold of maximum motion that a node can travel per frame
64 water_normal(0, 0, 0),
65 m_broadphase(0),
66 m_dispatcher(0),
67 m_gravity(0, -10, 0)
68 {
69 }
70};
71
74 class btSoftBody : public btCollisionObject
75{
76public:
77 btAlignedObjectArray<const class btCollisionObject*> m_collisionDisabledObjects;
78
79 // The solver object that handles this soft body
80 btSoftBodySolver* m_softBodySolver;
81
82 //
83 // Enumerations
84 //
85
87 struct eAeroModel
88 {
89 enum _
90 {
91 V_Point,
92 V_TwoSided,
93 V_TwoSidedLiftDrag,
94 V_OneSided,
95 F_TwoSided,
96 F_TwoSidedLiftDrag,
97 F_OneSided,
98 END
99 };
100 };
101
103 struct eVSolver
104 {
105 enum _
106 {
107 Linear,
108 END
109 };
110 };
111
113 struct ePSolver
114 {
115 enum _
116 {
117 Linear,
118 Anchors,
119 RContacts,
120 SContacts,
121 END
122 };
123 };
124
126 struct eSolverPresets
127 {
128 enum _
129 {
130 Positions,
131 Velocities,
132 Default = Positions,
133 END
134 };
135 };
136
138 struct eFeature
139 {
140 enum _
141 {
142 None,
143 Node,
144 Link,
145 Face,
146 Tetra,
147 END
148 };
149 };
150
151 typedef btAlignedObjectArray<eVSolver::_> tVSolverArray;
152 typedef btAlignedObjectArray<ePSolver::_> tPSolverArray;
153
154 //
155 // Flags
156 //
157
159 struct fCollision
160 {
161 enum _
162 {
163 RVSmask = 0x000f,
164 SDF_RS = 0x0001,
165 CL_RS = 0x0002,
166 SDF_RD = 0x0004,
167
168 SVSmask = 0x00f0,
169 VF_SS = 0x0010,
170 CL_SS = 0x0020,
171 CL_SELF = 0x0040,
172 VF_DD = 0x0080,
173
174 RVDFmask = 0x0f00,
175 SDF_RDF = 0x0100,
176 SDF_MDF = 0x0200,
177 SDF_RDN = 0x0400,
178 /* presets */
179 Default = SDF_RS,
180 END
181 };
182 };
183
185 struct fMaterial
186 {
187 enum _
188 {
189 DebugDraw = 0x0001,
190 /* presets */
191 Default = DebugDraw,
192 END
193 };
194 };
195
196 //
197 // API Types
198 //
199
200 /* sRayCast */
201 struct sRayCast
202 {
203 btSoftBody* body;
204 eFeature::_ feature;
205 int index;
206 btScalar fraction;
207 };
208
209 /* ImplicitFn */
210 struct ImplicitFn
211 {
212 virtual ~ImplicitFn() {}
213 virtual btScalar Eval(const btVector3& x) = 0;
214 };
215
216 //
217 // Internal types
218 //
219
220 typedef btAlignedObjectArray<btScalar> tScalarArray;
221 typedef btAlignedObjectArray<btVector3> tVector3Array;
222
223 /* sCti is Softbody contact info */
224 struct sCti
225 {
226 const btCollisionObject* m_colObj; /* Rigid body */
227 btVector3 m_normal; /* Outward normal */
228 btScalar m_offset; /* Offset from origin */
229 btVector3 m_bary; /* Barycentric weights for faces */
230 };
231
232 /* sMedium */
233 struct sMedium
234 {
235 btVector3 m_velocity; /* Velocity */
236 btScalar m_pressure; /* Pressure */
237 btScalar m_density; /* Density */
238 };
239
240 /* Base type */
241 struct Element
242 {
243 void* m_tag; // User data
244 Element() : m_tag(0) {}
245 };
246 /* Material */
247 struct Material : Element
248 {
249 btScalar m_kLST; // Linear stiffness coefficient [0,1]
250 btScalar m_kAST; // Area/Angular stiffness coefficient [0,1]
251 btScalar m_kVST; // Volume stiffness coefficient [0,1]
252 int m_flags; // Flags
253 };
254
255 /* Feature */
256 struct Feature : Element
257 {
258 Material* m_material; // Material
259 };
260 /* Node */
261 struct RenderNode
262 {
263 btVector3 m_x;
264 btVector3 m_uv1;
265 btVector3 m_normal;
266 };
267 struct Node : Feature
268 {
269 btVector3 m_x; // Position
270 btVector3 m_q; // Previous step position/Test position
271 btVector3 m_v; // Velocity
272 btVector3 m_vn; // Previous step velocity
273 btVector3 m_f; // Force accumulator
274 btVector3 m_n; // Normal
275 btScalar m_im; // 1/mass
276 btScalar m_area; // Area
277 btDbvtNode* m_leaf; // Leaf data
278 int m_constrained; // depth of penetration
279 int m_battach : 1; // Attached
280 int index;
281 btVector3 m_splitv; // velocity associated with split impulse
282 btMatrix3x3 m_effectiveMass; // effective mass in contact
283 btMatrix3x3 m_effectiveMass_inv; // inverse of effective mass
284 };
285 /* Link */
286 ATTRIBUTE_ALIGNED16(struct)
287 Link : Feature
288 {
289 btVector3 m_c3; // gradient
290 Node* m_n[2]; // Node pointers
291 btScalar m_rl; // Rest length
292 int m_bbending : 1; // Bending link
293 btScalar m_c0; // (ima+imb)*kLST
294 btScalar m_c1; // rl^2
295 btScalar m_c2; // |gradient|^2/c0
296
297 BT_DECLARE_ALIGNED_ALLOCATOR();
298 };
299 struct RenderFace
300 {
301 RenderNode* m_n[3]; // Node pointers
302 };
303
304 /* Face */
305 struct Face : Feature
306 {
307 Node* m_n[3]; // Node pointers
308 btVector3 m_normal; // Normal
309 btScalar m_ra; // Rest area
310 btDbvtNode* m_leaf; // Leaf data
311 btVector4 m_pcontact; // barycentric weights of the persistent contact
312 btVector3 m_n0, m_n1, m_vn;
313 int m_index;
314 };
315 /* Tetra */
316 struct Tetra : Feature
317 {
318 Node* m_n[4]; // Node pointers
319 btScalar m_rv; // Rest volume
320 btDbvtNode* m_leaf; // Leaf data
321 btVector3 m_c0[4]; // gradients
322 btScalar m_c1; // (4*kVST)/(im0+im1+im2+im3)
323 btScalar m_c2; // m_c1/sum(|g0..3|^2)
324 btMatrix3x3 m_Dm_inverse; // rest Dm^-1
325 btMatrix3x3 m_F;
326 btScalar m_element_measure;
327 btVector4 m_P_inv[3]; // first three columns of P_inv matrix
328 };
329
330 /* TetraScratch */
331 struct TetraScratch
332 {
333 btMatrix3x3 m_F; // deformation gradient F
334 btScalar m_trace; // trace of F^T * F
335 btScalar m_J; // det(F)
336 btMatrix3x3 m_cofF; // cofactor of F
337 btMatrix3x3 m_corotation; // corotatio of the tetra
338 };
339
340 /* RContact */
341 struct RContact
342 {
343 sCti m_cti; // Contact infos
344 Node* m_node; // Owner node
345 btMatrix3x3 m_c0; // Impulse matrix
346 btVector3 m_c1; // Relative anchor
347 btScalar m_c2; // ima*dt
348 btScalar m_c3; // Friction
349 btScalar m_c4; // Hardness
350
351 // jacobians and unit impulse responses for multibody
352 btMultiBodyJacobianData jacobianData_normal;
353 btMultiBodyJacobianData jacobianData_t1;
354 btMultiBodyJacobianData jacobianData_t2;
355 btVector3 t1;
356 btVector3 t2;
357 };
358
359 class DeformableRigidContact
360 {
361 public:
362 sCti m_cti; // Contact infos
363 btMatrix3x3 m_c0; // Impulse matrix
364 btVector3 m_c1; // Relative anchor
365 btScalar m_c2; // inverse mass of node/face
366 btScalar m_c3; // Friction
367 btScalar m_c4; // Hardness
368 btMatrix3x3 m_c5; // inverse effective mass
369
370 // jacobians and unit impulse responses for multibody
371 btMultiBodyJacobianData jacobianData_normal;
372 btMultiBodyJacobianData jacobianData_t1;
373 btMultiBodyJacobianData jacobianData_t2;
374 btVector3 t1;
375 btVector3 t2;
376 };
377
378 class DeformableNodeRigidContact : public DeformableRigidContact
379 {
380 public:
381 Node* m_node; // Owner node
382 };
383
384 class DeformableNodeRigidAnchor : public DeformableNodeRigidContact
385 {
386 public:
387 btVector3 m_local; // Anchor position in body space
388 };
389
390 class DeformableFaceRigidContact : public DeformableRigidContact
391 {
392 public:
393 Face* m_face; // Owner face
394 btVector3 m_contactPoint; // Contact point
395 btVector3 m_bary; // Barycentric weights
396 btVector3 m_weights; // v_contactPoint * m_weights[i] = m_face->m_node[i]->m_v;
397 };
398
399 struct DeformableFaceNodeContact
400 {
401 Node* m_node; // Node
402 Face* m_face; // Face
403 btVector3 m_bary; // Barycentric weights
404 btVector3 m_weights; // v_contactPoint * m_weights[i] = m_face->m_node[i]->m_v;
405 btVector3 m_normal; // Normal
406 btScalar m_margin; // Margin
407 btScalar m_friction; // Friction
408 btScalar m_imf; // inverse mass of the face at contact point
409 btScalar m_c0; // scale of the impulse matrix;
410 const btCollisionObject* m_colObj; // Collision object to collide with.
411 };
412
413 /* SContact */
414 struct SContact
415 {
416 Node* m_node; // Node
417 Face* m_face; // Face
418 btVector3 m_weights; // Weigths
419 btVector3 m_normal; // Normal
420 btScalar m_margin; // Margin
421 btScalar m_friction; // Friction
422 btScalar m_cfm[2]; // Constraint force mixing
423 };
424 /* Anchor */
425 struct Anchor
426 {
427 Node* m_node; // Node pointer
428 btVector3 m_local; // Anchor position in body space
429 btRigidBody* m_body; // Body
430 btScalar m_influence;
431 btMatrix3x3 m_c0; // Impulse matrix
432 btVector3 m_c1; // Relative anchor
433 btScalar m_c2; // ima*dt
434 };
435 /* Note */
436 struct Note : Element
437 {
438 const char* m_text; // Text
439 btVector3 m_offset; // Offset
440 int m_rank; // Rank
441 Node* m_nodes[4]; // Nodes
442 btScalar m_coords[4]; // Coordinates
443 };
444 /* Pose */
445 struct Pose
446 {
447 bool m_bvolume; // Is valid
448 bool m_bframe; // Is frame
449 btScalar m_volume; // Rest volume
450 tVector3Array m_pos; // Reference positions
451 tScalarArray m_wgh; // Weights
452 btVector3 m_com; // COM
453 btMatrix3x3 m_rot; // Rotation
454 btMatrix3x3 m_scl; // Scale
455 btMatrix3x3 m_aqq; // Base scaling
456 };
457 /* Cluster */
458 struct Cluster
459 {
460 tScalarArray m_masses;
461 btAlignedObjectArray<Node*> m_nodes;
462 tVector3Array m_framerefs;
463 btTransform m_framexform;
464 btScalar m_idmass;
465 btScalar m_imass;
466 btMatrix3x3 m_locii;
467 btMatrix3x3 m_invwi;
468 btVector3 m_com;
469 btVector3 m_vimpulses[2];
470 btVector3 m_dimpulses[2];
471 int m_nvimpulses;
472 int m_ndimpulses;
473 btVector3 m_lv;
474 btVector3 m_av;
475 btDbvtNode* m_leaf;
476 btScalar m_ndamping; /* Node damping */
477 btScalar m_ldamping; /* Linear damping */
478 btScalar m_adamping; /* Angular damping */
479 btScalar m_matching;
480 btScalar m_maxSelfCollisionImpulse;
481 btScalar m_selfCollisionImpulseFactor;
482 bool m_containsAnchor;
483 bool m_collide;
484 int m_clusterIndex;
485 Cluster() : m_leaf(0), m_ndamping(0), m_ldamping(0), m_adamping(0), m_matching(0), m_maxSelfCollisionImpulse(100.f), m_selfCollisionImpulseFactor(0.01f), m_containsAnchor(false)
486 {
487 }
488 };
489 /* Impulse */
490 struct Impulse
491 {
492 btVector3 m_velocity;
493 btVector3 m_drift;
494 int m_asVelocity : 1;
495 int m_asDrift : 1;
496 Impulse() : m_velocity(0, 0, 0), m_drift(0, 0, 0), m_asVelocity(0), m_asDrift(0) {}
497 Impulse operator-() const
498 {
499 Impulse i = *this;
500 i.m_velocity = -i.m_velocity;
501 i.m_drift = -i.m_drift;
502 return (i);
503 }
504 Impulse operator*(btScalar x) const
505 {
506 Impulse i = *this;
507 i.m_velocity *= x;
508 i.m_drift *= x;
509 return (i);
510 }
511 };
512 /* Body */
513 struct Body
514 {
515 Cluster* m_soft;
516 btRigidBody* m_rigid;
517 const btCollisionObject* m_collisionObject;
518
519 Body() : m_soft(0), m_rigid(0), m_collisionObject(0) {}
520 Body(Cluster* p) : m_soft(p), m_rigid(0), m_collisionObject(0) {}
521 Body(const btCollisionObject* colObj) : m_soft(0), m_collisionObject(colObj)
522 {
523 m_rigid = (btRigidBody*)btRigidBody::upcast(m_collisionObject);
524 }
525
526 void activate() const
527 {
528 if (m_rigid)
529 m_rigid->activate();
530 if (m_collisionObject)
531 m_collisionObject->activate();
532 }
533 const btMatrix3x3& invWorldInertia() const
534 {
535 static const btMatrix3x3 iwi(0, 0, 0, 0, 0, 0, 0, 0, 0);
536 if (m_rigid) return (m_rigid->getInvInertiaTensorWorld());
537 if (m_soft) return (m_soft->m_invwi);
538 return (iwi);
539 }
540 btScalar invMass() const
541 {
542 if (m_rigid) return (m_rigid->getInvMass());
543 if (m_soft) return (m_soft->m_imass);
544 return (0);
545 }
546 const btTransform& xform() const
547 {
548 static const btTransform identity = btTransform::getIdentity();
549 if (m_collisionObject) return (m_collisionObject->getWorldTransform());
550 if (m_soft) return (m_soft->m_framexform);
551 return (identity);
552 }
553 btVector3 linearVelocity() const
554 {
555 if (m_rigid) return (m_rigid->getLinearVelocity());
556 if (m_soft) return (m_soft->m_lv);
557 return (btVector3(0, 0, 0));
558 }
559 btVector3 angularVelocity(const btVector3& rpos) const
560 {
561 if (m_rigid) return (btCross(m_rigid->getAngularVelocity(), rpos));
562 if (m_soft) return (btCross(m_soft->m_av, rpos));
563 return (btVector3(0, 0, 0));
564 }
565 btVector3 angularVelocity() const
566 {
567 if (m_rigid) return (m_rigid->getAngularVelocity());
568 if (m_soft) return (m_soft->m_av);
569 return (btVector3(0, 0, 0));
570 }
571 btVector3 velocity(const btVector3& rpos) const
572 {
573 return (linearVelocity() + angularVelocity(rpos));
574 }
575 void applyVImpulse(const btVector3& impulse, const btVector3& rpos) const
576 {
577 if (m_rigid) m_rigid->applyImpulse(impulse, rpos);
578 if (m_soft) btSoftBody::clusterVImpulse(m_soft, rpos, impulse);
579 }
580 void applyDImpulse(const btVector3& impulse, const btVector3& rpos) const
581 {
582 if (m_rigid) m_rigid->applyImpulse(impulse, rpos);
583 if (m_soft) btSoftBody::clusterDImpulse(m_soft, rpos, impulse);
584 }
585 void applyImpulse(const Impulse& impulse, const btVector3& rpos) const
586 {
587 if (impulse.m_asVelocity)
588 {
589 // printf("impulse.m_velocity = %f,%f,%f\n",impulse.m_velocity.getX(),impulse.m_velocity.getY(),impulse.m_velocity.getZ());
590 applyVImpulse(impulse.m_velocity, rpos);
591 }
592 if (impulse.m_asDrift)
593 {
594 // printf("impulse.m_drift = %f,%f,%f\n",impulse.m_drift.getX(),impulse.m_drift.getY(),impulse.m_drift.getZ());
595 applyDImpulse(impulse.m_drift, rpos);
596 }
597 }
598 void applyVAImpulse(const btVector3& impulse) const
599 {
600 if (m_rigid) m_rigid->applyTorqueImpulse(impulse);
601 if (m_soft) btSoftBody::clusterVAImpulse(m_soft, impulse);
602 }
603 void applyDAImpulse(const btVector3& impulse) const
604 {
605 if (m_rigid) m_rigid->applyTorqueImpulse(impulse);
606 if (m_soft) btSoftBody::clusterDAImpulse(m_soft, impulse);
607 }
608 void applyAImpulse(const Impulse& impulse) const
609 {
610 if (impulse.m_asVelocity) applyVAImpulse(impulse.m_velocity);
611 if (impulse.m_asDrift) applyDAImpulse(impulse.m_drift);
612 }
613 void applyDCImpulse(const btVector3& impulse) const
614 {
615 if (m_rigid) m_rigid->applyCentralImpulse(impulse);
616 if (m_soft) btSoftBody::clusterDCImpulse(m_soft, impulse);
617 }
618 };
619 /* Joint */
620 struct Joint
621 {
622 struct eType
623 {
624 enum _
625 {
626 Linear = 0,
627 Angular,
628 Contact
629 };
630 };
631 struct Specs
632 {
633 Specs() : erp(1), cfm(1), split(1) {}
634 btScalar erp;
635 btScalar cfm;
636 btScalar split;
637 };
638 Body m_bodies[2];
639 btVector3 m_refs[2];
640 btScalar m_cfm;
641 btScalar m_erp;
642 btScalar m_split;
643 btVector3 m_drift;
644 btVector3 m_sdrift;
645 btMatrix3x3 m_massmatrix;
646 bool m_delete;
647 virtual ~Joint() {}
648 Joint() : m_delete(false) {}
649 virtual void Prepare(btScalar dt, int iterations);
650 virtual void Solve(btScalar dt, btScalar sor) = 0;
651 virtual void Terminate(btScalar dt) = 0;
652 virtual eType::_ Type() const = 0;
653 };
654 /* LJoint */
655 struct LJoint : Joint
656 {
657 struct Specs : Joint::Specs
658 {
659 btVector3 position;
660 };
661 btVector3 m_rpos[2];
662 void Prepare(btScalar dt, int iterations);
663 void Solve(btScalar dt, btScalar sor);
664 void Terminate(btScalar dt);
665 eType::_ Type() const { return (eType::Linear); }
666 };
667 /* AJoint */
668 struct AJoint : Joint
669 {
670 struct IControl
671 {
672 virtual ~IControl() {}
673 virtual void Prepare(AJoint*) {}
674 virtual btScalar Speed(AJoint*, btScalar current) { return (current); }
675 static IControl* Default()
676 {
677 static IControl def;
678 return (&def);
679 }
680 };
681 struct Specs : Joint::Specs
682 {
683 Specs() : icontrol(IControl::Default()) {}
684 btVector3 axis;
685 IControl* icontrol;
686 };
687 btVector3 m_axis[2];
688 IControl* m_icontrol;
689 void Prepare(btScalar dt, int iterations);
690 void Solve(btScalar dt, btScalar sor);
691 void Terminate(btScalar dt);
692 eType::_ Type() const { return (eType::Angular); }
693 };
694 /* CJoint */
695 struct CJoint : Joint
696 {
697 int m_life;
698 int m_maxlife;
699 btVector3 m_rpos[2];
700 btVector3 m_normal;
701 btScalar m_friction;
702 void Prepare(btScalar dt, int iterations);
703 void Solve(btScalar dt, btScalar sor);
704 void Terminate(btScalar dt);
705 eType::_ Type() const { return (eType::Contact); }
706 };
707 /* Config */
708 struct Config
709 {
710 eAeroModel::_ aeromodel; // Aerodynamic model (default: V_Point)
711 btScalar kVCF; // Velocities correction factor (Baumgarte)
712 btScalar kDP; // Damping coefficient [0,1]
713 btScalar kDG; // Drag coefficient [0,+inf]
714 btScalar kLF; // Lift coefficient [0,+inf]
715 btScalar kPR; // Pressure coefficient [-inf,+inf]
716 btScalar kVC; // Volume conversation coefficient [0,+inf]
717 btScalar kDF; // Dynamic friction coefficient [0,1]
718 btScalar kMT; // Pose matching coefficient [0,1]
719 btScalar kCHR; // Rigid contacts hardness [0,1]
720 btScalar kKHR; // Kinetic contacts hardness [0,1]
721 btScalar kSHR; // Soft contacts hardness [0,1]
722 btScalar kAHR; // Anchors hardness [0,1]
723 btScalar kSRHR_CL; // Soft vs rigid hardness [0,1] (cluster only)
724 btScalar kSKHR_CL; // Soft vs kinetic hardness [0,1] (cluster only)
725 btScalar kSSHR_CL; // Soft vs soft hardness [0,1] (cluster only)
726 btScalar kSR_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
727 btScalar kSK_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
728 btScalar kSS_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
729 btScalar maxvolume; // Maximum volume ratio for pose
730 btScalar timescale; // Time scale
731 int viterations; // Velocities solver iterations
732 int piterations; // Positions solver iterations
733 int diterations; // Drift solver iterations
734 int citerations; // Cluster solver iterations
735 int collisions; // Collisions flags
736 tVSolverArray m_vsequence; // Velocity solvers sequence
737 tPSolverArray m_psequence; // Position solvers sequence
738 tPSolverArray m_dsequence; // Drift solvers sequence
739 btScalar drag; // deformable air drag
740 btScalar m_maxStress; // Maximum principle first Piola stress
741 };
742 /* SolverState */
743 struct SolverState
744 {
745 //if you add new variables, always initialize them!
746 SolverState()
747 : sdt(0),
748 isdt(0),
749 velmrg(0),
750 radmrg(0),
751 updmrg(0)
752 {
753 }
754 btScalar sdt; // dt*timescale
755 btScalar isdt; // 1/sdt
756 btScalar velmrg; // velocity margin
757 btScalar radmrg; // radial margin
758 btScalar updmrg; // Update margin
759 };
760
761 struct RayFromToCaster : btDbvt::ICollide
762 {
763 btVector3 m_rayFrom;
764 btVector3 m_rayTo;
765 btVector3 m_rayNormalizedDirection;
766 btScalar m_mint;
767 Face* m_face;
768 int m_tests;
769 RayFromToCaster(const btVector3& rayFrom, const btVector3& rayTo, btScalar mxt);
770 void Process(const btDbvtNode* leaf);
771
772 static /*inline*/ btScalar rayFromToTriangle(const btVector3& rayFrom,
773 const btVector3& rayTo,
774 const btVector3& rayNormalizedDirection,
775 const btVector3& a,
776 const btVector3& b,
777 const btVector3& c,
778 btScalar maxt = SIMD_INFINITY);
779 };
780
781 //
782 // Typedefs
783 //
784
785 typedef void (*psolver_t)(btSoftBody*, btScalar, btScalar);
786 typedef void (*vsolver_t)(btSoftBody*, btScalar);
787 typedef btAlignedObjectArray<Cluster*> tClusterArray;
788 typedef btAlignedObjectArray<Note> tNoteArray;
789 typedef btAlignedObjectArray<Node> tNodeArray;
790 typedef btAlignedObjectArray<RenderNode> tRenderNodeArray;
791 typedef btAlignedObjectArray<btDbvtNode*> tLeafArray;
792 typedef btAlignedObjectArray<Link> tLinkArray;
793 typedef btAlignedObjectArray<Face> tFaceArray;
794 typedef btAlignedObjectArray<RenderFace> tRenderFaceArray;
795 typedef btAlignedObjectArray<Tetra> tTetraArray;
796 typedef btAlignedObjectArray<Anchor> tAnchorArray;
797 typedef btAlignedObjectArray<RContact> tRContactArray;
798 typedef btAlignedObjectArray<SContact> tSContactArray;
799 typedef btAlignedObjectArray<Material*> tMaterialArray;
800 typedef btAlignedObjectArray<Joint*> tJointArray;
801 typedef btAlignedObjectArray<btSoftBody*> tSoftBodyArray;
802 typedef btAlignedObjectArray<btAlignedObjectArray<btScalar> > tDenseMatrix;
803
804 //
805 // Fields
806 //
807
808 Config m_cfg; // Configuration
809 SolverState m_sst; // Solver state
810 Pose m_pose; // Pose
811 void* m_tag; // User data
812 btSoftBodyWorldInfo* m_worldInfo; // World info
813 tNoteArray m_notes; // Notes
814 tNodeArray m_nodes; // Nodes
815 tRenderNodeArray m_renderNodes; // Render Nodes
816 tLinkArray m_links; // Links
817 tFaceArray m_faces; // Faces
818 tRenderFaceArray m_renderFaces; // Faces
819 tTetraArray m_tetras; // Tetras
820 btAlignedObjectArray<TetraScratch> m_tetraScratches;
821 btAlignedObjectArray<TetraScratch> m_tetraScratchesTn;
822 tAnchorArray m_anchors; // Anchors
823 btAlignedObjectArray<DeformableNodeRigidAnchor> m_deformableAnchors;
824 tRContactArray m_rcontacts; // Rigid contacts
825 btAlignedObjectArray<DeformableNodeRigidContact> m_nodeRigidContacts;
826 btAlignedObjectArray<DeformableFaceNodeContact> m_faceNodeContacts;
827 btAlignedObjectArray<DeformableFaceRigidContact> m_faceRigidContacts;
828 btAlignedObjectArray<DeformableFaceNodeContact> m_faceNodeContactsCCD;
829 tSContactArray m_scontacts; // Soft contacts
830 tJointArray m_joints; // Joints
831 tMaterialArray m_materials; // Materials
832 btScalar m_timeacc; // Time accumulator
833 btVector3 m_bounds[2]; // Spatial bounds
834 bool m_bUpdateRtCst; // Update runtime constants
835 btDbvt m_ndbvt; // Nodes tree
836 btDbvt m_fdbvt; // Faces tree
837 btDbvntNode* m_fdbvnt; // Faces tree with normals
838 btDbvt m_cdbvt; // Clusters tree
839 tClusterArray m_clusters; // Clusters
840 btScalar m_dampingCoefficient; // Damping Coefficient
841 btScalar m_sleepingThreshold;
842 btScalar m_maxSpeedSquared;
843 btAlignedObjectArray<btVector3> m_quads; // quadrature points for collision detection
844 btScalar m_repulsionStiffness;
845 btScalar m_gravityFactor;
846 bool m_cacheBarycenter;
847 btAlignedObjectArray<btVector3> m_X; // initial positions
848
849 btAlignedObjectArray<btVector4> m_renderNodesInterpolationWeights;
850 btAlignedObjectArray<btAlignedObjectArray<const btSoftBody::Node*> > m_renderNodesParents;
851 btAlignedObjectArray<btScalar> m_z; // vertical distance used in extrapolation
852 bool m_useSelfCollision;
853 bool m_softSoftCollision;
854
855 btAlignedObjectArray<bool> m_clusterConnectivity; //cluster connectivity, for self-collision
856
857 btVector3 m_windVelocity;
858
859 btScalar m_restLengthScale;
860
861 bool m_reducedModel; // Reduced deformable model flag
862
863 //
864 // Api
865 //
866
867 /* ctor */
868 btSoftBody(btSoftBodyWorldInfo* worldInfo, int node_count, const btVector3* x, const btScalar* m);
869
870 /* ctor */
871 btSoftBody(btSoftBodyWorldInfo* worldInfo);
872
873 void initDefaults();
874
875 /* dtor */
876 virtual ~btSoftBody();
877 /* Check for existing link */
878
879 btAlignedObjectArray<int> m_userIndexMapping;
880
881 btSoftBodyWorldInfo* getWorldInfo()
882 {
883 return m_worldInfo;
884 }
885
886 void setDampingCoefficient(btScalar damping_coeff)
887 {
888 m_dampingCoefficient = damping_coeff;
889 }
890
892 virtual void setCollisionShape(btCollisionShape* collisionShape)
893 {
894 }
895
896 bool checkLink(int node0,
897 int node1) const;
898 bool checkLink(const Node* node0,
899 const Node* node1) const;
900 /* Check for existring face */
901 bool checkFace(int node0,
902 int node1,
903 int node2) const;
904 /* Append material */
905 Material* appendMaterial();
906 /* Append note */
907 void appendNote(const char* text,
908 const btVector3& o,
909 const btVector4& c = btVector4(1, 0, 0, 0),
910 Node* n0 = 0,
911 Node* n1 = 0,
912 Node* n2 = 0,
913 Node* n3 = 0);
914 void appendNote(const char* text,
915 const btVector3& o,
916 Node* feature);
917 void appendNote(const char* text,
918 const btVector3& o,
919 Link* feature);
920 void appendNote(const char* text,
921 const btVector3& o,
922 Face* feature);
923 /* Append node */
924 void appendNode(const btVector3& x, btScalar m);
925 /* Append link */
926 void appendLink(int model = -1, Material* mat = 0);
927 void appendLink(int node0,
928 int node1,
929 Material* mat = 0,
930 bool bcheckexist = false);
931 void appendLink(Node* node0,
932 Node* node1,
933 Material* mat = 0,
934 bool bcheckexist = false);
935 /* Append face */
936 void appendFace(int model = -1, Material* mat = 0);
937 void appendFace(int node0,
938 int node1,
939 int node2,
940 Material* mat = 0);
941 void appendTetra(int model, Material* mat);
942 //
943 void appendTetra(int node0,
944 int node1,
945 int node2,
946 int node3,
947 Material* mat = 0);
948
949 /* Append anchor */
950 void appendDeformableAnchor(int node, btRigidBody* body);
951 void appendDeformableAnchor(int node, btMultiBodyLinkCollider* link);
952 void appendAnchor(int node,
953 btRigidBody* body, bool disableCollisionBetweenLinkedBodies = false, btScalar influence = 1);
954 void appendAnchor(int node, btRigidBody* body, const btVector3& localPivot, bool disableCollisionBetweenLinkedBodies = false, btScalar influence = 1);
955 void removeAnchor(int node);
956 /* Append linear joint */
957 void appendLinearJoint(const LJoint::Specs& specs, Cluster* body0, Body body1);
958 void appendLinearJoint(const LJoint::Specs& specs, Body body = Body());
959 void appendLinearJoint(const LJoint::Specs& specs, btSoftBody* body);
960 /* Append linear joint */
961 void appendAngularJoint(const AJoint::Specs& specs, Cluster* body0, Body body1);
962 void appendAngularJoint(const AJoint::Specs& specs, Body body = Body());
963 void appendAngularJoint(const AJoint::Specs& specs, btSoftBody* body);
964 /* Add force (or gravity) to the entire body */
965 void addForce(const btVector3& force);
966 /* Add force (or gravity) to a node of the body */
967 void addForce(const btVector3& force,
968 int node);
969 /* Add aero force to a node of the body */
970 void addAeroForceToNode(const btVector3& windVelocity, int nodeIndex);
971
972 /* Add aero force to a face of the body */
973 void addAeroForceToFace(const btVector3& windVelocity, int faceIndex);
974
975 /* Add velocity to the entire body */
976 void addVelocity(const btVector3& velocity);
977
978 /* Set velocity for the entire body */
979 void setVelocity(const btVector3& velocity);
980
981 /* Add velocity to a node of the body */
982 void addVelocity(const btVector3& velocity,
983 int node);
984 /* Set mass */
985 void setMass(int node,
986 btScalar mass);
987 /* Get mass */
988 btScalar getMass(int node) const;
989 /* Get total mass */
990 btScalar getTotalMass() const;
991 /* Set total mass (weighted by previous masses) */
992 void setTotalMass(btScalar mass,
993 bool fromfaces = false);
994 /* Set total density */
995 void setTotalDensity(btScalar density);
996 /* Set volume mass (using tetrahedrons) */
997 void setVolumeMass(btScalar mass);
998 /* Set volume density (using tetrahedrons) */
999 void setVolumeDensity(btScalar density);
1000 /* Get the linear velocity of the center of mass */
1001 btVector3 getLinearVelocity();
1002 /* Set the linear velocity of the center of mass */
1003 void setLinearVelocity(const btVector3& linVel);
1004 /* Set the angular velocity of the center of mass */
1005 void setAngularVelocity(const btVector3& angVel);
1006 /* Get best fit rigid transform */
1007 btTransform getRigidTransform();
1008 /* Transform to given pose */
1009 virtual void transformTo(const btTransform& trs);
1010 /* Transform */
1011 virtual void transform(const btTransform& trs);
1012 /* Translate */
1013 virtual void translate(const btVector3& trs);
1014 /* Rotate */
1015 virtual void rotate(const btQuaternion& rot);
1016 /* Scale */
1017 virtual void scale(const btVector3& scl);
1018 /* Get link resting lengths scale */
1019 btScalar getRestLengthScale();
1020 /* Scale resting length of all springs */
1021 void setRestLengthScale(btScalar restLength);
1022 /* Set current state as pose */
1023 void setPose(bool bvolume,
1024 bool bframe);
1025 /* Set current link lengths as resting lengths */
1026 void resetLinkRestLengths();
1027 /* Return the volume */
1028 btScalar getVolume() const;
1029 /* Cluster count */
1030 btVector3 getCenterOfMass() const
1031 {
1032 btVector3 com(0, 0, 0);
1033 for (int i = 0; i < m_nodes.size(); i++)
1034 {
1035 com += (m_nodes[i].m_x * this->getMass(i));
1036 }
1037 com /= this->getTotalMass();
1038 return com;
1039 }
1040 int clusterCount() const;
1041 /* Cluster center of mass */
1042 static btVector3 clusterCom(const Cluster* cluster);
1043 btVector3 clusterCom(int cluster) const;
1044 /* Cluster velocity at rpos */
1045 static btVector3 clusterVelocity(const Cluster* cluster, const btVector3& rpos);
1046 /* Cluster impulse */
1047 static void clusterVImpulse(Cluster* cluster, const btVector3& rpos, const btVector3& impulse);
1048 static void clusterDImpulse(Cluster* cluster, const btVector3& rpos, const btVector3& impulse);
1049 static void clusterImpulse(Cluster* cluster, const btVector3& rpos, const Impulse& impulse);
1050 static void clusterVAImpulse(Cluster* cluster, const btVector3& impulse);
1051 static void clusterDAImpulse(Cluster* cluster, const btVector3& impulse);
1052 static void clusterAImpulse(Cluster* cluster, const Impulse& impulse);
1053 static void clusterDCImpulse(Cluster* cluster, const btVector3& impulse);
1054 /* Generate bending constraints based on distance in the adjency graph */
1055 int generateBendingConstraints(int distance,
1056 Material* mat = 0);
1057 /* Randomize constraints to reduce solver bias */
1058 void randomizeConstraints();
1059
1060 void updateState(const btAlignedObjectArray<btVector3>& qs, const btAlignedObjectArray<btVector3>& vs);
1061
1062 /* Release clusters */
1063 void releaseCluster(int index);
1064 void releaseClusters();
1065 /* Generate clusters (K-mean) */
1068 int generateClusters(int k, int maxiterations = 8192);
1069 /* Refine */
1070 void refine(ImplicitFn* ifn, btScalar accurary, bool cut);
1071 /* CutLink */
1072 bool cutLink(int node0, int node1, btScalar position);
1073 bool cutLink(const Node* node0, const Node* node1, btScalar position);
1074
1076 bool rayTest(const btVector3& rayFrom,
1077 const btVector3& rayTo,
1078 sRayCast& results);
1079 bool rayFaceTest(const btVector3& rayFrom,
1080 const btVector3& rayTo,
1081 sRayCast& results);
1082 int rayFaceTest(const btVector3& rayFrom, const btVector3& rayTo,
1083 btScalar& mint, int& index) const;
1084 /* Solver presets */
1085 void setSolver(eSolverPresets::_ preset);
1086 /* predictMotion */
1087 void predictMotion(btScalar dt);
1088 /* solveConstraints */
1089 void solveConstraints();
1090 /* staticSolve */
1091 void staticSolve(int iterations);
1092 /* solveCommonConstraints */
1093 static void solveCommonConstraints(btSoftBody** bodies, int count, int iterations);
1094 /* solveClusters */
1095 static void solveClusters(const btAlignedObjectArray<btSoftBody*>& bodies);
1096 /* integrateMotion */
1097 void integrateMotion();
1098 /* defaultCollisionHandlers */
1099 void defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap);
1100 void defaultCollisionHandler(btSoftBody* psb);
1101 void setSelfCollision(bool useSelfCollision);
1102 bool useSelfCollision();
1103 void updateDeactivation(btScalar timeStep);
1104 void setZeroVelocity();
1105 bool wantsSleeping();
1106
1107 virtual btMatrix3x3 getImpulseFactor(int n_node)
1108 {
1109 btMatrix3x3 tmp;
1110 tmp.setIdentity();
1111 return tmp;
1112 }
1113
1114 //
1115 // Functionality to deal with new accelerated solvers.
1116 //
1117
1121 void setWindVelocity(const btVector3& velocity);
1122
1126 const btVector3& getWindVelocity();
1127
1128 //
1129 // Set the solver that handles this soft body
1130 // Should not be allowed to get out of sync with reality
1131 // Currently called internally on addition to the world
1132 void setSoftBodySolver(btSoftBodySolver* softBodySolver)
1133 {
1134 m_softBodySolver = softBodySolver;
1135 }
1136
1137 //
1138 // Return the solver that handles this soft body
1139 //
1140 btSoftBodySolver* getSoftBodySolver()
1141 {
1142 return m_softBodySolver;
1143 }
1144
1145 //
1146 // Return the solver that handles this soft body
1147 //
1148 btSoftBodySolver* getSoftBodySolver() const
1149 {
1150 return m_softBodySolver;
1151 }
1152
1153 //
1154 // Cast
1155 //
1156
1157 static const btSoftBody* upcast(const btCollisionObject* colObj)
1158 {
1159 if (colObj->getInternalType() == CO_SOFT_BODY)
1160 return (const btSoftBody*)colObj;
1161 return 0;
1162 }
1163 static btSoftBody* upcast(btCollisionObject* colObj)
1164 {
1165 if (colObj->getInternalType() == CO_SOFT_BODY)
1166 return (btSoftBody*)colObj;
1167 return 0;
1168 }
1169
1170 //
1171 // ::btCollisionObject
1172 //
1173
1174 virtual void getAabb(btVector3& aabbMin, btVector3& aabbMax) const
1175 {
1176 aabbMin = m_bounds[0];
1177 aabbMax = m_bounds[1];
1178 }
1179 //
1180 // Private
1181 //
1182 void pointersToIndices();
1183 void indicesToPointers(const int* map = 0);
1184
1185 int rayTest(const btVector3& rayFrom, const btVector3& rayTo,
1186 btScalar& mint, eFeature::_& feature, int& index, bool bcountonly) const;
1187 void initializeFaceTree();
1188 void rebuildNodeTree();
1189 btVector3 evaluateCom() const;
1190 bool checkDeformableContact(const btCollisionObjectWrapper* colObjWrap, const btVector3& x, btScalar margin, btSoftBody::sCti& cti, bool predict = false) const;
1191 bool checkDeformableFaceContact(const btCollisionObjectWrapper* colObjWrap, Face& f, btVector3& contact_point, btVector3& bary, btScalar margin, btSoftBody::sCti& cti, bool predict = false) const;
1192 bool checkContact(const btCollisionObjectWrapper* colObjWrap, const btVector3& x, btScalar margin, btSoftBody::sCti& cti) const;
1193 void updateNormals();
1194 void updateBounds();
1195 void updatePose();
1196 void updateConstants();
1197 void updateLinkConstants();
1198 void updateArea(bool averageArea = true);
1199 void initializeClusters();
1200 void updateClusters();
1201 void cleanupClusters();
1202 void prepareClusters(int iterations);
1203 void solveClusters(btScalar sor);
1204 void applyClusters(bool drift);
1205 void dampClusters();
1206 void setSpringStiffness(btScalar k);
1207 void setGravityFactor(btScalar gravFactor);
1208 void setCacheBarycenter(bool cacheBarycenter);
1209 void initializeDmInverse();
1210 void updateDeformation();
1211 void advanceDeformation();
1212 void applyForces();
1213 void setMaxStress(btScalar maxStress);
1214 void interpolateRenderMesh();
1215 void setCollisionQuadrature(int N);
1216 static void PSolve_Anchors(btSoftBody* psb, btScalar kst, btScalar ti);
1217 static void PSolve_RContacts(btSoftBody* psb, btScalar kst, btScalar ti);
1218 static void PSolve_SContacts(btSoftBody* psb, btScalar, btScalar ti);
1219 static void PSolve_Links(btSoftBody* psb, btScalar kst, btScalar ti);
1220 static void VSolve_Links(btSoftBody* psb, btScalar kst);
1221 static psolver_t getSolver(ePSolver::_ solver);
1222 static vsolver_t getSolver(eVSolver::_ solver);
1223 void geometricCollisionHandler(btSoftBody* psb);
1224#define SAFE_EPSILON SIMD_EPSILON * 100.0
1225 void updateNode(btDbvtNode* node, bool use_velocity, bool margin)
1226 {
1227 if (node->isleaf())
1228 {
1229 btSoftBody::Node* n = (btSoftBody::Node*)(node->data);
1230 ATTRIBUTE_ALIGNED16(btDbvtVolume)
1231 vol;
1232 btScalar pad = margin ? m_sst.radmrg : SAFE_EPSILON; // use user defined margin or margin for floating point precision
1233 if (use_velocity)
1234 {
1235 btVector3 points[2] = {n->m_x, n->m_x + m_sst.sdt * n->m_v};
1236 vol = btDbvtVolume::FromPoints(points, 2);
1237 vol.Expand(btVector3(pad, pad, pad));
1238 }
1239 else
1240 {
1241 vol = btDbvtVolume::FromCR(n->m_x, pad);
1242 }
1243 node->volume = vol;
1244 return;
1245 }
1246 else
1247 {
1248 updateNode(node->childs[0], use_velocity, margin);
1249 updateNode(node->childs[1], use_velocity, margin);
1250 ATTRIBUTE_ALIGNED16(btDbvtVolume)
1251 vol;
1252 Merge(node->childs[0]->volume, node->childs[1]->volume, vol);
1253 node->volume = vol;
1254 }
1255 }
1256
1257 void updateNodeTree(bool use_velocity, bool margin)
1258 {
1259 if (m_ndbvt.m_root)
1260 updateNode(m_ndbvt.m_root, use_velocity, margin);
1261 }
1262
1263 template <class DBVTNODE> // btDbvtNode or btDbvntNode
1264 void updateFace(DBVTNODE* node, bool use_velocity, bool margin)
1265 {
1266 if (node->isleaf())
1267 {
1268 btSoftBody::Face* f = (btSoftBody::Face*)(node->data);
1269 btScalar pad = margin ? m_sst.radmrg : SAFE_EPSILON; // use user defined margin or margin for floating point precision
1270 ATTRIBUTE_ALIGNED16(btDbvtVolume)
1271 vol;
1272 if (use_velocity)
1273 {
1274 btVector3 points[6] = {f->m_n[0]->m_x, f->m_n[0]->m_x + m_sst.sdt * f->m_n[0]->m_v,
1275 f->m_n[1]->m_x, f->m_n[1]->m_x + m_sst.sdt * f->m_n[1]->m_v,
1276 f->m_n[2]->m_x, f->m_n[2]->m_x + m_sst.sdt * f->m_n[2]->m_v};
1277 vol = btDbvtVolume::FromPoints(points, 6);
1278 }
1279 else
1280 {
1281 btVector3 points[3] = {f->m_n[0]->m_x,
1282 f->m_n[1]->m_x,
1283 f->m_n[2]->m_x};
1284 vol = btDbvtVolume::FromPoints(points, 3);
1285 }
1286 vol.Expand(btVector3(pad, pad, pad));
1287 node->volume = vol;
1288 return;
1289 }
1290 else
1291 {
1292 updateFace(node->childs[0], use_velocity, margin);
1293 updateFace(node->childs[1], use_velocity, margin);
1294 ATTRIBUTE_ALIGNED16(btDbvtVolume)
1295 vol;
1296 Merge(node->childs[0]->volume, node->childs[1]->volume, vol);
1297 node->volume = vol;
1298 }
1299 }
1300 void updateFaceTree(bool use_velocity, bool margin)
1301 {
1302 if (m_fdbvt.m_root)
1303 updateFace(m_fdbvt.m_root, use_velocity, margin);
1304 if (m_fdbvnt)
1305 updateFace(m_fdbvnt, use_velocity, margin);
1306 }
1307
1308 template <typename T>
1309 static inline T BaryEval(const T& a,
1310 const T& b,
1311 const T& c,
1312 const btVector3& coord)
1313 {
1314 return (a * coord.x() + b * coord.y() + c * coord.z());
1315 }
1316
1317 void applyRepulsionForce(btScalar timeStep, bool applySpringForce)
1318 {
1319 btAlignedObjectArray<int> indices;
1320 {
1321 // randomize the order of repulsive force
1322 indices.resize(m_faceNodeContacts.size());
1323 for (int i = 0; i < m_faceNodeContacts.size(); ++i)
1324 indices[i] = i;
1325#define NEXTRAND (seed = (1664525L * seed + 1013904223L) & 0xffffffff)
1326 int i, ni;
1327
1328 for (i = 0, ni = indices.size(); i < ni; ++i)
1329 {
1330 btSwap(indices[i], indices[NEXTRAND % ni]);
1331 }
1332 }
1333 for (int k = 0; k < m_faceNodeContacts.size(); ++k)
1334 {
1335 int idx = indices[k];
1336 btSoftBody::DeformableFaceNodeContact& c = m_faceNodeContacts[idx];
1337 btSoftBody::Node* node = c.m_node;
1338 btSoftBody::Face* face = c.m_face;
1339 const btVector3& w = c.m_bary;
1340 const btVector3& n = c.m_normal;
1341 btVector3 l = node->m_x - BaryEval(face->m_n[0]->m_x, face->m_n[1]->m_x, face->m_n[2]->m_x, w);
1342 btScalar d = c.m_margin - n.dot(l);
1343 d = btMax(btScalar(0), d);
1344
1345 const btVector3& va = node->m_v;
1346 btVector3 vb = BaryEval(face->m_n[0]->m_v, face->m_n[1]->m_v, face->m_n[2]->m_v, w);
1347 btVector3 vr = va - vb;
1348 const btScalar vn = btDot(vr, n); // dn < 0 <==> opposing
1349 if (vn > OVERLAP_REDUCTION_FACTOR * d / timeStep)
1350 continue;
1351 btVector3 vt = vr - vn * n;
1352 btScalar I = 0;
1353 btScalar mass = node->m_im == 0 ? 0 : btScalar(1) / node->m_im;
1354 if (applySpringForce)
1355 I = -btMin(m_repulsionStiffness * timeStep * d, mass * (OVERLAP_REDUCTION_FACTOR * d / timeStep - vn));
1356 if (vn < 0)
1357 I += 0.5 * mass * vn;
1358 int face_penetration = 0, node_penetration = node->m_constrained;
1359 for (int i = 0; i < 3; ++i)
1360 face_penetration |= face->m_n[i]->m_constrained;
1361 btScalar I_tilde = 2.0 * I / (1.0 + w.length2());
1362
1363 // double the impulse if node or face is constrained.
1364 if (face_penetration > 0 || node_penetration > 0)
1365 {
1366 I_tilde *= 2.0;
1367 }
1368 if (face_penetration <= 0)
1369 {
1370 for (int j = 0; j < 3; ++j)
1371 face->m_n[j]->m_v += w[j] * n * I_tilde * node->m_im;
1372 }
1373 if (node_penetration <= 0)
1374 {
1375 node->m_v -= I_tilde * node->m_im * n;
1376 }
1377
1378 // apply frictional impulse
1379 btScalar vt_norm = vt.safeNorm();
1380 if (vt_norm > SIMD_EPSILON)
1381 {
1382 btScalar delta_vn = -2 * I * node->m_im;
1383 btScalar mu = c.m_friction;
1384 btScalar vt_new = btMax(btScalar(1) - mu * delta_vn / (vt_norm + SIMD_EPSILON), btScalar(0)) * vt_norm;
1385 I = 0.5 * mass * (vt_norm - vt_new);
1386 vt.safeNormalize();
1387 I_tilde = 2.0 * I / (1.0 + w.length2());
1388 // double the impulse if node or face is constrained.
1389 if (face_penetration > 0 || node_penetration > 0)
1390 I_tilde *= 2.0;
1391 if (face_penetration <= 0)
1392 {
1393 for (int j = 0; j < 3; ++j)
1394 face->m_n[j]->m_v += w[j] * vt * I_tilde * (face->m_n[j])->m_im;
1395 }
1396 if (node_penetration <= 0)
1397 {
1398 node->m_v -= I_tilde * node->m_im * vt;
1399 }
1400 }
1401 }
1402 }
1403 virtual int calculateSerializeBufferSize() const;
1404
1406 virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
1407};
1408
1409#endif //_BT_SOFT_BODY_H
btAlignedObjectArray.h
btCollisionCreateFunc.h
btConcaveShape.h
btDbvt.h
btDbvtVolume
btDbvtAabbMm btDbvtVolume
Definition btDbvt.h:177
Merge
DBVT_INLINE void Merge(const btDbvtAabbMm &a, const btDbvtAabbMm &b, btDbvtAabbMm &r)
Definition btDbvt.h:745
btIDebugDraw.h
btMax
const T & btMax(const T &a, const T &b)
Definition btMinMax.h:27
btMin
const T & btMin(const T &a, const T &b)
Definition btMinMax.h:21
btMultiBodyConstraint.h
btMultiBodyLinkCollider.h
btRigidBody.h
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition btScalar.h:314
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition btScalar.h:99
SIMD_INFINITY
#define SIMD_INFINITY
Definition btScalar.h:544
SIMD_EPSILON
#define SIMD_EPSILON
Definition btScalar.h:543
btSwap
void btSwap(T &a, T &b)
Definition btScalar.h:643
seed
static unsigned long seed
Definition btSoftBody.h:39
OVERLAP_REDUCTION_FACTOR
static const btScalar OVERLAP_REDUCTION_FACTOR
Definition btSoftBody.h:38
NEXTRAND
#define NEXTRAND
SAFE_EPSILON
#define SAFE_EPSILON
Definition btSoftBody.h:1224
btSparseSDF.h
btTransform.h
btVector3.h
btDot
btScalar btDot(const btVector3 &v1, const btVector3 &v2)
Return the dot product between two vectors.
Definition btVector3.h:890
btCross
btVector3 btCross(const btVector3 &v1, const btVector3 &v2)
Return the cross product of two vectors.
Definition btVector3.h:918
btAlignedObjectArray
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
Definition btAlignedObjectArray.h:46
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition btAlignedObjectArray.h:142
btAlignedObjectArray::resize
void resize(int newsize, const T &fillData=T())
Definition btAlignedObjectArray.h:203
btBroadphaseInterface
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
Definition btBroadphaseInterface.h:50
btCollisionObject::CO_SOFT_BODY
@ CO_SOFT_BODY
Definition btCollisionObject.h:152
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition btCollisionObject.h:374
btCollisionObject::btCollisionObject
btCollisionObject()
Definition btCollisionObject.cpp:20
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition btCollisionShape.h:28
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition btDispatcher.h:77
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition btMatrix3x3.h:50
btMatrix3x3::setIdentity
void setIdentity()
Set the matrix to the identity.
Definition btMatrix3x3.h:323
btMultiBodyLinkCollider
Definition btMultiBodyLinkCollider.h:33
btQuaternion
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition btQuaternion.h:50
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition btRigidBody.h:60
btRigidBody::upcast
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
Definition btRigidBody.h:189
btSerializer
Definition btSerializer.h:66
btSoftBodySolver
Definition btSoftBodySolvers.h:29
btSoftBody::DeformableFaceRigidContact
Definition btSoftBody.h:391
btSoftBody::DeformableFaceRigidContact::m_contactPoint
btVector3 m_contactPoint
Definition btSoftBody.h:394
btSoftBody::DeformableFaceRigidContact::m_bary
btVector3 m_bary
Definition btSoftBody.h:395
btSoftBody::DeformableFaceRigidContact::m_face
Face * m_face
Definition btSoftBody.h:393
btSoftBody::DeformableFaceRigidContact::m_weights
btVector3 m_weights
Definition btSoftBody.h:396
btSoftBody::DeformableNodeRigidAnchor
Definition btSoftBody.h:385
btSoftBody::DeformableNodeRigidAnchor::m_local
btVector3 m_local
Definition btSoftBody.h:387
btSoftBody::DeformableNodeRigidContact
Definition btSoftBody.h:379
btSoftBody::DeformableNodeRigidContact::m_node
Node * m_node
Definition btSoftBody.h:381
btSoftBody::DeformableRigidContact
Definition btSoftBody.h:360
btSoftBody::DeformableRigidContact::m_c2
btScalar m_c2
Definition btSoftBody.h:365
btSoftBody::DeformableRigidContact::m_c1
btVector3 m_c1
Definition btSoftBody.h:364
btSoftBody::DeformableRigidContact::t1
btVector3 t1
Definition btSoftBody.h:374
btSoftBody::DeformableRigidContact::m_c5
btMatrix3x3 m_c5
Definition btSoftBody.h:368
btSoftBody::DeformableRigidContact::m_c3
btScalar m_c3
Definition btSoftBody.h:366
btSoftBody::DeformableRigidContact::m_cti
sCti m_cti
Definition btSoftBody.h:362
btSoftBody::DeformableRigidContact::m_c0
btMatrix3x3 m_c0
Definition btSoftBody.h:363
btSoftBody::DeformableRigidContact::t2
btVector3 t2
Definition btSoftBody.h:375
btSoftBody::DeformableRigidContact::jacobianData_t1
btMultiBodyJacobianData jacobianData_t1
Definition btSoftBody.h:372
btSoftBody::DeformableRigidContact::jacobianData_normal
btMultiBodyJacobianData jacobianData_normal
Definition btSoftBody.h:371
btSoftBody::DeformableRigidContact::jacobianData_t2
btMultiBodyJacobianData jacobianData_t2
Definition btSoftBody.h:373
btSoftBody::DeformableRigidContact::m_c4
btScalar m_c4
Definition btSoftBody.h:367
btSoftBody
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition btSoftBody.h:75
btSoftBody::PSolve_Links
static void PSolve_Links(btSoftBody *psb, btScalar kst, btScalar ti)
Definition btSoftBody.cpp:4004
btSoftBody::PSolve_SContacts
static void PSolve_SContacts(btSoftBody *psb, btScalar, btScalar ti)
Definition btSoftBody.cpp:3969
btSoftBody::checkLink
bool checkLink(int node0, int node1) const
Definition btSoftBody.cpp:256
btSoftBody::m_bUpdateRtCst
bool m_bUpdateRtCst
Definition btSoftBody.h:834
btSoftBody::m_sleepingThreshold
btScalar m_sleepingThreshold
Definition btSoftBody.h:841
btSoftBody::transformTo
virtual void transformTo(const btTransform &trs)
Definition btSoftBody.cpp:1093
btSoftBody::getLinearVelocity
btVector3 getLinearVelocity()
Definition btSoftBody.cpp:1034
btSoftBody::checkFace
bool checkFace(int node0, int node1, int node2) const
Definition btSoftBody.cpp:278
btSoftBody::advanceDeformation
void advanceDeformation()
Definition btSoftBody.cpp:3571
btSoftBody::tVSolverArray
btAlignedObjectArray< eVSolver::_ > tVSolverArray
Definition btSoftBody.h:151
btSoftBody::setGravityFactor
void setGravityFactor(btScalar gravFactor)
Definition btSoftBody.cpp:3471
btSoftBody::updateClusters
void updateClusters()
Definition btSoftBody.cpp:3238
btSoftBody::m_cdbvt
btDbvt m_cdbvt
Definition btSoftBody.h:838
btSoftBody::setPose
void setPose(bool bvolume, bool bframe)
Definition btSoftBody.cpp:1185
btSoftBody::cutLink
bool cutLink(int node0, int node1, btScalar position)
Definition btSoftBody.cpp:1984
btSoftBody::appendFace
void appendFace(int model=-1, Material *mat=0)
Definition btSoftBody.cpp:432
btSoftBody::setMass
void setMass(int node, btScalar mass)
Definition btSoftBody.cpp:923
btSoftBody::interpolateRenderMesh
void interpolateRenderMesh()
Definition btSoftBody.cpp:3824
btSoftBody::m_joints
tJointArray m_joints
Definition btSoftBody.h:830
btSoftBody::m_dampingCoefficient
btScalar m_dampingCoefficient
Definition btSoftBody.h:840
btSoftBody::updateNode
void updateNode(btDbvtNode *node, bool use_velocity, bool margin)
Definition btSoftBody.h:1225
btSoftBody::m_tetraScratchesTn
btAlignedObjectArray< TetraScratch > m_tetraScratchesTn
Definition btSoftBody.h:821
btSoftBody::integrateMotion
void integrateMotion()
Definition btSoftBody.cpp:2348
btSoftBody::tTetraArray
btAlignedObjectArray< Tetra > tTetraArray
Definition btSoftBody.h:795
btSoftBody::rebuildNodeTree
void rebuildNodeTree()
Definition btSoftBody.cpp:2697
btSoftBody::rayFaceTest
bool rayFaceTest(const btVector3 &rayFrom, const btVector3 &rayTo, sRayCast &results)
Definition btSoftBody.cpp:2054
btSoftBody::appendLinearJoint
void appendLinearJoint(const LJoint::Specs &specs, Cluster *body0, Body body1)
Definition btSoftBody.cpp:640
btSoftBody::m_renderFaces
tRenderFaceArray m_renderFaces
Definition btSoftBody.h:818
btSoftBody::tSContactArray
btAlignedObjectArray< SContact > tSContactArray
Definition btSoftBody.h:798
btSoftBody::scale
virtual void scale(const btVector3 &scl)
Definition btSoftBody.cpp:1143
btSoftBody::m_clusterConnectivity
btAlignedObjectArray< bool > m_clusterConnectivity
Definition btSoftBody.h:855
btSoftBody::updateFaceTree
void updateFaceTree(bool use_velocity, bool margin)
Definition btSoftBody.h:1300
btSoftBody::defaultCollisionHandler
void defaultCollisionHandler(const btCollisionObjectWrapper *pcoWrap)
Definition btSoftBody.cpp:4085
btSoftBody::getVolume
btScalar getVolume() const
Definition btSoftBody.cpp:1244
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:2039
btSoftBody::m_sst
SolverState m_sst
Definition btSoftBody.h:809
btSoftBody::addVelocity
void addVelocity(const btVector3 &velocity)
Definition btSoftBody.cpp:893
btSoftBody::tRContactArray
btAlignedObjectArray< RContact > tRContactArray
Definition btSoftBody.h:797
btSoftBody::setDampingCoefficient
void setDampingCoefficient(btScalar damping_coeff)
Definition btSoftBody.h:886
btSoftBody::predictMotion
void predictMotion(btScalar dt)
Definition btSoftBody.cpp:2099
btSoftBody::setSelfCollision
void setSelfCollision(bool useSelfCollision)
Definition btSoftBody.cpp:4074
btSoftBody::setLinearVelocity
void setLinearVelocity(const btVector3 &linVel)
Definition btSoftBody.cpp:1047
btSoftBody::m_timeacc
btScalar m_timeacc
Definition btSoftBody.h:832
btSoftBody::m_pose
Pose m_pose
Definition btSoftBody.h:810
btSoftBody::m_userIndexMapping
btAlignedObjectArray< int > m_userIndexMapping
Definition btSoftBody.h:879
btSoftBody::tFaceArray
btAlignedObjectArray< Face > tFaceArray
Definition btSoftBody.h:793
btSoftBody::appendTetra
void appendTetra(int model, Material *mat)
Definition btSoftBody.cpp:472
btSoftBody::setRestLengthScale
void setRestLengthScale(btScalar restLength)
Definition btSoftBody.cpp:1170
btSoftBody::m_fdbvnt
btDbvntNode * m_fdbvnt
Definition btSoftBody.h:837
btSoftBody::updateNodeTree
void updateNodeTree(bool use_velocity, bool margin)
Definition btSoftBody.h:1257
btSoftBody::rotate
virtual void rotate(const btQuaternion &rot)
Definition btSoftBody.cpp:1134
btSoftBody::updateFace
void updateFace(DBVTNODE *node, bool use_velocity, bool margin)
Definition btSoftBody.h:1264
btSoftBody::applyClusters
void applyClusters(bool drift)
Definition btSoftBody.cpp:3386
btSoftBody::setZeroVelocity
void setZeroVelocity()
Definition btSoftBody.cpp:4732
btSoftBody::PSolve_Anchors
static void PSolve_Anchors(btSoftBody *psb, btScalar kst, btScalar ti)
Definition btSoftBody.cpp:3873
btSoftBody::m_faceNodeContactsCCD
btAlignedObjectArray< DeformableFaceNodeContact > m_faceNodeContactsCCD
Definition btSoftBody.h:828
btSoftBody::m_worldInfo
btSoftBodyWorldInfo * m_worldInfo
Definition btSoftBody.h:812
btSoftBody::setSoftBodySolver
void setSoftBodySolver(btSoftBodySolver *softBodySolver)
Definition btSoftBody.h:1132
btSoftBody::tDenseMatrix
btAlignedObjectArray< btAlignedObjectArray< btScalar > > tDenseMatrix
Definition btSoftBody.h:802
btSoftBody::updateArea
void updateArea(bool averageArea=true)
Definition btSoftBody.cpp:3086
btSoftBody::addForce
void addForce(const btVector3 &force)
Definition btSoftBody.cpp:693
btSoftBody::wantsSleeping
bool wantsSleeping()
Definition btSoftBody.cpp:4740
btSoftBody::prepareClusters
void prepareClusters(int iterations)
Definition btSoftBody.cpp:3368
btSoftBody::setCollisionQuadrature
void setCollisionQuadrature(int N)
Definition btSoftBody.cpp:3861
btSoftBody::clusterVImpulse
static void clusterVImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
Definition btSoftBody.cpp:1292
btSoftBody::serialize
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition btSoftBody.cpp:4336
btSoftBody::m_faceNodeContacts
btAlignedObjectArray< DeformableFaceNodeContact > m_faceNodeContacts
Definition btSoftBody.h:826
btSoftBody::VSolve_Links
static void VSolve_Links(btSoftBody *psb, btScalar kst)
Definition btSoftBody.cpp:4027
btSoftBody::m_tetras
tTetraArray m_tetras
Definition btSoftBody.h:819
btSoftBody::useSelfCollision
bool useSelfCollision()
Definition btSoftBody.cpp:4079
btSoftBody::evaluateCom
btVector3 evaluateCom() const
Definition btSoftBody.cpp:2735
btSoftBody::setTotalDensity
void setTotalDensity(btScalar density)
Definition btSoftBody.cpp:983
btSoftBody::m_collisionDisabledObjects
btAlignedObjectArray< const class btCollisionObject * > m_collisionDisabledObjects
Definition btSoftBody.h:77
btSoftBody::tLinkArray
btAlignedObjectArray< Link > tLinkArray
Definition btSoftBody.h:792
btSoftBody::clusterDAImpulse
static void clusterDAImpulse(Cluster *cluster, const btVector3 &impulse)
Definition btSoftBody.cpp:1330
btSoftBody::appendNode
void appendNode(const btVector3 &x, btScalar m)
Definition btSoftBody.cpp:372
btSoftBody::staticSolve
void staticSolve(int iterations)
Definition btSoftBody.cpp:2301
btSoftBody::setVolumeMass
void setVolumeMass(btScalar mass)
Definition btSoftBody.cpp:989
btSoftBody::m_restLengthScale
btScalar m_restLengthScale
Definition btSoftBody.h:859
btSoftBody::checkDeformableContact
bool checkDeformableContact(const btCollisionObjectWrapper *colObjWrap, const btVector3 &x, btScalar margin, btSoftBody::sCti &cti, bool predict=false) const
Definition btSoftBody.cpp:2777
btSoftBody::m_reducedModel
bool m_reducedModel
Definition btSoftBody.h:861
btSoftBody::cleanupClusters
void cleanupClusters()
Definition btSoftBody.cpp:3354
btSoftBody::m_cfg
Config m_cfg
Definition btSoftBody.h:808
btSoftBody::updateDeactivation
void updateDeactivation(btScalar timeStep)
Definition btSoftBody.cpp:4716
btSoftBody::m_tetraScratches
btAlignedObjectArray< TetraScratch > m_tetraScratches
Definition btSoftBody.h:820
btSoftBody::getWindVelocity
const btVector3 & getWindVelocity()
Return the wind velocity for interaction with the air.
Definition btSoftBody.cpp:4324
btSoftBody::addAeroForceToFace
void addAeroForceToFace(const btVector3 &windVelocity, int faceIndex)
Definition btSoftBody.cpp:797
btSoftBody::m_renderNodesInterpolationWeights
btAlignedObjectArray< btVector4 > m_renderNodesInterpolationWeights
Definition btSoftBody.h:849
btSoftBody::appendAngularJoint
void appendAngularJoint(const AJoint::Specs &specs, Cluster *body0, Body body1)
Definition btSoftBody.cpp:666
btSoftBody::m_faces
tFaceArray m_faces
Definition btSoftBody.h:817
btSoftBody::setAngularVelocity
void setAngularVelocity(const btVector3 &angVel)
Definition btSoftBody.cpp:1056
btSoftBody::setVolumeDensity
void setVolumeDensity(btScalar density)
Definition btSoftBody.cpp:1019
btSoftBody::clusterDCImpulse
static void clusterDCImpulse(Cluster *cluster, const btVector3 &impulse)
Definition btSoftBody.cpp:1345
btSoftBody::transform
virtual void transform(const btTransform &trs)
Definition btSoftBody.cpp:1103
btSoftBody::m_softSoftCollision
bool m_softSoftCollision
Definition btSoftBody.h:853
btSoftBody::clusterVAImpulse
static void clusterVAImpulse(Cluster *cluster, const btVector3 &impulse)
Definition btSoftBody.cpp:1321
btSoftBody::getMass
btScalar getMass(int node) const
Definition btSoftBody.cpp:930
btSoftBody::m_materials
tMaterialArray m_materials
Definition btSoftBody.h:831
btSoftBody::setMaxStress
void setMaxStress(btScalar maxStress)
Definition btSoftBody.cpp:3818
btSoftBody::dampClusters
void dampClusters()
Definition btSoftBody.cpp:3437
btSoftBody::btSoftBody
btSoftBody(btSoftBodyWorldInfo *worldInfo, int node_count, const btVector3 *x, const btScalar *m)
Definition btSoftBody.cpp:130
btSoftBody::updateDeformation
void updateDeformation()
Definition btSoftBody.cpp:3533
btSoftBody::m_z
btAlignedObjectArray< btScalar > m_z
Definition btSoftBody.h:851
btSoftBody::addAeroForceToNode
void addAeroForceToNode(const btVector3 &windVelocity, int nodeIndex)
Definition btSoftBody.cpp:708
btSoftBody::applyRepulsionForce
void applyRepulsionForce(btScalar timeStep, bool applySpringForce)
Definition btSoftBody.h:1317
btSoftBody::tVector3Array
btAlignedObjectArray< btVector3 > tVector3Array
Definition btSoftBody.h:221
btSoftBody::clusterCom
static btVector3 clusterCom(const Cluster *cluster)
Definition btSoftBody.cpp:1269
btSoftBody::m_rcontacts
tRContactArray m_rcontacts
Definition btSoftBody.h:824
btSoftBody::appendAnchor
void appendAnchor(int node, btRigidBody *body, bool disableCollisionBetweenLinkedBodies=false, btScalar influence=1)
Definition btSoftBody.cpp:504
btSoftBody::tNodeArray
btAlignedObjectArray< Node > tNodeArray
Definition btSoftBody.h:789
btSoftBody::m_bounds
btVector3 m_bounds[2]
Definition btSoftBody.h:833
btSoftBody::m_maxSpeedSquared
btScalar m_maxSpeedSquared
Definition btSoftBody.h:842
btSoftBody::releaseCluster
void releaseCluster(int index)
Definition btSoftBody.cpp:1505
btSoftBody::tRenderNodeArray
btAlignedObjectArray< RenderNode > tRenderNodeArray
Definition btSoftBody.h:790
btSoftBody::m_repulsionStiffness
btScalar m_repulsionStiffness
Definition btSoftBody.h:844
btSoftBody::setVelocity
void setVelocity(const btVector3 &velocity)
Definition btSoftBody.cpp:899
btSoftBody::m_clusters
tClusterArray m_clusters
Definition btSoftBody.h:839
btSoftBody::tJointArray
btAlignedObjectArray< Joint * > tJointArray
Definition btSoftBody.h:800
btSoftBody::solveConstraints
void solveConstraints()
Definition btSoftBody.cpp:2208
btSoftBody::m_faceRigidContacts
btAlignedObjectArray< DeformableFaceRigidContact > m_faceRigidContacts
Definition btSoftBody.h:827
btSoftBody::generateClusters
int generateClusters(int k, int maxiterations=8192)
generateClusters with k=0 will create a convex cluster for each tetrahedron or triangle otherwise an ...
Definition btSoftBody.cpp:1521
btSoftBody::geometricCollisionHandler
void geometricCollisionHandler(btSoftBody *psb)
Definition btSoftBody.cpp:4267
btSoftBody::releaseClusters
void releaseClusters()
Definition btSoftBody.cpp:1515
btSoftBody::refine
void refine(ImplicitFn *ifn, btScalar accurary, bool cut)
Definition btSoftBody.cpp:1714
btSoftBody::setSolver
void setSolver(eSolverPresets::_ preset)
Definition btSoftBody.cpp:2074
btSoftBody::BaryEval
static T BaryEval(const T &a, const T &b, const T &c, const btVector3 &coord)
Definition btSoftBody.h:1309
btSoftBody::appendMaterial
Material * appendMaterial()
Definition btSoftBody.cpp:302
btSoftBody::removeAnchor
void removeAnchor(int node)
Definition btSoftBody.cpp:566
btSoftBody::m_deformableAnchors
btAlignedObjectArray< DeformableNodeRigidAnchor > m_deformableAnchors
Definition btSoftBody.h:823
btSoftBody::setCacheBarycenter
void setCacheBarycenter(bool cacheBarycenter)
Definition btSoftBody.cpp:3476
btSoftBody::tMaterialArray
btAlignedObjectArray< Material * > tMaterialArray
Definition btSoftBody.h:799
btSoftBody::tAnchorArray
btAlignedObjectArray< Anchor > tAnchorArray
Definition btSoftBody.h:796
btSoftBody::m_gravityFactor
btScalar m_gravityFactor
Definition btSoftBody.h:845
btSoftBody::solveClusters
static void solveClusters(const btAlignedObjectArray< btSoftBody * > &bodies)
Definition btSoftBody.cpp:2319
btSoftBody::appendNote
void appendNote(const char *text, const btVector3 &o, const btVector4 &c=btVector4(1, 0, 0, 0), Node *n0=0, Node *n1=0, Node *n2=0, Node *n3=0)
Definition btSoftBody.cpp:314
btSoftBody::checkDeformableFaceContact
bool checkDeformableFaceContact(const btCollisionObjectWrapper *colObjWrap, Face &f, btVector3 &contact_point, btVector3 &bary, btScalar margin, btSoftBody::sCti &cti, bool predict=false) const
Definition btSoftBody.cpp:2834
btSoftBody::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition btSoftBody.cpp:4329
btSoftBody::m_nodeRigidContacts
btAlignedObjectArray< DeformableNodeRigidContact > m_nodeRigidContacts
Definition btSoftBody.h:825
btSoftBody::tSoftBodyArray
btAlignedObjectArray< btSoftBody * > tSoftBodyArray
Definition btSoftBody.h:801
btSoftBody::PSolve_RContacts
static void PSolve_RContacts(btSoftBody *psb, btScalar kst, btScalar ti)
Definition btSoftBody.cpp:3894
btSoftBody::getImpulseFactor
virtual btMatrix3x3 getImpulseFactor(int n_node)
Definition btSoftBody.h:1107
btSoftBody::clusterImpulse
static void clusterImpulse(Cluster *cluster, const btVector3 &rpos, const Impulse &impulse)
Definition btSoftBody.cpp:1314
btSoftBody::m_renderNodesParents
btAlignedObjectArray< btAlignedObjectArray< const btSoftBody::Node * > > m_renderNodesParents
Definition btSoftBody.h:850
btSoftBody::m_renderNodes
tRenderNodeArray m_renderNodes
Definition btSoftBody.h:815
btSoftBody::pointersToIndices
void pointersToIndices()
Definition btSoftBody.cpp:2416
btSoftBody::m_notes
tNoteArray m_notes
Definition btSoftBody.h:813
btSoftBody::updateNormals
void updateNormals()
Definition btSoftBody.cpp:2946
btSoftBody::clusterDImpulse
static void clusterDImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
Definition btSoftBody.cpp:1304
btSoftBody::m_fdbvt
btDbvt m_fdbvt
Definition btSoftBody.h:836
btSoftBody::m_links
tLinkArray m_links
Definition btSoftBody.h:816
btSoftBody::applyForces
void applyForces()
Definition btSoftBody.cpp:3750
btSoftBody::clusterVelocity
static btVector3 clusterVelocity(const Cluster *cluster, const btVector3 &rpos)
Definition btSoftBody.cpp:1286
btSoftBody::getRigidTransform
btTransform getRigidTransform()
Definition btSoftBody.cpp:1067
btSoftBody::m_scontacts
tSContactArray m_scontacts
Definition btSoftBody.h:829
btSoftBody::m_cacheBarycenter
bool m_cacheBarycenter
Definition btSoftBody.h:846
btSoftBody::m_useSelfCollision
bool m_useSelfCollision
Definition btSoftBody.h:852
btSoftBody::m_tag
void * m_tag
Definition btSoftBody.h:811
btSoftBody::updatePose
void updatePose()
Definition btSoftBody.cpp:3049
btSoftBody::tLeafArray
btAlignedObjectArray< btDbvtNode * > tLeafArray
Definition btSoftBody.h:791
btSoftBody::psolver_t
void(* psolver_t)(btSoftBody *, btScalar, btScalar)
Definition btSoftBody.h:785
btSoftBody::initializeClusters
void initializeClusters()
Definition btSoftBody.cpp:3171
btSoftBody::getWorldInfo
btSoftBodyWorldInfo * getWorldInfo()
Definition btSoftBody.h:881
btSoftBody::m_anchors
tAnchorArray m_anchors
Definition btSoftBody.h:822
btSoftBody::getRestLengthScale
btScalar getRestLengthScale()
Definition btSoftBody.cpp:1164
btSoftBody::tNoteArray
btAlignedObjectArray< Note > tNoteArray
Definition btSoftBody.h:788
btSoftBody::updateState
void updateState(const btAlignedObjectArray< btVector3 > &qs, const btAlignedObjectArray< btVector3 > &vs)
Definition btSoftBody.cpp:1489
btSoftBody::randomizeConstraints
void randomizeConstraints()
Definition btSoftBody.cpp:1472
btSoftBody::setCollisionShape
virtual void setCollisionShape(btCollisionShape *collisionShape)
Definition btSoftBody.h:892
btSoftBody::m_windVelocity
btVector3 m_windVelocity
Definition btSoftBody.h:857
btSoftBody::getTotalMass
btScalar getTotalMass() const
Definition btSoftBody.cpp:936
btSoftBody::m_nodes
tNodeArray m_nodes
Definition btSoftBody.h:814
btSoftBody::tPSolverArray
btAlignedObjectArray< ePSolver::_ > tPSolverArray
Definition btSoftBody.h:152
btSoftBody::appendLink
void appendLink(int model=-1, Material *mat=0)
Definition btSoftBody.cpp:392
btSoftBody::setSpringStiffness
void setSpringStiffness(btScalar k)
Definition btSoftBody.cpp:3462
btSoftBody::initializeDmInverse
void initializeDmInverse()
Definition btSoftBody.cpp:3481
btSoftBody::upcast
static const btSoftBody * upcast(const btCollisionObject *colObj)
Definition btSoftBody.h:1157
btSoftBody::updateConstants
void updateConstants()
Definition btSoftBody.cpp:3163
btSoftBody::setTotalMass
void setTotalMass(btScalar mass, bool fromfaces=false)
Definition btSoftBody.cpp:947
btSoftBody::getSoftBodySolver
btSoftBodySolver * getSoftBodySolver()
Definition btSoftBody.h:1140
btSoftBody::~btSoftBody
virtual ~btSoftBody()
Definition btSoftBody.cpp:240
btSoftBody::appendDeformableAnchor
void appendDeformableAnchor(int node, btRigidBody *body)
Definition btSoftBody.cpp:531
btSoftBody::tRenderFaceArray
btAlignedObjectArray< RenderFace > tRenderFaceArray
Definition btSoftBody.h:794
btSoftBody::updateLinkConstants
void updateLinkConstants()
Definition btSoftBody.cpp:3150
btSoftBody::getAabb
virtual void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
Definition btSoftBody.h:1174
btSoftBody::vsolver_t
void(* vsolver_t)(btSoftBody *, btScalar)
Definition btSoftBody.h:786
btSoftBody::initDefaults
void initDefaults()
Definition btSoftBody.cpp:170
btSoftBody::m_quads
btAlignedObjectArray< btVector3 > m_quads
Definition btSoftBody.h:843
btSoftBody::getSolver
static psolver_t getSolver(ePSolver::_ solver)
Definition btSoftBody.cpp:4041
btSoftBody::checkContact
bool checkContact(const btCollisionObjectWrapper *colObjWrap, const btVector3 &x, btScalar margin, btSoftBody::sCti &cti) const
Definition btSoftBody.cpp:2748
btSoftBody::indicesToPointers
void indicesToPointers(const int *map=0)
Definition btSoftBody.cpp:2459
btSoftBody::solveCommonConstraints
static void solveCommonConstraints(btSoftBody **bodies, int count, int iterations)
Definition btSoftBody.cpp:2313
btSoftBody::tClusterArray
btAlignedObjectArray< Cluster * > tClusterArray
Definition btSoftBody.h:787
btSoftBody::updateBounds
void updateBounds()
Definition btSoftBody.cpp:2975
btSoftBody::setWindVelocity
void setWindVelocity(const btVector3 &velocity)
Set a wind velocity for interaction with the air.
Definition btSoftBody.cpp:4319
btSoftBody::getSoftBodySolver
btSoftBodySolver * getSoftBodySolver() const
Definition btSoftBody.h:1148
btSoftBody::generateBendingConstraints
int generateBendingConstraints(int distance, Material *mat=0)
Definition btSoftBody.cpp:1357
btSoftBody::m_X
btAlignedObjectArray< btVector3 > m_X
Definition btSoftBody.h:847
btSoftBody::translate
virtual void translate(const btVector3 &trs)
Definition btSoftBody.cpp:1125
btSoftBody::getCenterOfMass
btVector3 getCenterOfMass() const
Definition btSoftBody.h:1030
btSoftBody::initializeFaceTree
void initializeFaceTree()
Definition btSoftBody.cpp:2642
btSoftBody::m_softBodySolver
btSoftBodySolver * m_softBodySolver
Definition btSoftBody.h:80
btSoftBody::resetLinkRestLengths
void resetLinkRestLengths()
Definition btSoftBody.cpp:1233
btSoftBody::clusterCount
int clusterCount() const
Definition btSoftBody.cpp:1263
btSoftBody::tScalarArray
btAlignedObjectArray< btScalar > tScalarArray
Definition btSoftBody.h:220
btSoftBody::m_ndbvt
btDbvt m_ndbvt
Definition btSoftBody.h:835
btSoftBody::clusterAImpulse
static void clusterAImpulse(Cluster *cluster, const Impulse &impulse)
Definition btSoftBody.cpp:1338
btSoftBody::upcast
static btSoftBody * upcast(btCollisionObject *colObj)
Definition btSoftBody.h:1163
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition btTransform.h:30
btTransform::getIdentity
static const btTransform & getIdentity()
Return an identity transform.
Definition btTransform.h:198
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition btVector3.h:82
btVector3::safeNorm
btScalar safeNorm() const
Return the norm (length) of the vector.
Definition btVector3.h:269
btVector3::z
const btScalar & z() const
Return the z value.
Definition btVector3.h:579
btVector3::safeNormalize
btVector3 & safeNormalize()
Definition btVector3.h:286
btVector3::dot
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition btVector3.h:229
btVector3::length2
btScalar length2() const
Return the length of the vector squared.
Definition btVector3.h:251
btVector3::x
const btScalar & x() const
Return the x value.
Definition btVector3.h:575
btVector3::y
const btScalar & y() const
Return the y value.
Definition btVector3.h:577
btVector4
Definition btVector3.h:1074
btCollisionObjectWrapper
Definition btCollisionObjectWrapper.h:18
btDbvntNode
Definition btDbvt.h:195
btDbvtAabbMm::FromCR
static btDbvtAabbMm FromCR(const btVector3 &c, btScalar r)
Definition btDbvt.h:473
btDbvtAabbMm::FromPoints
static btDbvtAabbMm FromPoints(const btVector3 *pts, int n)
Definition btDbvt.h:488
btDbvtNode
Definition btDbvt.h:181
btDbvtNode::childs
btDbvtNode * childs[2]
Definition btDbvt.h:187
btDbvtNode::data
void * data
Definition btDbvt.h:188
btDbvtNode::volume
btDbvtVolume volume
Definition btDbvt.h:182
btDbvtNode::isleaf
DBVT_INLINE bool isleaf() const
Definition btDbvt.h:184
btDbvt::ICollide
Definition btDbvt.h:270
btDbvt
The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes ...
Definition btDbvt.h:229
btMultiBodyJacobianData
Definition btMultiBodyConstraint.h:44
btSoftBodyWorldInfo
Definition btSoftBody.h:48
btSoftBodyWorldInfo::air_density
btScalar air_density
Definition btSoftBody.h:49
btSoftBodyWorldInfo::m_dispatcher
btDispatcher * m_dispatcher
Definition btSoftBody.h:55
btSoftBodyWorldInfo::water_density
btScalar water_density
Definition btSoftBody.h:50
btSoftBodyWorldInfo::btSoftBodyWorldInfo
btSoftBodyWorldInfo()
Definition btSoftBody.h:59
btSoftBodyWorldInfo::m_sparsesdf
btSparseSdf< 3 > m_sparsesdf
Definition btSoftBody.h:57
btSoftBodyWorldInfo::m_gravity
btVector3 m_gravity
Definition btSoftBody.h:56
btSoftBodyWorldInfo::water_normal
btVector3 water_normal
Definition btSoftBody.h:53
btSoftBodyWorldInfo::m_maxDisplacement
btScalar m_maxDisplacement
Definition btSoftBody.h:52
btSoftBodyWorldInfo::water_offset
btScalar water_offset
Definition btSoftBody.h:51
btSoftBodyWorldInfo::m_broadphase
btBroadphaseInterface * m_broadphase
Definition btSoftBody.h:54
btSoftBody::AJoint::IControl
Definition btSoftBody.h:671
btSoftBody::AJoint::IControl::~IControl
virtual ~IControl()
Definition btSoftBody.h:672
btSoftBody::AJoint::IControl::Default
static IControl * Default()
Definition btSoftBody.h:675
btSoftBody::AJoint::IControl::Speed
virtual btScalar Speed(AJoint *, btScalar current)
Definition btSoftBody.h:674
btSoftBody::AJoint::IControl::Prepare
virtual void Prepare(AJoint *)
Definition btSoftBody.h:673
btSoftBody::AJoint::Specs::icontrol
IControl * icontrol
Definition btSoftBody.h:685
btSoftBody::AJoint::Specs::axis
btVector3 axis
Definition btSoftBody.h:684
btSoftBody::AJoint::Specs::Specs
Specs()
Definition btSoftBody.h:683
btSoftBody::AJoint
Definition btSoftBody.h:669
btSoftBody::AJoint::m_axis
btVector3 m_axis[2]
Definition btSoftBody.h:687
btSoftBody::AJoint::Prepare
void Prepare(btScalar dt, int iterations)
Definition btSoftBody.cpp:3630
btSoftBody::AJoint::Solve
void Solve(btScalar dt, btScalar sor)
Definition btSoftBody.cpp:3650
btSoftBody::AJoint::m_icontrol
IControl * m_icontrol
Definition btSoftBody.h:688
btSoftBody::AJoint::Terminate
void Terminate(btScalar dt)
Definition btSoftBody.cpp:3665
btSoftBody::AJoint::Type
eType::_ Type() const
Definition btSoftBody.h:692
btSoftBody::Anchor
Definition btSoftBody.h:426
btSoftBody::Anchor::m_c1
btVector3 m_c1
Definition btSoftBody.h:432
btSoftBody::Anchor::m_influence
btScalar m_influence
Definition btSoftBody.h:430
btSoftBody::Anchor::m_local
btVector3 m_local
Definition btSoftBody.h:428
btSoftBody::Anchor::m_body
btRigidBody * m_body
Definition btSoftBody.h:429
btSoftBody::Anchor::m_c2
btScalar m_c2
Definition btSoftBody.h:433
btSoftBody::Anchor::m_node
Node * m_node
Definition btSoftBody.h:427
btSoftBody::Anchor::m_c0
btMatrix3x3 m_c0
Definition btSoftBody.h:431
btSoftBody::Body
Definition btSoftBody.h:514
btSoftBody::Body::invMass
btScalar invMass() const
Definition btSoftBody.h:540
btSoftBody::Body::Body
Body(Cluster *p)
Definition btSoftBody.h:520
btSoftBody::Body::invWorldInertia
const btMatrix3x3 & invWorldInertia() const
Definition btSoftBody.h:533
btSoftBody::Body::applyVImpulse
void applyVImpulse(const btVector3 &impulse, const btVector3 &rpos) const
Definition btSoftBody.h:575
btSoftBody::Body::angularVelocity
btVector3 angularVelocity() const
Definition btSoftBody.h:565
btSoftBody::Body::m_rigid
btRigidBody * m_rigid
Definition btSoftBody.h:516
btSoftBody::Body::linearVelocity
btVector3 linearVelocity() const
Definition btSoftBody.h:553
btSoftBody::Body::angularVelocity
btVector3 angularVelocity(const btVector3 &rpos) const
Definition btSoftBody.h:559
btSoftBody::Body::applyDImpulse
void applyDImpulse(const btVector3 &impulse, const btVector3 &rpos) const
Definition btSoftBody.h:580
btSoftBody::Body::Body
Body(const btCollisionObject *colObj)
Definition btSoftBody.h:521
btSoftBody::Body::velocity
btVector3 velocity(const btVector3 &rpos) const
Definition btSoftBody.h:571
btSoftBody::Body::applyDCImpulse
void applyDCImpulse(const btVector3 &impulse) const
Definition btSoftBody.h:613
btSoftBody::Body::applyDAImpulse
void applyDAImpulse(const btVector3 &impulse) const
Definition btSoftBody.h:603
btSoftBody::Body::xform
const btTransform & xform() const
Definition btSoftBody.h:546
btSoftBody::Body::activate
void activate() const
Definition btSoftBody.h:526
btSoftBody::Body::applyVAImpulse
void applyVAImpulse(const btVector3 &impulse) const
Definition btSoftBody.h:598
btSoftBody::Body::Body
Body()
Definition btSoftBody.h:519
btSoftBody::Body::m_soft
Cluster * m_soft
Definition btSoftBody.h:515
btSoftBody::Body::applyAImpulse
void applyAImpulse(const Impulse &impulse) const
Definition btSoftBody.h:608
btSoftBody::Body::applyImpulse
void applyImpulse(const Impulse &impulse, const btVector3 &rpos) const
Definition btSoftBody.h:585
btSoftBody::Body::m_collisionObject
const btCollisionObject * m_collisionObject
Definition btSoftBody.h:517
btSoftBody::CJoint
Definition btSoftBody.h:696
btSoftBody::CJoint::Terminate
void Terminate(btScalar dt)
Definition btSoftBody.cpp:3740
btSoftBody::CJoint::m_life
int m_life
Definition btSoftBody.h:697
btSoftBody::CJoint::Type
eType::_ Type() const
Definition btSoftBody.h:705
btSoftBody::CJoint::m_rpos
btVector3 m_rpos[2]
Definition btSoftBody.h:699
btSoftBody::CJoint::Prepare
void Prepare(btScalar dt, int iterations)
Definition btSoftBody.cpp:3675
btSoftBody::CJoint::m_normal
btVector3 m_normal
Definition btSoftBody.h:700
btSoftBody::CJoint::m_maxlife
int m_maxlife
Definition btSoftBody.h:698
btSoftBody::CJoint::m_friction
btScalar m_friction
Definition btSoftBody.h:701
btSoftBody::CJoint::Solve
void Solve(btScalar dt, btScalar sor)
Definition btSoftBody.cpp:3697
btSoftBody::Cluster
Definition btSoftBody.h:459
btSoftBody::Cluster::m_dimpulses
btVector3 m_dimpulses[2]
Definition btSoftBody.h:470
btSoftBody::Cluster::m_nvimpulses
int m_nvimpulses
Definition btSoftBody.h:471
btSoftBody::Cluster::m_framerefs
tVector3Array m_framerefs
Definition btSoftBody.h:462
btSoftBody::Cluster::m_invwi
btMatrix3x3 m_invwi
Definition btSoftBody.h:467
btSoftBody::Cluster::m_maxSelfCollisionImpulse
btScalar m_maxSelfCollisionImpulse
Definition btSoftBody.h:480
btSoftBody::Cluster::m_ldamping
btScalar m_ldamping
Definition btSoftBody.h:477
btSoftBody::Cluster::m_locii
btMatrix3x3 m_locii
Definition btSoftBody.h:466
btSoftBody::Cluster::m_nodes
btAlignedObjectArray< Node * > m_nodes
Definition btSoftBody.h:461
btSoftBody::Cluster::m_com
btVector3 m_com
Definition btSoftBody.h:468
btSoftBody::Cluster::m_matching
btScalar m_matching
Definition btSoftBody.h:479
btSoftBody::Cluster::m_ndamping
btScalar m_ndamping
Definition btSoftBody.h:476
btSoftBody::Cluster::m_leaf
btDbvtNode * m_leaf
Definition btSoftBody.h:475
btSoftBody::Cluster::m_lv
btVector3 m_lv
Definition btSoftBody.h:473
btSoftBody::Cluster::m_vimpulses
btVector3 m_vimpulses[2]
Definition btSoftBody.h:469
btSoftBody::Cluster::m_clusterIndex
int m_clusterIndex
Definition btSoftBody.h:484
btSoftBody::Cluster::m_imass
btScalar m_imass
Definition btSoftBody.h:465
btSoftBody::Cluster::m_collide
bool m_collide
Definition btSoftBody.h:483
btSoftBody::Cluster::Cluster
Cluster()
Definition btSoftBody.h:485
btSoftBody::Cluster::m_adamping
btScalar m_adamping
Definition btSoftBody.h:478
btSoftBody::Cluster::m_containsAnchor
bool m_containsAnchor
Definition btSoftBody.h:482
btSoftBody::Cluster::m_ndimpulses
int m_ndimpulses
Definition btSoftBody.h:472
btSoftBody::Cluster::m_masses
tScalarArray m_masses
Definition btSoftBody.h:460
btSoftBody::Cluster::m_selfCollisionImpulseFactor
btScalar m_selfCollisionImpulseFactor
Definition btSoftBody.h:481
btSoftBody::Cluster::m_framexform
btTransform m_framexform
Definition btSoftBody.h:463
btSoftBody::Cluster::m_idmass
btScalar m_idmass
Definition btSoftBody.h:464
btSoftBody::Cluster::m_av
btVector3 m_av
Definition btSoftBody.h:474
btSoftBody::Config
Definition btSoftBody.h:709
btSoftBody::Config::kDG
btScalar kDG
Definition btSoftBody.h:713
btSoftBody::Config::maxvolume
btScalar maxvolume
Definition btSoftBody.h:729
btSoftBody::Config::collisions
int collisions
Definition btSoftBody.h:735
btSoftBody::Config::kSKHR_CL
btScalar kSKHR_CL
Definition btSoftBody.h:724
btSoftBody::Config::kKHR
btScalar kKHR
Definition btSoftBody.h:720
btSoftBody::Config::citerations
int citerations
Definition btSoftBody.h:734
btSoftBody::Config::kVCF
btScalar kVCF
Definition btSoftBody.h:711
btSoftBody::Config::diterations
int diterations
Definition btSoftBody.h:733
btSoftBody::Config::piterations
int piterations
Definition btSoftBody.h:732
btSoftBody::Config::kCHR
btScalar kCHR
Definition btSoftBody.h:719
btSoftBody::Config::kDP
btScalar kDP
Definition btSoftBody.h:712
btSoftBody::Config::kDF
btScalar kDF
Definition btSoftBody.h:717
btSoftBody::Config::m_psequence
tPSolverArray m_psequence
Definition btSoftBody.h:737
btSoftBody::Config::kSSHR_CL
btScalar kSSHR_CL
Definition btSoftBody.h:725
btSoftBody::Config::kVC
btScalar kVC
Definition btSoftBody.h:716
btSoftBody::Config::m_dsequence
tPSolverArray m_dsequence
Definition btSoftBody.h:738
btSoftBody::Config::kPR
btScalar kPR
Definition btSoftBody.h:715
btSoftBody::Config::kSRHR_CL
btScalar kSRHR_CL
Definition btSoftBody.h:723
btSoftBody::Config::kSK_SPLT_CL
btScalar kSK_SPLT_CL
Definition btSoftBody.h:727
btSoftBody::Config::kSS_SPLT_CL
btScalar kSS_SPLT_CL
Definition btSoftBody.h:728
btSoftBody::Config::drag
btScalar drag
Definition btSoftBody.h:739
btSoftBody::Config::m_maxStress
btScalar m_maxStress
Definition btSoftBody.h:740
btSoftBody::Config::kMT
btScalar kMT
Definition btSoftBody.h:718
btSoftBody::Config::aeromodel
eAeroModel::_ aeromodel
Definition btSoftBody.h:710
btSoftBody::Config::kLF
btScalar kLF
Definition btSoftBody.h:714
btSoftBody::Config::kSR_SPLT_CL
btScalar kSR_SPLT_CL
Definition btSoftBody.h:726
btSoftBody::Config::m_vsequence
tVSolverArray m_vsequence
Definition btSoftBody.h:736
btSoftBody::Config::viterations
int viterations
Definition btSoftBody.h:731
btSoftBody::Config::timescale
btScalar timescale
Definition btSoftBody.h:730
btSoftBody::Config::kSHR
btScalar kSHR
Definition btSoftBody.h:721
btSoftBody::Config::kAHR
btScalar kAHR
Definition btSoftBody.h:722
btSoftBody::DeformableFaceNodeContact
Definition btSoftBody.h:400
btSoftBody::DeformableFaceNodeContact::m_bary
btVector3 m_bary
Definition btSoftBody.h:403
btSoftBody::DeformableFaceNodeContact::m_weights
btVector3 m_weights
Definition btSoftBody.h:404
btSoftBody::DeformableFaceNodeContact::m_normal
btVector3 m_normal
Definition btSoftBody.h:405
btSoftBody::DeformableFaceNodeContact::m_node
Node * m_node
Definition btSoftBody.h:401
btSoftBody::DeformableFaceNodeContact::m_margin
btScalar m_margin
Definition btSoftBody.h:406
btSoftBody::DeformableFaceNodeContact::m_face
Face * m_face
Definition btSoftBody.h:402
btSoftBody::DeformableFaceNodeContact::m_c0
btScalar m_c0
Definition btSoftBody.h:409
btSoftBody::DeformableFaceNodeContact::m_imf
btScalar m_imf
Definition btSoftBody.h:408
btSoftBody::DeformableFaceNodeContact::m_colObj
const btCollisionObject * m_colObj
Definition btSoftBody.h:410
btSoftBody::DeformableFaceNodeContact::m_friction
btScalar m_friction
Definition btSoftBody.h:407
btSoftBody::Element::m_tag
void * m_tag
Definition btSoftBody.h:243
btSoftBody::Element::Element
Element()
Definition btSoftBody.h:244
btSoftBody::Face
Definition btSoftBody.h:306
btSoftBody::Face::m_pcontact
btVector4 m_pcontact
Definition btSoftBody.h:311
btSoftBody::Face::m_ra
btScalar m_ra
Definition btSoftBody.h:309
btSoftBody::Face::m_normal
btVector3 m_normal
Definition btSoftBody.h:308
btSoftBody::Face::m_n0
btVector3 m_n0
Definition btSoftBody.h:312
btSoftBody::Face::m_n1
btVector3 m_n1
Definition btSoftBody.h:312
btSoftBody::Face::m_vn
btVector3 m_vn
Definition btSoftBody.h:312
btSoftBody::Face::m_n
Node * m_n[3]
Definition btSoftBody.h:307
btSoftBody::Face::m_index
int m_index
Definition btSoftBody.h:313
btSoftBody::Face::m_leaf
btDbvtNode * m_leaf
Definition btSoftBody.h:310
btSoftBody::Feature
Definition btSoftBody.h:257
btSoftBody::Feature::m_material
Material * m_material
Definition btSoftBody.h:258
btSoftBody::ImplicitFn
Definition btSoftBody.h:211
btSoftBody::ImplicitFn::~ImplicitFn
virtual ~ImplicitFn()
Definition btSoftBody.h:212
btSoftBody::ImplicitFn::Eval
virtual btScalar Eval(const btVector3 &x)=0
btSoftBody::Impulse
Definition btSoftBody.h:491
btSoftBody::Impulse::m_drift
btVector3 m_drift
Definition btSoftBody.h:493
btSoftBody::Impulse::Impulse
Impulse()
Definition btSoftBody.h:496
btSoftBody::Impulse::operator*
Impulse operator*(btScalar x) const
Definition btSoftBody.h:504
btSoftBody::Impulse::operator-
Impulse operator-() const
Definition btSoftBody.h:497
btSoftBody::Impulse::m_asDrift
int m_asDrift
Definition btSoftBody.h:495
btSoftBody::Impulse::m_velocity
btVector3 m_velocity
Definition btSoftBody.h:492
btSoftBody::Impulse::m_asVelocity
int m_asVelocity
Definition btSoftBody.h:494
btSoftBody::Joint::Specs
Definition btSoftBody.h:632
btSoftBody::Joint::Specs::erp
btScalar erp
Definition btSoftBody.h:634
btSoftBody::Joint::Specs::split
btScalar split
Definition btSoftBody.h:636
btSoftBody::Joint::Specs::Specs
Specs()
Definition btSoftBody.h:633
btSoftBody::Joint::Specs::cfm
btScalar cfm
Definition btSoftBody.h:635
btSoftBody::Joint::eType
Definition btSoftBody.h:623
btSoftBody::Joint::eType::_
_
Definition btSoftBody.h:625
btSoftBody::Joint::eType::Linear
@ Linear
Definition btSoftBody.h:626
btSoftBody::Joint::eType::Contact
@ Contact
Definition btSoftBody.h:628
btSoftBody::Joint::eType::Angular
@ Angular
Definition btSoftBody.h:627
btSoftBody::Joint::m_drift
btVector3 m_drift
Definition btSoftBody.h:643
btSoftBody::Joint::m_sdrift
btVector3 m_sdrift
Definition btSoftBody.h:644
btSoftBody::Joint::m_split
btScalar m_split
Definition btSoftBody.h:642
btSoftBody::Joint::Solve
virtual void Solve(btScalar dt, btScalar sor)=0
btSoftBody::Joint::m_cfm
btScalar m_cfm
Definition btSoftBody.h:640
btSoftBody::Joint::m_delete
bool m_delete
Definition btSoftBody.h:646
btSoftBody::Joint::m_bodies
Body m_bodies[2]
Definition btSoftBody.h:638
btSoftBody::Joint::Terminate
virtual void Terminate(btScalar dt)=0
btSoftBody::Joint::m_erp
btScalar m_erp
Definition btSoftBody.h:641
btSoftBody::Joint::m_massmatrix
btMatrix3x3 m_massmatrix
Definition btSoftBody.h:645
btSoftBody::Joint::~Joint
virtual ~Joint()
Definition btSoftBody.h:647
btSoftBody::Joint::Joint
Joint()
Definition btSoftBody.h:648
btSoftBody::Joint::m_refs
btVector3 m_refs[2]
Definition btSoftBody.h:639
btSoftBody::Joint::Prepare
virtual void Prepare(btScalar dt, int iterations)
Definition btSoftBody.cpp:3580
btSoftBody::Joint::Type
virtual eType::_ Type() const =0
btSoftBody::LJoint::Specs::position
btVector3 position
Definition btSoftBody.h:659
btSoftBody::LJoint
Definition btSoftBody.h:656
btSoftBody::LJoint::Solve
void Solve(btScalar dt, btScalar sor)
Definition btSoftBody.cpp:3607
btSoftBody::LJoint::m_rpos
btVector3 m_rpos[2]
Definition btSoftBody.h:661
btSoftBody::LJoint::Type
eType::_ Type() const
Definition btSoftBody.h:665
btSoftBody::LJoint::Prepare
void Prepare(btScalar dt, int iterations)
Definition btSoftBody.cpp:3587
btSoftBody::LJoint::Terminate
void Terminate(btScalar dt)
Definition btSoftBody.cpp:3620
btSoftBody::Link
Definition btSoftBody.h:288
btSoftBody::Link::m_bbending
int m_bbending
Definition btSoftBody.h:292
btSoftBody::Link::BT_DECLARE_ALIGNED_ALLOCATOR
BT_DECLARE_ALIGNED_ALLOCATOR()
btSoftBody::Link::m_c3
btVector3 m_c3
Definition btSoftBody.h:289
btSoftBody::Link::m_c0
btScalar m_c0
Definition btSoftBody.h:293
btSoftBody::Link::m_c1
btScalar m_c1
Definition btSoftBody.h:294
btSoftBody::Link::m_n
Node * m_n[2]
Definition btSoftBody.h:290
btSoftBody::Link::m_c2
btScalar m_c2
Definition btSoftBody.h:295
btSoftBody::Link::m_rl
btScalar m_rl
Definition btSoftBody.h:291
btSoftBody::Material
Definition btSoftBody.h:248
btSoftBody::Material::m_flags
int m_flags
Definition btSoftBody.h:252
btSoftBody::Material::m_kAST
btScalar m_kAST
Definition btSoftBody.h:250
btSoftBody::Material::m_kVST
btScalar m_kVST
Definition btSoftBody.h:251
btSoftBody::Material::m_kLST
btScalar m_kLST
Definition btSoftBody.h:249
btSoftBody::Node
Definition btSoftBody.h:268
btSoftBody::Node::m_im
btScalar m_im
Definition btSoftBody.h:275
btSoftBody::Node::m_area
btScalar m_area
Definition btSoftBody.h:276
btSoftBody::Node::m_x
btVector3 m_x
Definition btSoftBody.h:269
btSoftBody::Node::m_constrained
int m_constrained
Definition btSoftBody.h:278
btSoftBody::Node::m_splitv
btVector3 m_splitv
Definition btSoftBody.h:281
btSoftBody::Node::m_vn
btVector3 m_vn
Definition btSoftBody.h:272
btSoftBody::Node::m_battach
int m_battach
Definition btSoftBody.h:279
btSoftBody::Node::m_v
btVector3 m_v
Definition btSoftBody.h:271
btSoftBody::Node::m_q
btVector3 m_q
Definition btSoftBody.h:270
btSoftBody::Node::m_leaf
btDbvtNode * m_leaf
Definition btSoftBody.h:277
btSoftBody::Node::m_n
btVector3 m_n
Definition btSoftBody.h:274
btSoftBody::Node::m_f
btVector3 m_f
Definition btSoftBody.h:273
btSoftBody::Node::m_effectiveMass_inv
btMatrix3x3 m_effectiveMass_inv
Definition btSoftBody.h:283
btSoftBody::Node::index
int index
Definition btSoftBody.h:280
btSoftBody::Node::m_effectiveMass
btMatrix3x3 m_effectiveMass
Definition btSoftBody.h:282
btSoftBody::Note
Definition btSoftBody.h:437
btSoftBody::Note::m_coords
btScalar m_coords[4]
Definition btSoftBody.h:442
btSoftBody::Note::m_offset
btVector3 m_offset
Definition btSoftBody.h:439
btSoftBody::Note::m_rank
int m_rank
Definition btSoftBody.h:440
btSoftBody::Note::m_nodes
Node * m_nodes[4]
Definition btSoftBody.h:441
btSoftBody::Note::m_text
const char * m_text
Definition btSoftBody.h:438
btSoftBody::Pose
Definition btSoftBody.h:446
btSoftBody::Pose::m_scl
btMatrix3x3 m_scl
Definition btSoftBody.h:454
btSoftBody::Pose::m_bvolume
bool m_bvolume
Definition btSoftBody.h:447
btSoftBody::Pose::m_volume
btScalar m_volume
Definition btSoftBody.h:449
btSoftBody::Pose::m_com
btVector3 m_com
Definition btSoftBody.h:452
btSoftBody::Pose::m_pos
tVector3Array m_pos
Definition btSoftBody.h:450
btSoftBody::Pose::m_aqq
btMatrix3x3 m_aqq
Definition btSoftBody.h:455
btSoftBody::Pose::m_rot
btMatrix3x3 m_rot
Definition btSoftBody.h:453
btSoftBody::Pose::m_wgh
tScalarArray m_wgh
Definition btSoftBody.h:451
btSoftBody::Pose::m_bframe
bool m_bframe
Definition btSoftBody.h:448
btSoftBody::RContact
Definition btSoftBody.h:342
btSoftBody::RContact::m_c2
btScalar m_c2
Definition btSoftBody.h:347
btSoftBody::RContact::m_cti
sCti m_cti
Definition btSoftBody.h:343
btSoftBody::RContact::t1
btVector3 t1
Definition btSoftBody.h:355
btSoftBody::RContact::jacobianData_t2
btMultiBodyJacobianData jacobianData_t2
Definition btSoftBody.h:354
btSoftBody::RContact::m_c4
btScalar m_c4
Definition btSoftBody.h:349
btSoftBody::RContact::m_c1
btVector3 m_c1
Definition btSoftBody.h:346
btSoftBody::RContact::jacobianData_t1
btMultiBodyJacobianData jacobianData_t1
Definition btSoftBody.h:353
btSoftBody::RContact::t2
btVector3 t2
Definition btSoftBody.h:356
btSoftBody::RContact::m_node
Node * m_node
Definition btSoftBody.h:344
btSoftBody::RContact::m_c0
btMatrix3x3 m_c0
Definition btSoftBody.h:345
btSoftBody::RContact::m_c3
btScalar m_c3
Definition btSoftBody.h:348
btSoftBody::RContact::jacobianData_normal
btMultiBodyJacobianData jacobianData_normal
Definition btSoftBody.h:352
btSoftBody::RayFromToCaster::m_face
Face * m_face
Definition btSoftBody.h:767
btSoftBody::RayFromToCaster::RayFromToCaster
RayFromToCaster(const btVector3 &rayFrom, const btVector3 &rayTo, btScalar mxt)
Definition btSoftBody.cpp:2355
btSoftBody::RayFromToCaster::m_mint
btScalar m_mint
Definition btSoftBody.h:766
btSoftBody::RayFromToCaster::m_tests
int m_tests
Definition btSoftBody.h:768
btSoftBody::RayFromToCaster::Process
void Process(const btDbvtNode *leaf)
Definition btSoftBody.cpp:2366
btSoftBody::RayFromToCaster::rayFromToTriangle
static btScalar rayFromToTriangle(const btVector3 &rayFrom, const btVector3 &rayTo, const btVector3 &rayNormalizedDirection, const btVector3 &a, const btVector3 &b, const btVector3 &c, btScalar maxt=SIMD_INFINITY)
Definition btSoftBody.cpp:2383
btSoftBody::RayFromToCaster::m_rayTo
btVector3 m_rayTo
Definition btSoftBody.h:764
btSoftBody::RayFromToCaster::m_rayNormalizedDirection
btVector3 m_rayNormalizedDirection
Definition btSoftBody.h:765
btSoftBody::RayFromToCaster::m_rayFrom
btVector3 m_rayFrom
Definition btSoftBody.h:763
btSoftBody::RenderFace
Definition btSoftBody.h:300
btSoftBody::RenderFace::m_n
RenderNode * m_n[3]
Definition btSoftBody.h:301
btSoftBody::RenderNode
Definition btSoftBody.h:262
btSoftBody::RenderNode::m_uv1
btVector3 m_uv1
Definition btSoftBody.h:264
btSoftBody::RenderNode::m_normal
btVector3 m_normal
Definition btSoftBody.h:265
btSoftBody::RenderNode::m_x
btVector3 m_x
Definition btSoftBody.h:263
btSoftBody::SContact
Definition btSoftBody.h:415
btSoftBody::SContact::m_normal
btVector3 m_normal
Definition btSoftBody.h:419
btSoftBody::SContact::m_node
Node * m_node
Definition btSoftBody.h:416
btSoftBody::SContact::m_margin
btScalar m_margin
Definition btSoftBody.h:420
btSoftBody::SContact::m_weights
btVector3 m_weights
Definition btSoftBody.h:418
btSoftBody::SContact::m_cfm
btScalar m_cfm[2]
Definition btSoftBody.h:422
btSoftBody::SContact::m_friction
btScalar m_friction
Definition btSoftBody.h:421
btSoftBody::SContact::m_face
Face * m_face
Definition btSoftBody.h:417
btSoftBody::SolverState
Definition btSoftBody.h:744
btSoftBody::SolverState::velmrg
btScalar velmrg
Definition btSoftBody.h:756
btSoftBody::SolverState::radmrg
btScalar radmrg
Definition btSoftBody.h:757
btSoftBody::SolverState::updmrg
btScalar updmrg
Definition btSoftBody.h:758
btSoftBody::SolverState::isdt
btScalar isdt
Definition btSoftBody.h:755
btSoftBody::SolverState::sdt
btScalar sdt
Definition btSoftBody.h:754
btSoftBody::SolverState::SolverState
SolverState()
Definition btSoftBody.h:746
btSoftBody::TetraScratch
Definition btSoftBody.h:332
btSoftBody::TetraScratch::m_J
btScalar m_J
Definition btSoftBody.h:335
btSoftBody::TetraScratch::m_F
btMatrix3x3 m_F
Definition btSoftBody.h:333
btSoftBody::TetraScratch::m_cofF
btMatrix3x3 m_cofF
Definition btSoftBody.h:336
btSoftBody::TetraScratch::m_corotation
btMatrix3x3 m_corotation
Definition btSoftBody.h:337
btSoftBody::TetraScratch::m_trace
btScalar m_trace
Definition btSoftBody.h:334
btSoftBody::Tetra
Definition btSoftBody.h:317
btSoftBody::Tetra::m_c1
btScalar m_c1
Definition btSoftBody.h:322
btSoftBody::Tetra::m_element_measure
btScalar m_element_measure
Definition btSoftBody.h:326
btSoftBody::Tetra::m_Dm_inverse
btMatrix3x3 m_Dm_inverse
Definition btSoftBody.h:324
btSoftBody::Tetra::m_rv
btScalar m_rv
Definition btSoftBody.h:319
btSoftBody::Tetra::m_F
btMatrix3x3 m_F
Definition btSoftBody.h:325
btSoftBody::Tetra::m_P_inv
btVector4 m_P_inv[3]
Definition btSoftBody.h:327
btSoftBody::Tetra::m_c0
btVector3 m_c0[4]
Definition btSoftBody.h:321
btSoftBody::Tetra::m_c2
btScalar m_c2
Definition btSoftBody.h:323
btSoftBody::Tetra::m_leaf
btDbvtNode * m_leaf
Definition btSoftBody.h:320
btSoftBody::Tetra::m_n
Node * m_n[4]
Definition btSoftBody.h:318
btSoftBody::eAeroModel
eAeroModel
Definition btSoftBody.h:88
btSoftBody::eAeroModel::_
_
Definition btSoftBody.h:90
btSoftBody::eAeroModel::V_TwoSided
@ V_TwoSided
Vertex normals are oriented toward velocity.
Definition btSoftBody.h:92
btSoftBody::eAeroModel::V_OneSided
@ V_OneSided
Vertex normals are flipped to match velocity and lift and drag forces are applied.
Definition btSoftBody.h:94
btSoftBody::eAeroModel::END
@ END
Face normals are taken as it is.
Definition btSoftBody.h:98
btSoftBody::eAeroModel::V_TwoSidedLiftDrag
@ V_TwoSidedLiftDrag
Vertex normals are flipped to match velocity.
Definition btSoftBody.h:93
btSoftBody::eAeroModel::F_OneSided
@ F_OneSided
Face normals are flipped to match velocity and lift and drag forces are applied.
Definition btSoftBody.h:97
btSoftBody::eAeroModel::F_TwoSided
@ F_TwoSided
Vertex normals are taken as it is.
Definition btSoftBody.h:95
btSoftBody::eAeroModel::F_TwoSidedLiftDrag
@ F_TwoSidedLiftDrag
Face normals are flipped to match velocity.
Definition btSoftBody.h:96
btSoftBody::eAeroModel::V_Point
@ V_Point
Definition btSoftBody.h:91
btSoftBody::eFeature
eFeature
Definition btSoftBody.h:139
btSoftBody::eFeature::_
_
Definition btSoftBody.h:141
btSoftBody::eFeature::Face
@ Face
Definition btSoftBody.h:145
btSoftBody::eFeature::None
@ None
Definition btSoftBody.h:142
btSoftBody::eFeature::Node
@ Node
Definition btSoftBody.h:143
btSoftBody::eFeature::Tetra
@ Tetra
Definition btSoftBody.h:146
btSoftBody::eFeature::Link
@ Link
Definition btSoftBody.h:144
btSoftBody::eFeature::END
@ END
Definition btSoftBody.h:147
btSoftBody::ePSolver
ePSolver : positions solvers
Definition btSoftBody.h:114
btSoftBody::ePSolver::_
_
Definition btSoftBody.h:116
btSoftBody::ePSolver::RContacts
@ RContacts
Anchor solver.
Definition btSoftBody.h:119
btSoftBody::ePSolver::SContacts
@ SContacts
Rigid contacts solver.
Definition btSoftBody.h:120
btSoftBody::ePSolver::Linear
@ Linear
Definition btSoftBody.h:117
btSoftBody::ePSolver::Anchors
@ Anchors
Linear solver.
Definition btSoftBody.h:118
btSoftBody::ePSolver::END
@ END
Soft contacts solver.
Definition btSoftBody.h:121
btSoftBody::eSolverPresets
eSolverPresets
Definition btSoftBody.h:127
btSoftBody::eSolverPresets::_
_
Definition btSoftBody.h:129
btSoftBody::eSolverPresets::Velocities
@ Velocities
Definition btSoftBody.h:131
btSoftBody::eSolverPresets::END
@ END
Definition btSoftBody.h:133
btSoftBody::eSolverPresets::Default
@ Default
Definition btSoftBody.h:132
btSoftBody::eSolverPresets::Positions
@ Positions
Definition btSoftBody.h:130
btSoftBody::eVSolver
eVSolver : velocities solvers
Definition btSoftBody.h:104
btSoftBody::eVSolver::_
_
Definition btSoftBody.h:106
btSoftBody::eVSolver::Linear
@ Linear
Definition btSoftBody.h:107
btSoftBody::eVSolver::END
@ END
Linear solver.
Definition btSoftBody.h:108
btSoftBody::fCollision
fCollision
Definition btSoftBody.h:160
btSoftBody::fCollision::_
_
Definition btSoftBody.h:162
btSoftBody::fCollision::SDF_RDN
@ SDF_RDN
GJK based Multibody vs. deformable face.
Definition btSoftBody.h:177
btSoftBody::fCollision::VF_SS
@ VF_SS
Rigid versus soft mask.
Definition btSoftBody.h:169
btSoftBody::fCollision::Default
@ Default
SDF based Rigid vs. deformable node.
Definition btSoftBody.h:179
btSoftBody::fCollision::RVDFmask
@ RVDFmask
Vertex vs face soft vs soft handling.
Definition btSoftBody.h:174
btSoftBody::fCollision::VF_DD
@ VF_DD
Cluster soft body self collision.
Definition btSoftBody.h:172
btSoftBody::fCollision::CL_SS
@ CL_SS
Vertex vs face soft vs soft handling.
Definition btSoftBody.h:170
btSoftBody::fCollision::RVSmask
@ RVSmask
Definition btSoftBody.h:163
btSoftBody::fCollision::CL_SELF
@ CL_SELF
Cluster vs cluster soft vs soft handling.
Definition btSoftBody.h:171
btSoftBody::fCollision::SVSmask
@ SVSmask
rigid vs deformable
Definition btSoftBody.h:168
btSoftBody::fCollision::SDF_RS
@ SDF_RS
Rigid versus soft mask.
Definition btSoftBody.h:164
btSoftBody::fCollision::SDF_RD
@ SDF_RD
Cluster vs convex rigid vs soft.
Definition btSoftBody.h:166
btSoftBody::fCollision::END
@ END
Definition btSoftBody.h:180
btSoftBody::fCollision::SDF_RDF
@ SDF_RDF
Rigid versus deformable face mask.
Definition btSoftBody.h:175
btSoftBody::fCollision::SDF_MDF
@ SDF_MDF
GJK based Rigid vs. deformable face.
Definition btSoftBody.h:176
btSoftBody::fCollision::CL_RS
@ CL_RS
SDF based rigid vs soft.
Definition btSoftBody.h:165
btSoftBody::fMaterial
fMaterial
Definition btSoftBody.h:186
btSoftBody::fMaterial::_
_
Definition btSoftBody.h:188
btSoftBody::fMaterial::DebugDraw
@ DebugDraw
Definition btSoftBody.h:189
btSoftBody::fMaterial::END
@ END
Definition btSoftBody.h:192
btSoftBody::fMaterial::Default
@ Default
Enable debug draw.
Definition btSoftBody.h:191
btSoftBody::sCti
Definition btSoftBody.h:225
btSoftBody::sCti::m_colObj
const btCollisionObject * m_colObj
Definition btSoftBody.h:226
btSoftBody::sCti::m_bary
btVector3 m_bary
Definition btSoftBody.h:229
btSoftBody::sCti::m_offset
btScalar m_offset
Definition btSoftBody.h:228
btSoftBody::sCti::m_normal
btVector3 m_normal
Definition btSoftBody.h:227
btSoftBody::sMedium
Definition btSoftBody.h:234
btSoftBody::sMedium::m_density
btScalar m_density
Definition btSoftBody.h:237
btSoftBody::sMedium::m_pressure
btScalar m_pressure
Definition btSoftBody.h:236
btSoftBody::sMedium::m_velocity
btVector3 m_velocity
Definition btSoftBody.h:235
btSoftBody::sRayCast
Definition btSoftBody.h:202
btSoftBody::sRayCast::feature
eFeature::_ feature
soft body
Definition btSoftBody.h:204
btSoftBody::sRayCast::fraction
btScalar fraction
feature index
Definition btSoftBody.h:206
btSoftBody::sRayCast::index
int index
feature type
Definition btSoftBody.h:205
btSoftBody::sRayCast::body
btSoftBody * body
Definition btSoftBody.h:203
btSparseSdf
Definition btSparseSDF.h:59