1 /* 2 Bullet Continuous Collision Detection and Physics Library 3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/ 4 5 This software is provided 'as-is', without any express or implied warranty. 6 In no event will the authors be held liable for any damages arising from the use of this software. 7 Permission is granted to anyone to use this software for any purpose, 8 including commercial applications, and to alter it and redistribute it freely, 9 subject to the following restrictions: 10 11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 13 3. This notice may not be removed or altered from any source distribution. 14 */ 15 ///btSoftBody implementation by Nathanael Presson 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 "BulletDynamics/Dynamics/btRigidBody.h" 24 25 #include "BulletCollision/CollisionShapes/btConcaveShape.h" 26 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" 27 #include "btSparseSDF.h" 28 #include "BulletCollision/BroadphaseCollision/btDbvt.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 38 class btBroadphaseInterface; 39 class btDispatcher; 40 class btSoftBodySolver; 41 42 /* btSoftBodyWorldInfo */ 43 struct btSoftBodyWorldInfo 44 { 45 btScalar air_density; 46 btScalar water_density; 47 btScalar water_offset; 48 btScalar m_maxDisplacement; 49 btVector3 water_normal; 50 btBroadphaseInterface* m_broadphase; 51 btDispatcher* m_dispatcher; 52 btVector3 m_gravity; 53 btSparseSdf<3> m_sparsesdf; 54 55 btSoftBodyWorldInfo() 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 69 ///The btSoftBody is an class to simulate cloth and volumetric soft bodies. 70 ///There is two-way interaction between btSoftBody and btRigidBody/btCollisionObject. 71 class btSoftBody : public btCollisionObject 72 { 73 public: 74 btAlignedObjectArray<const class btCollisionObject*> m_collisionDisabledObjects; 75 76 // The solver object that handles this soft body 77 btSoftBodySolver *m_softBodySolver; 78 79 // 80 // Enumerations 81 // 82 83 ///eAeroModel 84 struct eAeroModel { enum _ { 85 V_Point, ///Vertex normals are oriented toward velocity 86 V_TwoSided, ///Vertex normals are flipped to match velocity 87 V_TwoSidedLiftDrag, ///Vertex normals are flipped to match velocity and lift and drag forces are applied 88 V_OneSided, ///Vertex normals are taken as it is 89 F_TwoSided, ///Face normals are flipped to match velocity 90 F_TwoSidedLiftDrag, ///Face normals are flipped to match velocity and lift and drag forces are applied 91 F_OneSided, ///Face normals are taken as it is 92 END 93 };}; 94 95 ///eVSolver : velocities solvers 96 struct eVSolver { enum _ { 97 Linear, ///Linear solver 98 END 99 };}; 100 101 ///ePSolver : positions solvers 102 struct ePSolver { enum _ { 103 Linear, ///Linear solver 104 Anchors, ///Anchor solver 105 RContacts, ///Rigid contacts solver 106 SContacts, ///Soft contacts solver 107 END 108 };}; 109 110 ///eSolverPresets 111 struct eSolverPresets { enum _ { 112 Positions, 113 Velocities, 114 Default = Positions, 115 END 116 };}; 117 118 ///eFeature 119 struct eFeature { enum _ { 120 None, 121 Node, 122 Link, 123 Face, 124 Tetra, 125 END 126 };}; 127 128 typedef btAlignedObjectArray<eVSolver::_> tVSolverArray; 129 typedef btAlignedObjectArray<ePSolver::_> tPSolverArray; 130 131 // 132 // Flags 133 // 134 135 ///fCollision 136 struct fCollision { enum _ { 137 RVSmask = 0x000f, ///Rigid versus soft mask 138 SDF_RS = 0x0001, ///SDF based rigid vs soft 139 CL_RS = 0x0002, ///Cluster vs convex rigid vs soft 140 141 SVSmask = 0x0030, ///Rigid versus soft mask 142 VF_SS = 0x0010, ///Vertex vs face soft vs soft handling 143 CL_SS = 0x0020, ///Cluster vs cluster soft vs soft handling 144 CL_SELF = 0x0040, ///Cluster soft body self collision 145 /* presets */ 146 Default = SDF_RS, 147 END 148 };}; 149 150 ///fMaterial 151 struct fMaterial { enum _ { 152 DebugDraw = 0x0001, /// Enable debug draw 153 /* presets */ 154 Default = DebugDraw, 155 END 156 };}; 157 158 // 159 // API Types 160 // 161 162 /* sRayCast */ 163 struct sRayCast 164 { 165 btSoftBody* body; /// soft body 166 eFeature::_ feature; /// feature type 167 int index; /// feature index 168 btScalar fraction; /// time of impact fraction (rayorg+(rayto-rayfrom)*fraction) 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 182 typedef btAlignedObjectArray<btScalar> tScalarArray; 183 typedef btAlignedObjectArray<btVector3> tVector3Array; 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 291 btScalar m_influence; 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; 322 btAlignedObjectArray<Node*> m_nodes; 323 tVector3Array m_framerefs; 324 btTransform m_framexform; 325 btScalar m_idmass; 326 btScalar m_imass; 327 btMatrix3x3 m_locii; 328 btMatrix3x3 m_invwi; 329 btVector3 m_com; 330 btVector3 m_vimpulses[2]; 331 btVector3 m_dimpulses[2]; 332 int m_nvimpulses; 333 int m_ndimpulses; 334 btVector3 m_lv; 335 btVector3 m_av; 336 btDbvtNode* m_leaf; 337 btScalar m_ndamping; /* Node damping */ 338 btScalar m_ldamping; /* Linear damping */ 339 btScalar m_adamping; /* Angular damping */ 340 btScalar m_matching; 341 btScalar m_maxSelfCollisionImpulse; 342 btScalar m_selfCollisionImpulseFactor; 343 bool m_containsAnchor; 344 bool m_collide; 345 int m_clusterIndex; 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 { 355 btVector3 m_velocity; 356 btVector3 m_drift; 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) {} 360 Impulse operator -() const 361 { 362 Impulse i=*this; 363 i.m_velocity=-i.m_velocity; 364 i.m_drift=-i.m_drift; 365 return(i); 366 } 367 Impulse operator*(btScalar x) const 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 { 378 Cluster* m_soft; 379 btRigidBody* m_rigid; 380 const btCollisionObject* m_collisionObject; 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 } 397 const btMatrix3x3& invWorldInertia() const 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 } 404 btScalar invMass() const 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 } 417 btVector3 linearVelocity() const 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 } 423 btVector3 angularVelocity(const btVector3& rpos) const 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 } 429 btVector3 angularVelocity() const 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, 488 Angular, 489 Contact 490 };}; 491 struct Specs 492 { 493 Specs() : erp(1),cfm(1),split(1) {} 494 btScalar erp; 495 btScalar cfm; 496 btScalar split; 497 }; 498 Body m_bodies[2]; 499 btVector3 m_refs[2]; 500 btScalar m_cfm; 501 btScalar m_erp; 502 btScalar m_split; 503 btVector3 m_drift; 504 btVector3 m_sdrift; 505 btMatrix3x3 m_massmatrix; 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 { 517 struct Specs : Joint::Specs 518 { 519 btVector3 position; 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 }; 537 struct Specs : Joint::Specs 538 { 539 Specs() : icontrol(IControl::Default()) {} 540 btVector3 axis; 541 IControl* icontrol; 542 }; 543 btVector3 m_axis[2]; 544 IControl* m_icontrol; 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; 554 int m_maxlife; 555 btVector3 m_rpos[2]; 556 btVector3 m_normal; 557 btScalar m_friction; 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 }; 605 /// RayFromToCaster takes a ray from, ray to (instead of direction!) 606 struct RayFromToCaster : btDbvt::ICollide 607 { 608 btVector3 m_rayFrom; 609 btVector3 m_rayTo; 610 btVector3 m_rayNormalizedDirection; 611 btScalar m_mint; 612 Face* m_face; 613 int m_tests; 614 RayFromToCaster(const btVector3& rayFrom,const btVector3& rayTo,btScalar mxt); 615 void Process(const btDbvtNode* leaf); 616 617 static 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); 632 typedef btAlignedObjectArray<Cluster*> tClusterArray; 633 typedef btAlignedObjectArray<Note> tNoteArray; 634 typedef btAlignedObjectArray<Node> tNodeArray; 635 typedef btAlignedObjectArray<btDbvtNode*> tLeafArray; 636 typedef btAlignedObjectArray<Link> tLinkArray; 637 typedef btAlignedObjectArray<Face> tFaceArray; 638 typedef btAlignedObjectArray<Tetra> tTetraArray; 639 typedef btAlignedObjectArray<Anchor> tAnchorArray; 640 typedef btAlignedObjectArray<RContact> tRContactArray; 641 typedef btAlignedObjectArray<SContact> tSContactArray; 642 typedef btAlignedObjectArray<Material*> tMaterialArray; 643 typedef btAlignedObjectArray<Joint*> tJointArray; 644 typedef btAlignedObjectArray<btSoftBody*> tSoftBodyArray; 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 654 btSoftBodyWorldInfo* m_worldInfo; // World info 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 675 btTransform m_initialWorldTransform; 676 677 btVector3 m_windVelocity; 678 679 btScalar m_restLengthScale; 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 697 btAlignedObjectArray<int> m_userIndexMapping; 698 699 btSoftBodyWorldInfo* getWorldInfo() 700 { 701 return m_worldInfo; 702 } 703 704 ///@todo: avoid internal softbody shape hack and move collision code to collision library 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) */ 855 ///generateClusters with k=0 will create a convex cluster for each tetrahedron or triangle 856 ///otherwise an approximation will be used (better performance) 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 864 ///Ray casting using rayFrom and rayTo in worldspace, (not direction!) 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 892 /** 893 * Set a wind velocity for interaction with the air. 894 */ 895 void setWindVelocity( const btVector3 &velocity ); 896 897 898 /** 899 * Return the wind velocity for interaction with the air. 900 */ 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 // 915 btSoftBodySolver *getSoftBodySolver() 916 { 917 return m_softBodySolver; 918 } 919 920 // 921 // Return the solver that handles this soft body 922 // 923 btSoftBodySolver *getSoftBodySolver() const 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 991 ///fills the dataBuffer and returns the struct name (and 0 on failure) 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 1003
