Bullet Collision Detection & Physics Library
btSoftBody.h
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
16 
17 #ifndef _BT_SOFT_BODY_H
18 #define _BT_SOFT_BODY_H
19 
21 #include "LinearMath/btTransform.h"
24 
27 #include "btSparseSDF.h"
29 
30 //#ifdef BT_USE_DOUBLE_PRECISION
31 //#define btRigidBodyData btRigidBodyDoubleData
32 //#define btRigidBodyDataName "btRigidBodyDoubleData"
33 //#else
34 #define btSoftBodyData btSoftBodyFloatData
35 #define btSoftBodyDataName "btSoftBodyFloatData"
36 //#endif //BT_USE_DOUBLE_PRECISION
37 
39 class btDispatcher;
40 class btSoftBodySolver;
41 
42 /* btSoftBodyWorldInfo */
44 {
54 
56  :air_density((btScalar)1.2),
57  water_density(0),
58  water_offset(0),
59  m_maxDisplacement(1000.f),//avoid soft body from 'exploding' so use some upper threshold of maximum motion that a node can travel per frame
60  water_normal(0,0,0),
61  m_broadphase(0),
62  m_dispatcher(0),
63  m_gravity(0,-10,0)
64  {
65  }
66 };
67 
68 
72 {
73 public:
75 
76  // The solver object that handles this soft body
78 
79  //
80  // Enumerations
81  //
82 
84  struct eAeroModel { enum _ {
92  END
93  };};
94 
96  struct eVSolver { enum _ {
98  END
99  };};
100 
102  struct ePSolver { enum _ {
107  END
108  };};
109 
111  struct eSolverPresets { enum _ {
114  Default = Positions,
115  END
116  };};
117 
119  struct eFeature { enum _ {
125  END
126  };};
127 
130 
131  //
132  // Flags
133  //
134 
136  struct fCollision { enum _ {
137  RVSmask = 0x000f,
138  SDF_RS = 0x0001,
139  CL_RS = 0x0002,
140 
141  SVSmask = 0x0030,
142  VF_SS = 0x0010,
143  CL_SS = 0x0020,
144  CL_SELF = 0x0040,
145  /* presets */
146  Default = SDF_RS,
147  END
148  };};
149 
151  struct fMaterial { enum _ {
152  DebugDraw = 0x0001,
153  /* presets */
154  Default = DebugDraw,
155  END
156  };};
157 
158  //
159  // API Types
160  //
161 
162  /* sRayCast */
163  struct sRayCast
164  {
167  int index;
169  };
170 
171  /* ImplicitFn */
172  struct ImplicitFn
173  {
174  virtual ~ImplicitFn() {}
175  virtual btScalar Eval(const btVector3& x)=0;
176  };
177 
178  //
179  // Internal types
180  //
181 
184 
185  /* sCti is Softbody contact info */
186  struct sCti
187  {
188  const btCollisionObject* m_colObj; /* Rigid body */
189  btVector3 m_normal; /* Outward normal */
190  btScalar m_offset; /* Offset from origin */
191  };
192 
193  /* sMedium */
194  struct sMedium
195  {
196  btVector3 m_velocity; /* Velocity */
197  btScalar m_pressure; /* Pressure */
198  btScalar m_density; /* Density */
199  };
200 
201  /* Base type */
202  struct Element
203  {
204  void* m_tag; // User data
205  Element() : m_tag(0) {}
206  };
207  /* Material */
208  struct Material : Element
209  {
210  btScalar m_kLST; // Linear stiffness coefficient [0,1]
211  btScalar m_kAST; // Area/Angular stiffness coefficient [0,1]
212  btScalar m_kVST; // Volume stiffness coefficient [0,1]
213  int m_flags; // Flags
214  };
215 
216  /* Feature */
217  struct Feature : Element
218  {
219  Material* m_material; // Material
220  };
221  /* Node */
222  struct Node : Feature
223  {
224  btVector3 m_x; // Position
225  btVector3 m_q; // Previous step position
226  btVector3 m_v; // Velocity
227  btVector3 m_f; // Force accumulator
228  btVector3 m_n; // Normal
229  btScalar m_im; // 1/mass
230  btScalar m_area; // Area
231  btDbvtNode* m_leaf; // Leaf data
232  int m_battach:1; // Attached
233  };
234  /* Link */
235  struct Link : Feature
236  {
237  Node* m_n[2]; // Node pointers
238  btScalar m_rl; // Rest length
239  int m_bbending:1; // Bending link
240  btScalar m_c0; // (ima+imb)*kLST
241  btScalar m_c1; // rl^2
242  btScalar m_c2; // |gradient|^2/c0
243  btVector3 m_c3; // gradient
244  };
245  /* Face */
246  struct Face : Feature
247  {
248  Node* m_n[3]; // Node pointers
249  btVector3 m_normal; // Normal
250  btScalar m_ra; // Rest area
251  btDbvtNode* m_leaf; // Leaf data
252  };
253  /* Tetra */
254  struct Tetra : Feature
255  {
256  Node* m_n[4]; // Node pointers
257  btScalar m_rv; // Rest volume
258  btDbvtNode* m_leaf; // Leaf data
259  btVector3 m_c0[4]; // gradients
260  btScalar m_c1; // (4*kVST)/(im0+im1+im2+im3)
261  btScalar m_c2; // m_c1/sum(|g0..3|^2)
262  };
263  /* RContact */
264  struct RContact
265  {
266  sCti m_cti; // Contact infos
267  Node* m_node; // Owner node
268  btMatrix3x3 m_c0; // Impulse matrix
269  btVector3 m_c1; // Relative anchor
270  btScalar m_c2; // ima*dt
271  btScalar m_c3; // Friction
272  btScalar m_c4; // Hardness
273  };
274  /* SContact */
275  struct SContact
276  {
277  Node* m_node; // Node
278  Face* m_face; // Face
279  btVector3 m_weights; // Weigths
280  btVector3 m_normal; // Normal
281  btScalar m_margin; // Margin
282  btScalar m_friction; // Friction
283  btScalar m_cfm[2]; // Constraint force mixing
284  };
285  /* Anchor */
286  struct Anchor
287  {
288  Node* m_node; // Node pointer
289  btVector3 m_local; // Anchor position in body space
290  btRigidBody* m_body; // Body
292  btMatrix3x3 m_c0; // Impulse matrix
293  btVector3 m_c1; // Relative anchor
294  btScalar m_c2; // ima*dt
295  };
296  /* Note */
297  struct Note : Element
298  {
299  const char* m_text; // Text
300  btVector3 m_offset; // Offset
301  int m_rank; // Rank
302  Node* m_nodes[4]; // Nodes
303  btScalar m_coords[4]; // Coordinates
304  };
305  /* Pose */
306  struct Pose
307  {
308  bool m_bvolume; // Is valid
309  bool m_bframe; // Is frame
310  btScalar m_volume; // Rest volume
311  tVector3Array m_pos; // Reference positions
312  tScalarArray m_wgh; // Weights
313  btVector3 m_com; // COM
314  btMatrix3x3 m_rot; // Rotation
315  btMatrix3x3 m_scl; // Scale
316  btMatrix3x3 m_aqq; // Base scaling
317  };
318  /* Cluster */
319  struct Cluster
320  {
321  tScalarArray m_masses;
323  tVector3Array m_framerefs;
330  btVector3 m_vimpulses[2];
331  btVector3 m_dimpulses[2];
337  btScalar m_ndamping; /* Node damping */
338  btScalar m_ldamping; /* Linear damping */
339  btScalar m_adamping; /* Angular damping */
344  bool m_collide;
346  Cluster() : m_leaf(0),m_ndamping(0),m_ldamping(0),m_adamping(0),m_matching(0)
347  ,m_maxSelfCollisionImpulse(100.f),
348  m_selfCollisionImpulseFactor(0.01f),
349  m_containsAnchor(false)
350  {}
351  };
352  /* Impulse */
353  struct Impulse
354  {
357  int m_asVelocity:1;
358  int m_asDrift:1;
359  Impulse() : m_velocity(0,0,0),m_drift(0,0,0),m_asVelocity(0),m_asDrift(0) {}
361  {
362  Impulse i=*this;
363  i.m_velocity=-i.m_velocity;
364  i.m_drift=-i.m_drift;
365  return(i);
366  }
368  {
369  Impulse i=*this;
370  i.m_velocity*=x;
371  i.m_drift*=x;
372  return(i);
373  }
374  };
375  /* Body */
376  struct Body
377  {
381 
382  Body() : m_soft(0),m_rigid(0),m_collisionObject(0) {}
383  Body(Cluster* p) : m_soft(p),m_rigid(0),m_collisionObject(0) {}
384  Body(const btCollisionObject* colObj) : m_soft(0),m_collisionObject(colObj)
385  {
386  m_rigid = (btRigidBody*)btRigidBody::upcast(m_collisionObject);
387  }
388 
389  void activate() const
390  {
391  if(m_rigid)
392  m_rigid->activate();
393  if (m_collisionObject)
394  m_collisionObject->activate();
395 
396  }
398  {
399  static const btMatrix3x3 iwi(0,0,0,0,0,0,0,0,0);
400  if(m_rigid) return(m_rigid->getInvInertiaTensorWorld());
401  if(m_soft) return(m_soft->m_invwi);
402  return(iwi);
403  }
405  {
406  if(m_rigid) return(m_rigid->getInvMass());
407  if(m_soft) return(m_soft->m_imass);
408  return(0);
409  }
410  const btTransform& xform() const
411  {
412  static const btTransform identity=btTransform::getIdentity();
413  if(m_collisionObject) return(m_collisionObject->getWorldTransform());
414  if(m_soft) return(m_soft->m_framexform);
415  return(identity);
416  }
418  {
419  if(m_rigid) return(m_rigid->getLinearVelocity());
420  if(m_soft) return(m_soft->m_lv);
421  return(btVector3(0,0,0));
422  }
424  {
425  if(m_rigid) return(btCross(m_rigid->getAngularVelocity(),rpos));
426  if(m_soft) return(btCross(m_soft->m_av,rpos));
427  return(btVector3(0,0,0));
428  }
430  {
431  if(m_rigid) return(m_rigid->getAngularVelocity());
432  if(m_soft) return(m_soft->m_av);
433  return(btVector3(0,0,0));
434  }
435  btVector3 velocity(const btVector3& rpos) const
436  {
437  return(linearVelocity()+angularVelocity(rpos));
438  }
439  void applyVImpulse(const btVector3& impulse,const btVector3& rpos) const
440  {
441  if(m_rigid) m_rigid->applyImpulse(impulse,rpos);
442  if(m_soft) btSoftBody::clusterVImpulse(m_soft,rpos,impulse);
443  }
444  void applyDImpulse(const btVector3& impulse,const btVector3& rpos) const
445  {
446  if(m_rigid) m_rigid->applyImpulse(impulse,rpos);
447  if(m_soft) btSoftBody::clusterDImpulse(m_soft,rpos,impulse);
448  }
449  void applyImpulse(const Impulse& impulse,const btVector3& rpos) const
450  {
451  if(impulse.m_asVelocity)
452  {
453 // printf("impulse.m_velocity = %f,%f,%f\n",impulse.m_velocity.getX(),impulse.m_velocity.getY(),impulse.m_velocity.getZ());
454  applyVImpulse(impulse.m_velocity,rpos);
455  }
456  if(impulse.m_asDrift)
457  {
458 // printf("impulse.m_drift = %f,%f,%f\n",impulse.m_drift.getX(),impulse.m_drift.getY(),impulse.m_drift.getZ());
459  applyDImpulse(impulse.m_drift,rpos);
460  }
461  }
462  void applyVAImpulse(const btVector3& impulse) const
463  {
464  if(m_rigid) m_rigid->applyTorqueImpulse(impulse);
465  if(m_soft) btSoftBody::clusterVAImpulse(m_soft,impulse);
466  }
467  void applyDAImpulse(const btVector3& impulse) const
468  {
469  if(m_rigid) m_rigid->applyTorqueImpulse(impulse);
470  if(m_soft) btSoftBody::clusterDAImpulse(m_soft,impulse);
471  }
472  void applyAImpulse(const Impulse& impulse) const
473  {
474  if(impulse.m_asVelocity) applyVAImpulse(impulse.m_velocity);
475  if(impulse.m_asDrift) applyDAImpulse(impulse.m_drift);
476  }
477  void applyDCImpulse(const btVector3& impulse) const
478  {
479  if(m_rigid) m_rigid->applyCentralImpulse(impulse);
480  if(m_soft) btSoftBody::clusterDCImpulse(m_soft,impulse);
481  }
482  };
483  /* Joint */
484  struct Joint
485  {
486  struct eType { enum _ {
487  Linear=0,
489  Contact
490  };};
491  struct Specs
492  {
493  Specs() : erp(1),cfm(1),split(1) {}
497  };
498  Body m_bodies[2];
499  btVector3 m_refs[2];
506  bool m_delete;
507  virtual ~Joint() {}
508  Joint() : m_delete(false) {}
509  virtual void Prepare(btScalar dt,int iterations);
510  virtual void Solve(btScalar dt,btScalar sor)=0;
511  virtual void Terminate(btScalar dt)=0;
512  virtual eType::_ Type() const=0;
513  };
514  /* LJoint */
515  struct LJoint : Joint
516  {
518  {
520  };
521  btVector3 m_rpos[2];
522  void Prepare(btScalar dt,int iterations);
523  void Solve(btScalar dt,btScalar sor);
524  void Terminate(btScalar dt);
525  eType::_ Type() const { return(eType::Linear); }
526  };
527  /* AJoint */
528  struct AJoint : Joint
529  {
530  struct IControl
531  {
532  virtual ~IControl() {}
533  virtual void Prepare(AJoint*) {}
534  virtual btScalar Speed(AJoint*,btScalar current) { return(current); }
535  static IControl* Default() { static IControl def;return(&def); }
536  };
538  {
539  Specs() : icontrol(IControl::Default()) {}
542  };
543  btVector3 m_axis[2];
545  void Prepare(btScalar dt,int iterations);
546  void Solve(btScalar dt,btScalar sor);
547  void Terminate(btScalar dt);
548  eType::_ Type() const { return(eType::Angular); }
549  };
550  /* CJoint */
551  struct CJoint : Joint
552  {
553  int m_life;
555  btVector3 m_rpos[2];
558  void Prepare(btScalar dt,int iterations);
559  void Solve(btScalar dt,btScalar sor);
560  void Terminate(btScalar dt);
561  eType::_ Type() const { return(eType::Contact); }
562  };
563  /* Config */
564  struct Config
565  {
566  eAeroModel::_ aeromodel; // Aerodynamic model (default: V_Point)
567  btScalar kVCF; // Velocities correction factor (Baumgarte)
568  btScalar kDP; // Damping coefficient [0,1]
569  btScalar kDG; // Drag coefficient [0,+inf]
570  btScalar kLF; // Lift coefficient [0,+inf]
571  btScalar kPR; // Pressure coefficient [-inf,+inf]
572  btScalar kVC; // Volume conversation coefficient [0,+inf]
573  btScalar kDF; // Dynamic friction coefficient [0,1]
574  btScalar kMT; // Pose matching coefficient [0,1]
575  btScalar kCHR; // Rigid contacts hardness [0,1]
576  btScalar kKHR; // Kinetic contacts hardness [0,1]
577  btScalar kSHR; // Soft contacts hardness [0,1]
578  btScalar kAHR; // Anchors hardness [0,1]
579  btScalar kSRHR_CL; // Soft vs rigid hardness [0,1] (cluster only)
580  btScalar kSKHR_CL; // Soft vs kinetic hardness [0,1] (cluster only)
581  btScalar kSSHR_CL; // Soft vs soft hardness [0,1] (cluster only)
582  btScalar kSR_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
583  btScalar kSK_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
584  btScalar kSS_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
585  btScalar maxvolume; // Maximum volume ratio for pose
586  btScalar timescale; // Time scale
587  int viterations; // Velocities solver iterations
588  int piterations; // Positions solver iterations
589  int diterations; // Drift solver iterations
590  int citerations; // Cluster solver iterations
591  int collisions; // Collisions flags
592  tVSolverArray m_vsequence; // Velocity solvers sequence
593  tPSolverArray m_psequence; // Position solvers sequence
594  tPSolverArray m_dsequence; // Drift solvers sequence
595  };
596  /* SolverState */
597  struct SolverState
598  {
599  btScalar sdt; // dt*timescale
600  btScalar isdt; // 1/sdt
601  btScalar velmrg; // velocity margin
602  btScalar radmrg; // radial margin
603  btScalar updmrg; // Update margin
604  };
607  {
613  int m_tests;
614  RayFromToCaster(const btVector3& rayFrom,const btVector3& rayTo,btScalar mxt);
615  void Process(const btDbvtNode* leaf);
616 
617  static inline btScalar rayFromToTriangle(const btVector3& rayFrom,
618  const btVector3& rayTo,
619  const btVector3& rayNormalizedDirection,
620  const btVector3& a,
621  const btVector3& b,
622  const btVector3& c,
623  btScalar maxt=SIMD_INFINITY);
624  };
625 
626  //
627  // Typedefs
628  //
629 
630  typedef void (*psolver_t)(btSoftBody*,btScalar,btScalar);
631  typedef void (*vsolver_t)(btSoftBody*,btScalar);
645 
646  //
647  // Fields
648  //
649 
650  Config m_cfg; // Configuration
651  SolverState m_sst; // Solver state
652  Pose m_pose; // Pose
653  void* m_tag; // User data
655  tNoteArray m_notes; // Notes
656  tNodeArray m_nodes; // Nodes
657  tLinkArray m_links; // Links
658  tFaceArray m_faces; // Faces
659  tTetraArray m_tetras; // Tetras
660  tAnchorArray m_anchors; // Anchors
661  tRContactArray m_rcontacts; // Rigid contacts
662  tSContactArray m_scontacts; // Soft contacts
663  tJointArray m_joints; // Joints
664  tMaterialArray m_materials; // Materials
665  btScalar m_timeacc; // Time accumulator
666  btVector3 m_bounds[2]; // Spatial bounds
667  bool m_bUpdateRtCst; // Update runtime constants
668  btDbvt m_ndbvt; // Nodes tree
669  btDbvt m_fdbvt; // Faces tree
670  btDbvt m_cdbvt; // Clusters tree
671  tClusterArray m_clusters; // Clusters
672 
673  btAlignedObjectArray<bool>m_clusterConnectivity;//cluster connectivity, for self-collision
674 
676 
678 
680 
681  //
682  // Api
683  //
684 
685  /* ctor */
686  btSoftBody( btSoftBodyWorldInfo* worldInfo,int node_count, const btVector3* x, const btScalar* m);
687 
688  /* ctor */
689  btSoftBody( btSoftBodyWorldInfo* worldInfo);
690 
691  void initDefaults();
692 
693  /* dtor */
694  virtual ~btSoftBody();
695  /* Check for existing link */
696 
698 
700  {
701  return m_worldInfo;
702  }
703 
705  virtual void setCollisionShape(btCollisionShape* collisionShape)
706  {
707 
708  }
709 
710  bool checkLink( int node0,
711  int node1) const;
712  bool checkLink( const Node* node0,
713  const Node* node1) const;
714  /* Check for existring face */
715  bool checkFace( int node0,
716  int node1,
717  int node2) const;
718  /* Append material */
719  Material* appendMaterial();
720  /* Append note */
721  void appendNote( const char* text,
722  const btVector3& o,
723  const btVector4& c=btVector4(1,0,0,0),
724  Node* n0=0,
725  Node* n1=0,
726  Node* n2=0,
727  Node* n3=0);
728  void appendNote( const char* text,
729  const btVector3& o,
730  Node* feature);
731  void appendNote( const char* text,
732  const btVector3& o,
733  Link* feature);
734  void appendNote( const char* text,
735  const btVector3& o,
736  Face* feature);
737  /* Append node */
738  void appendNode( const btVector3& x,btScalar m);
739  /* Append link */
740  void appendLink(int model=-1,Material* mat=0);
741  void appendLink( int node0,
742  int node1,
743  Material* mat=0,
744  bool bcheckexist=false);
745  void appendLink( Node* node0,
746  Node* node1,
747  Material* mat=0,
748  bool bcheckexist=false);
749  /* Append face */
750  void appendFace(int model=-1,Material* mat=0);
751  void appendFace( int node0,
752  int node1,
753  int node2,
754  Material* mat=0);
755  void appendTetra(int model,Material* mat);
756  //
757  void appendTetra(int node0,
758  int node1,
759  int node2,
760  int node3,
761  Material* mat=0);
762 
763 
764  /* Append anchor */
765  void appendAnchor( int node,
766  btRigidBody* body, bool disableCollisionBetweenLinkedBodies=false,btScalar influence = 1);
767  void appendAnchor(int node,btRigidBody* body, const btVector3& localPivot,bool disableCollisionBetweenLinkedBodies=false,btScalar influence = 1);
768  /* Append linear joint */
769  void appendLinearJoint(const LJoint::Specs& specs,Cluster* body0,Body body1);
770  void appendLinearJoint(const LJoint::Specs& specs,Body body=Body());
771  void appendLinearJoint(const LJoint::Specs& specs,btSoftBody* body);
772  /* Append linear joint */
773  void appendAngularJoint(const AJoint::Specs& specs,Cluster* body0,Body body1);
774  void appendAngularJoint(const AJoint::Specs& specs,Body body=Body());
775  void appendAngularJoint(const AJoint::Specs& specs,btSoftBody* body);
776  /* Add force (or gravity) to the entire body */
777  void addForce( const btVector3& force);
778  /* Add force (or gravity) to a node of the body */
779  void addForce( const btVector3& force,
780  int node);
781  /* Add aero force to a node of the body */
782  void addAeroForceToNode(const btVector3& windVelocity,int nodeIndex);
783 
784  /* Add aero force to a face of the body */
785  void addAeroForceToFace(const btVector3& windVelocity,int faceIndex);
786 
787  /* Add velocity to the entire body */
788  void addVelocity( const btVector3& velocity);
789 
790  /* Set velocity for the entire body */
791  void setVelocity( const btVector3& velocity);
792 
793  /* Add velocity to a node of the body */
794  void addVelocity( const btVector3& velocity,
795  int node);
796  /* Set mass */
797  void setMass( int node,
798  btScalar mass);
799  /* Get mass */
800  btScalar getMass( int node) const;
801  /* Get total mass */
802  btScalar getTotalMass() const;
803  /* Set total mass (weighted by previous masses) */
804  void setTotalMass( btScalar mass,
805  bool fromfaces=false);
806  /* Set total density */
807  void setTotalDensity(btScalar density);
808  /* Set volume mass (using tetrahedrons) */
809  void setVolumeMass( btScalar mass);
810  /* Set volume density (using tetrahedrons) */
811  void setVolumeDensity( btScalar density);
812  /* Transform */
813  void transform( const btTransform& trs);
814  /* Translate */
815  void translate( const btVector3& trs);
816  /* Rotate */
817  void rotate( const btQuaternion& rot);
818  /* Scale */
819  void scale( const btVector3& scl);
820  /* Get link resting lengths scale */
821  btScalar getRestLengthScale();
822  /* Scale resting length of all springs */
823  void setRestLengthScale(btScalar restLength);
824  /* Set current state as pose */
825  void setPose( bool bvolume,
826  bool bframe);
827  /* Set current link lengths as resting lengths */
828  void resetLinkRestLengths();
829  /* Return the volume */
830  btScalar getVolume() const;
831  /* Cluster count */
832  int clusterCount() const;
833  /* Cluster center of mass */
834  static btVector3 clusterCom(const Cluster* cluster);
835  btVector3 clusterCom(int cluster) const;
836  /* Cluster velocity at rpos */
837  static btVector3 clusterVelocity(const Cluster* cluster,const btVector3& rpos);
838  /* Cluster impulse */
839  static void clusterVImpulse(Cluster* cluster,const btVector3& rpos,const btVector3& impulse);
840  static void clusterDImpulse(Cluster* cluster,const btVector3& rpos,const btVector3& impulse);
841  static void clusterImpulse(Cluster* cluster,const btVector3& rpos,const Impulse& impulse);
842  static void clusterVAImpulse(Cluster* cluster,const btVector3& impulse);
843  static void clusterDAImpulse(Cluster* cluster,const btVector3& impulse);
844  static void clusterAImpulse(Cluster* cluster,const Impulse& impulse);
845  static void clusterDCImpulse(Cluster* cluster,const btVector3& impulse);
846  /* Generate bending constraints based on distance in the adjency graph */
847  int generateBendingConstraints( int distance,
848  Material* mat=0);
849  /* Randomize constraints to reduce solver bias */
850  void randomizeConstraints();
851  /* Release clusters */
852  void releaseCluster(int index);
853  void releaseClusters();
854  /* Generate clusters (K-mean) */
857  int generateClusters(int k,int maxiterations=8192);
858  /* Refine */
859  void refine(ImplicitFn* ifn,btScalar accurary,bool cut);
860  /* CutLink */
861  bool cutLink(int node0,int node1,btScalar position);
862  bool cutLink(const Node* node0,const Node* node1,btScalar position);
863 
865  bool rayTest(const btVector3& rayFrom,
866  const btVector3& rayTo,
867  sRayCast& results);
868  /* Solver presets */
869  void setSolver(eSolverPresets::_ preset);
870  /* predictMotion */
871  void predictMotion(btScalar dt);
872  /* solveConstraints */
873  void solveConstraints();
874  /* staticSolve */
875  void staticSolve(int iterations);
876  /* solveCommonConstraints */
877  static void solveCommonConstraints(btSoftBody** bodies,int count,int iterations);
878  /* solveClusters */
879  static void solveClusters(const btAlignedObjectArray<btSoftBody*>& bodies);
880  /* integrateMotion */
881  void integrateMotion();
882  /* defaultCollisionHandlers */
883  void defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap);
884  void defaultCollisionHandler(btSoftBody* psb);
885 
886 
887 
888  //
889  // Functionality to deal with new accelerated solvers.
890  //
891 
895  void setWindVelocity( const btVector3 &velocity );
896 
897 
901  const btVector3& getWindVelocity();
902 
903  //
904  // Set the solver that handles this soft body
905  // Should not be allowed to get out of sync with reality
906  // Currently called internally on addition to the world
907  void setSoftBodySolver( btSoftBodySolver *softBodySolver )
908  {
909  m_softBodySolver = softBodySolver;
910  }
911 
912  //
913  // Return the solver that handles this soft body
914  //
916  {
917  return m_softBodySolver;
918  }
919 
920  //
921  // Return the solver that handles this soft body
922  //
924  {
925  return m_softBodySolver;
926  }
927 
928 
929  //
930  // Cast
931  //
932 
933  static const btSoftBody* upcast(const btCollisionObject* colObj)
934  {
935  if (colObj->getInternalType()==CO_SOFT_BODY)
936  return (const btSoftBody*)colObj;
937  return 0;
938  }
939  static btSoftBody* upcast(btCollisionObject* colObj)
940  {
941  if (colObj->getInternalType()==CO_SOFT_BODY)
942  return (btSoftBody*)colObj;
943  return 0;
944  }
945 
946  //
947  // ::btCollisionObject
948  //
949 
950  virtual void getAabb(btVector3& aabbMin,btVector3& aabbMax) const
951  {
952  aabbMin = m_bounds[0];
953  aabbMax = m_bounds[1];
954  }
955  //
956  // Private
957  //
958  void pointersToIndices();
959  void indicesToPointers(const int* map=0);
960 
961  int rayTest(const btVector3& rayFrom,const btVector3& rayTo,
962  btScalar& mint,eFeature::_& feature,int& index,bool bcountonly) const;
963  void initializeFaceTree();
964  btVector3 evaluateCom() const;
965  bool checkContact(const btCollisionObjectWrapper* colObjWrap,const btVector3& x,btScalar margin,btSoftBody::sCti& cti) const;
966  void updateNormals();
967  void updateBounds();
968  void updatePose();
969  void updateConstants();
970  void updateLinkConstants();
971  void updateArea(bool averageArea = true);
972  void initializeClusters();
973  void updateClusters();
974  void cleanupClusters();
975  void prepareClusters(int iterations);
976  void solveClusters(btScalar sor);
977  void applyClusters(bool drift);
978  void dampClusters();
979  void applyForces();
980  static void PSolve_Anchors(btSoftBody* psb,btScalar kst,btScalar ti);
981  static void PSolve_RContacts(btSoftBody* psb,btScalar kst,btScalar ti);
982  static void PSolve_SContacts(btSoftBody* psb,btScalar,btScalar ti);
983  static void PSolve_Links(btSoftBody* psb,btScalar kst,btScalar ti);
984  static void VSolve_Links(btSoftBody* psb,btScalar kst);
985  static psolver_t getSolver(ePSolver::_ solver);
986  static vsolver_t getSolver(eVSolver::_ solver);
987 
988 
989  virtual int calculateSerializeBufferSize() const;
990 
992  virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
993 
994  //virtual void serializeSingleObject(class btSerializer* serializer) const;
995 
996 
997 };
998 
999 
1000 
1001 
1002 #endif //_BT_SOFT_BODY_H
btScalar getInvMass() const
Definition: btRigidBody.h:270
const btCollisionObject * m_colObj
Definition: btSoftBody.h:188
btVector3 m_velocity
Definition: btSoftBody.h:355
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don&#39;t store a rigidbody pointer but a rigidbody ...
Definition: btRigidBody.h:200
btMatrix3x3 m_scl
Definition: btSoftBody.h:315
Impulse operator*(btScalar x) const
Definition: btSoftBody.h:367
eFeature::_ feature
soft body
Definition: btSoftBody.h:166
Rigid contacts solver.
Definition: btSoftBody.h:106
btScalar kSS_SPLT_CL
Definition: btSoftBody.h:584
btAlignedObjectArray< Link > tLinkArray
Definition: btSoftBody.h:636
int index
feature type
Definition: btSoftBody.h:167
Vertex normals are oriented toward velocity.
Definition: btSoftBody.h:86
btScalar m_maxDisplacement
Definition: btSoftBody.h:48
Config m_cfg
Definition: btSoftBody.h:650
btMatrix3x3 m_c0
Definition: btSoftBody.h:268
btVector3 linearVelocity() const
Definition: btSoftBody.h:417
btVector3 m_normal
Definition: btSoftBody.h:189
Body(Cluster *p)
Definition: btSoftBody.h:383
btScalar water_offset
Definition: btSoftBody.h:47
void applyTorqueImpulse(const btVector3 &torque)
Definition: btRigidBody.h:326
btMatrix3x3 m_locii
Definition: btSoftBody.h:327
btAlignedObjectArray< ePSolver::_ > tPSolverArray
Definition: btSoftBody.h:129
btVector3 angularVelocity() const
Definition: btSoftBody.h:429
Vertex normals are flipped to match velocity.
Definition: btSoftBody.h:87
btScalar m_restLengthScale
Definition: btSoftBody.h:679
Cluster * m_soft
Definition: btSoftBody.h:378
tVector3Array m_framerefs
Definition: btSoftBody.h:323
btAlignedObjectArray< btVector3 > tVector3Array
Definition: btSoftBody.h:183
Body(const btCollisionObject *colObj)
Definition: btSoftBody.h:384
btScalar kSK_SPLT_CL
Definition: btSoftBody.h:583
int getInternalType() const
reserved for Bullet internal usage
btMatrix3x3 m_c0
Definition: btSoftBody.h:292
tJointArray m_joints
Definition: btSoftBody.h:663
btAlignedObjectArray< bool > m_clusterConnectivity
Definition: btSoftBody.h:673
btScalar m_split
Definition: btSoftBody.h:502
btAlignedObjectArray< Cluster * > tClusterArray
Definition: btSoftBody.h:632
btVector3 angularVelocity(const btVector3 &rpos) const
Definition: btSoftBody.h:423
btAlignedObjectArray< Node * > m_nodes
Definition: btSoftBody.h:322
btAlignedObjectArray< btScalar > tScalarArray
Definition: btSoftBody.h:182
static void clusterVImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
Definition: btSoftBody.cpp:974
btDispatcher * m_dispatcher
Definition: btSoftBody.h:51
The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes ...
Definition: btDbvt.h:194
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
void * m_tag
Definition: btSoftBody.h:653
btScalar fraction
feature index
Definition: btSoftBody.h:168
btVector3 m_windVelocity
Definition: btSoftBody.h:677
virtual btScalar Speed(AJoint *, btScalar current)
Definition: btSoftBody.h:534
const btMatrix3x3 & invWorldInertia() const
Definition: btSoftBody.h:397
tSContactArray m_scontacts
Definition: btSoftBody.h:662
btAlignedObjectArray< Face > tFaceArray
Definition: btSoftBody.h:637
btAlignedObjectArray< RContact > tRContactArray
Definition: btSoftBody.h:640
btDbvt m_fdbvt
Definition: btSoftBody.h:669
btAlignedObjectArray< int > m_userIndexMapping
Definition: btSoftBody.h:697
static IControl * Default()
Definition: btSoftBody.h:535
btAlignedObjectArray< Tetra > tTetraArray
Definition: btSoftBody.h:638
btVector3 water_normal
Definition: btSoftBody.h:49
const btTransform & xform() const
Definition: btSoftBody.h:410
btMatrix3x3 m_aqq
Definition: btSoftBody.h:316
Vertex normals are taken as it is.
Definition: btSoftBody.h:89
btTransform m_initialWorldTransform
Definition: btSoftBody.h:675
btDbvtNode * m_leaf
Definition: btSoftBody.h:251
static btSoftBody * upcast(btCollisionObject *colObj)
Definition: btSoftBody.h:939
tNodeArray m_nodes
Definition: btSoftBody.h:656
tLinkArray m_links
Definition: btSoftBody.h:657
btVector3 m_normal
Definition: btSoftBody.h:249
btAlignedObjectArray< btDbvtNode * > tLeafArray
Definition: btSoftBody.h:635
btSoftBodyWorldInfo * m_worldInfo
Definition: btSoftBody.h:654
tTetraArray m_tetras
Definition: btSoftBody.h:659
virtual void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
Definition: btSoftBody.h:950
btSparseSdf< 3 > m_sparsesdf
Definition: btSoftBody.h:53
const char * m_text
Definition: btSoftBody.h:299
btVector3 btCross(const btVector3 &v1, const btVector3 &v2)
Return the cross product of two vectors.
Definition: btVector3.h:919
virtual void setCollisionShape(btCollisionShape *collisionShape)
Definition: btSoftBody.h:705
#define SIMD_INFINITY
Definition: btScalar.h:495
btTransform & getWorldTransform()
Material * m_material
Definition: btSoftBody.h:219
void applyDImpulse(const btVector3 &impulse, const btVector3 &rpos) const
Definition: btSoftBody.h:444
btVector3 m_offset
Definition: btSoftBody.h:300
btScalar kSR_SPLT_CL
Definition: btSoftBody.h:582
btSoftBodyWorldInfo * getWorldInfo()
Definition: btSoftBody.h:699
virtual ~Joint()
Definition: btSoftBody.h:507
btVector3 m_sdrift
Definition: btSoftBody.h:504
btVector3 m_normal
Definition: btSoftBody.h:556
btVector3 m_velocity
Definition: btSoftBody.h:196
Vertex normals are flipped to match velocity and lift and drag forces are applied.
Definition: btSoftBody.h:88
btAlignedObjectArray< Material * > tMaterialArray
Definition: btSoftBody.h:642
tMaterialArray m_materials
Definition: btSoftBody.h:664
static void clusterDImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
Definition: btSoftBody.cpp:984
btSoftBodySolver * getSoftBodySolver() const
Definition: btSoftBody.h:923
static const btSoftBody * upcast(const btCollisionObject *colObj)
Definition: btSoftBody.h:933
const btCollisionObject * m_collisionObject
Definition: btSoftBody.h:380
btMatrix3x3 m_invwi
Definition: btSoftBody.h:328
RayFromToCaster takes a ray from, ray to (instead of direction!)
Definition: btSoftBody.h:606
eVSolver : velocities solvers
Definition: btSoftBody.h:96
btSoftBodySolver * getSoftBodySolver()
Definition: btSoftBody.h:915
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:362
btCollisionObject can be used to manage collision detection objects.
static void clusterVAImpulse(Cluster *cluster, const btVector3 &impulse)
tAnchorArray m_anchors
Definition: btSoftBody.h:660
btDbvtNode * m_leaf
Definition: btSoftBody.h:258
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:62
btScalar m_influence
Definition: btSoftBody.h:291
Pose m_pose
Definition: btSoftBody.h:652
tPSolverArray m_dsequence
Definition: btSoftBody.h:594
btScalar invMass() const
Definition: btSoftBody.h:404
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
btScalar m_maxSelfCollisionImpulse
Definition: btSoftBody.h:341
void activate(bool forceActivation=false) const
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
btAlignedObjectArray< Note > tNoteArray
Definition: btSoftBody.h:633
void activate() const
Definition: btSoftBody.h:389
btScalar m_offset
Definition: btSoftBody.h:190
void applyVImpulse(const btVector3 &impulse, const btVector3 &rpos) const
Definition: btSoftBody.h:439
btVector3 m_com
Definition: btSoftBody.h:313
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btAlignedObjectArray< btSoftBody * > tSoftBodyArray
Definition: btSoftBody.h:644
eType::_ Type() const
Definition: btSoftBody.h:561
btAlignedObjectArray< SContact > tSContactArray
Definition: btSoftBody.h:641
ePSolver : positions solvers
Definition: btSoftBody.h:102
btMatrix3x3 operator-(const btMatrix3x3 &m1, const btMatrix3x3 &m2)
Definition: btMatrix3x3.h:925
btDbvt m_cdbvt
Definition: btSoftBody.h:670
btAlignedObjectArray< Joint * > tJointArray
Definition: btSoftBody.h:643
tNoteArray m_notes
Definition: btSoftBody.h:655
virtual void Prepare(AJoint *)
Definition: btSoftBody.h:533
static const btTransform & getIdentity()
Return an identity transform.
Definition: btTransform.h:203
Face normals are flipped to match velocity.
Definition: btSoftBody.h:90
static void split(const tNodeArray &leaves, tNodeArray &left, tNodeArray &right, const btVector3 &org, const btVector3 &axis)
Definition: btDbvt.cpp:232
void applyDCImpulse(const btVector3 &impulse) const
Definition: btSoftBody.h:477
btDbvt m_ndbvt
Definition: btSoftBody.h:668
btVector3 m_n
Definition: btSoftBody.h:228
btVector3 m_local
Definition: btSoftBody.h:289
btDbvtNode * m_leaf
Definition: btSoftBody.h:336
btScalar timescale
Definition: btSoftBody.h:586
SolverState m_sst
Definition: btSoftBody.h:651
Face normals are flipped to match velocity and lift and drag forces are applied.
Definition: btSoftBody.h:91
tClusterArray m_clusters
Definition: btSoftBody.h:671
btSoftBody * body
Definition: btSoftBody.h:165
btMatrix3x3 m_rot
Definition: btSoftBody.h:314
void setSoftBodySolver(btSoftBodySolver *softBodySolver)
Definition: btSoftBody.h:907
void applyVAImpulse(const btVector3 &impulse) const
Definition: btSoftBody.h:462
const btMatrix3x3 & getInvInertiaTensorWorld() const
Definition: btRigidBody.h:271
void applyCentralImpulse(const btVector3 &impulse)
Definition: btRigidBody.h:321
btMatrix3x3 m_massmatrix
Definition: btSoftBody.h:505
btScalar water_density
Definition: btSoftBody.h:46
btScalar m_volume
Definition: btSoftBody.h:310
btVector3 m_v
Definition: btSoftBody.h:226
tVSolverArray m_vsequence
Definition: btSoftBody.h:592
void applyImpulse(const Impulse &impulse, const btVector3 &rpos) const
Definition: btSoftBody.h:449
btScalar m_timeacc
Definition: btSoftBody.h:665
tPSolverArray m_psequence
Definition: btSoftBody.h:593
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
eType::_ Type() const
Definition: btSoftBody.h:548
tScalarArray m_wgh
Definition: btSoftBody.h:312
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:359
IControl * m_icontrol
Definition: btSoftBody.h:544
btBroadphaseInterface * m_broadphase
Definition: btSoftBody.h:50
eAeroModel::_ aeromodel
Definition: btSoftBody.h:566
btScalar air_density
Definition: btSoftBody.h:45
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
Definition: btRigidBody.h:331
btSoftBodySolver * m_softBodySolver
Definition: btSoftBody.h:77
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:48
btVector3 m_q
Definition: btSoftBody.h:225
btAlignedObjectArray< const class btCollisionObject * > m_collisionDisabledObjects
Definition: btSoftBody.h:74
btScalar m_selfCollisionImpulseFactor
Definition: btSoftBody.h:342
btVector3 m_f
Definition: btSoftBody.h:227
btVector3 m_gravity
Definition: btSoftBody.h:52
bool m_bUpdateRtCst
Definition: btSoftBody.h:667
tScalarArray m_masses
Definition: btSoftBody.h:321
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition: btSoftBody.h:71
btAlignedObjectArray< Node > tNodeArray
Definition: btSoftBody.h:634
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:69
static void clusterDCImpulse(Cluster *cluster, const btVector3 &impulse)
btRigidBody * m_body
Definition: btSoftBody.h:290
btVector3 m_drift
Definition: btSoftBody.h:503
btRigidBody * m_rigid
Definition: btSoftBody.h:379
void applyAImpulse(const Impulse &impulse) const
Definition: btSoftBody.h:472
void applyDAImpulse(const btVector3 &impulse) const
Definition: btSoftBody.h:467
btVector3 m_x
Definition: btSoftBody.h:224
tRContactArray m_rcontacts
Definition: btSoftBody.h:661
btAlignedObjectArray< Anchor > tAnchorArray
Definition: btSoftBody.h:639
btScalar maxvolume
Definition: btSoftBody.h:585
btScalar m_area
Definition: btSoftBody.h:230
btVector3 m_rayNormalizedDirection
Definition: btSoftBody.h:610
btAlignedObjectArray< eVSolver::_ > tVSolverArray
Definition: btSoftBody.h:128
btVector3 velocity(const btVector3 &rpos) const
Definition: btSoftBody.h:435
static void clusterDAImpulse(Cluster *cluster, const btVector3 &impulse)
btDbvtNode * m_leaf
Definition: btSoftBody.h:231
btTransform m_framexform
Definition: btSoftBody.h:324
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btScalar m_friction
Definition: btSoftBody.h:557
tVector3Array m_pos
Definition: btSoftBody.h:311
eType::_ Type() const
Definition: btSoftBody.h:525
tFaceArray m_faces
Definition: btSoftBody.h:658