btSoftBody.h

Go to the documentation of this file.

/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:

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.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

#ifndef _BT_SOFT_BODY_H
#define _BT_SOFT_BODY_H

#include "LinearMath/btAlignedObjectArray.h"
#include "LinearMath/btTransform.h"
#include "LinearMath/btIDebugDraw.h"
#include "BulletDynamics/Dynamics/btRigidBody.h"

#include "BulletCollision/CollisionShapes/btConcaveShape.h"
#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
#include "btSparseSDF.h"
#include "BulletCollision/BroadphaseCollision/btDbvt.h"

//#ifdef BT_USE_DOUBLE_PRECISION
//#define btRigidBodyData       btRigidBodyDoubleData
//#define btRigidBodyDataName   "btRigidBodyDoubleData"
//#else
#define btSoftBodyData  btSoftBodyFloatData
#define btSoftBodyDataName      "btSoftBodyFloatData"
//#endif //BT_USE_DOUBLE_PRECISION

class btBroadphaseInterface;
class btDispatcher;
class btSoftBodySolver;

/* btSoftBodyWorldInfo  */ 
struct  btSoftBodyWorldInfo
{
        btScalar                                air_density;
        btScalar                                water_density;
        btScalar                                water_offset;
        btVector3                               water_normal;
        btBroadphaseInterface*  m_broadphase;
        btDispatcher*   m_dispatcher;
        btVector3                               m_gravity;
        btSparseSdf<3>                  m_sparsesdf;

        btSoftBodyWorldInfo()
                :air_density((btScalar)1.2),
                water_density(0),
                water_offset(0),
                water_normal(0,0,0),
                m_broadphase(0),
                m_dispatcher(0),
                m_gravity(0,-10,0)
        {
        }
};      


class   btSoftBody : public btCollisionObject
{
public:
        btAlignedObjectArray<class btCollisionObject*> m_collisionDisabledObjects;

        // The solver object that handles this soft body
        btSoftBodySolver *m_softBodySolver;

        //
        // Enumerations
        //

        struct eAeroModel { enum _ {
                V_Point,                        
                V_TwoSided,                     
                V_TwoSidedLiftDrag, 
                V_OneSided,                     
                F_TwoSided,                     
                F_TwoSidedLiftDrag,     
                F_OneSided,                     
                END
        };};

        struct  eVSolver { enum _ {
                Linear,         
                END
        };};

        struct  ePSolver { enum _ {
                Linear,         
                Anchors,        
                RContacts,      
                SContacts,      
                END
        };};

        struct  eSolverPresets { enum _ {
                Positions,
                Velocities,
                Default =       Positions,
                END
        };};

        struct  eFeature { enum _ {
                None,
                Node,
                Link,
                Face,
                Tetra,
                END
        };};

        typedef btAlignedObjectArray<eVSolver::_>       tVSolverArray;
        typedef btAlignedObjectArray<ePSolver::_>       tPSolverArray;

        //
        // Flags
        //

        struct fCollision { enum _ {
                RVSmask =       0x000f, 
                SDF_RS  =       0x0001, 
                CL_RS   =       0x0002, 

                SVSmask =       0x0030, 
                VF_SS   =       0x0010, 
                CL_SS   =       0x0020, 
                CL_SELF =       0x0040, 
                /* presets      */ 
                Default =       SDF_RS,
                END
        };};

        struct fMaterial { enum _ {
                DebugDraw       =       0x0001, 
                /* presets      */ 
                Default         =       DebugDraw,
                END
        };};

        //
        // API Types
        //

        /* sRayCast             */ 
        struct sRayCast
        {
                btSoftBody*     body;           
                eFeature::_     feature;        
                int                     index;          
                btScalar        fraction;               
        };

        /* ImplicitFn   */ 
        struct  ImplicitFn
        {
                virtual btScalar        Eval(const btVector3& x)=0;
        };

        //
        // Internal types
        //

        typedef btAlignedObjectArray<btScalar>  tScalarArray;
        typedef btAlignedObjectArray<btVector3> tVector3Array;

        /* sCti is Softbody contact info        */ 
        struct  sCti
        {
                btCollisionObject*      m_colObj;               /* Rigid body                   */ 
                btVector3               m_normal;       /* Outward normal               */ 
                btScalar                m_offset;       /* Offset from origin   */ 
        };      

        /* sMedium              */ 
        struct  sMedium
        {
                btVector3               m_velocity;     /* Velocity                             */ 
                btScalar                m_pressure;     /* Pressure                             */ 
                btScalar                m_density;      /* Density                              */ 
        };

        /* Base type    */ 
        struct  Element
        {
                void*                   m_tag;                  // User data
                Element() : m_tag(0) {}
        };
        /* Material             */ 
        struct  Material : Element
        {
                btScalar                                m_kLST;                 // Linear stiffness coefficient [0,1]
                btScalar                                m_kAST;                 // Area/Angular stiffness coefficient [0,1]
                btScalar                                m_kVST;                 // Volume stiffness coefficient [0,1]
                int                                             m_flags;                // Flags
        };

        /* Feature              */ 
        struct  Feature : Element
        {
                Material*                               m_material;             // Material
        };
        /* Node                 */ 
        struct  Node : Feature
        {
                btVector3                               m_x;                    // Position
                btVector3                               m_q;                    // Previous step position
                btVector3                               m_v;                    // Velocity
                btVector3                               m_f;                    // Force accumulator
                btVector3                               m_n;                    // Normal
                btScalar                                m_im;                   // 1/mass
                btScalar                                m_area;                 // Area
                btDbvtNode*                             m_leaf;                 // Leaf data
                int                                             m_battach:1;    // Attached
        };
        /* Link                 */ 
        struct  Link : Feature
        {
                Node*                                   m_n[2];                 // Node pointers
                btScalar                                m_rl;                   // Rest length          
                int                                             m_bbending:1;   // Bending link
                btScalar                                m_c0;                   // (ima+imb)*kLST
                btScalar                                m_c1;                   // rl^2
                btScalar                                m_c2;                   // |gradient|^2/c0
                btVector3                               m_c3;                   // gradient
        };
        /* Face                 */ 
        struct  Face : Feature
        {
                Node*                                   m_n[3];                 // Node pointers
                btVector3                               m_normal;               // Normal
                btScalar                                m_ra;                   // Rest area
                btDbvtNode*                             m_leaf;                 // Leaf data
        };
        /* Tetra                */ 
        struct  Tetra : Feature
        {
                Node*                                   m_n[4];                 // Node pointers                
                btScalar                                m_rv;                   // Rest volume
                btDbvtNode*                             m_leaf;                 // Leaf data
                btVector3                               m_c0[4];                // gradients
                btScalar                                m_c1;                   // (4*kVST)/(im0+im1+im2+im3)
                btScalar                                m_c2;                   // m_c1/sum(|g0..3|^2)
        };
        /* RContact             */ 
        struct  RContact
        {
                sCti            m_cti;                  // Contact infos
                Node*                                   m_node;                 // Owner node
                btMatrix3x3                             m_c0;                   // Impulse matrix
                btVector3                               m_c1;                   // Relative anchor
                btScalar                                m_c2;                   // ima*dt
                btScalar                                m_c3;                   // Friction
                btScalar                                m_c4;                   // Hardness
        };
        /* SContact             */ 
        struct  SContact
        {
                Node*                                   m_node;                 // Node
                Face*                                   m_face;                 // Face
                btVector3                               m_weights;              // Weigths
                btVector3                               m_normal;               // Normal
                btScalar                                m_margin;               // Margin
                btScalar                                m_friction;             // Friction
                btScalar                                m_cfm[2];               // Constraint force mixing
        };
        /* Anchor               */ 
        struct  Anchor
        {
                Node*                                   m_node;                 // Node pointer
                btVector3                               m_local;                // Anchor position in body space
                btRigidBody*                    m_body;                 // Body
                btScalar                                m_influence;
                btMatrix3x3                             m_c0;                   // Impulse matrix
                btVector3                               m_c1;                   // Relative anchor
                btScalar                                m_c2;                   // ima*dt
        };
        /* Note                 */ 
        struct  Note : Element
        {
                const char*                             m_text;                 // Text
                btVector3                               m_offset;               // Offset
                int                                             m_rank;                 // Rank
                Node*                                   m_nodes[4];             // Nodes
                btScalar                                m_coords[4];    // Coordinates
        };      
        /* Pose                 */ 
        struct  Pose
        {
                bool                                    m_bvolume;              // Is valid
                bool                                    m_bframe;               // Is frame
                btScalar                                m_volume;               // Rest volume
                tVector3Array                   m_pos;                  // Reference positions
                tScalarArray                    m_wgh;                  // Weights
                btVector3                               m_com;                  // COM
                btMatrix3x3                             m_rot;                  // Rotation
                btMatrix3x3                             m_scl;                  // Scale
                btMatrix3x3                             m_aqq;                  // Base scaling
        };
        /* Cluster              */ 
        struct  Cluster
        {
                tScalarArray                            m_masses;
                btAlignedObjectArray<Node*>     m_nodes;                
                tVector3Array                           m_framerefs;
                btTransform                                     m_framexform;
                btScalar                                        m_idmass;
                btScalar                                        m_imass;
                btMatrix3x3                                     m_locii;
                btMatrix3x3                                     m_invwi;
                btVector3                                       m_com;
                btVector3                                       m_vimpulses[2];
                btVector3                                       m_dimpulses[2];
                int                                                     m_nvimpulses;
                int                                                     m_ndimpulses;
                btVector3                                       m_lv;
                btVector3                                       m_av;
                btDbvtNode*                                     m_leaf;
                btScalar                                        m_ndamping;     /* Node damping         */ 
                btScalar                                        m_ldamping;     /* Linear damping       */ 
                btScalar                                        m_adamping;     /* Angular damping      */ 
                btScalar                                        m_matching;
                btScalar                                        m_maxSelfCollisionImpulse;
                btScalar                                        m_selfCollisionImpulseFactor;
                bool                                            m_containsAnchor;
                bool                                            m_collide;
                int                                                     m_clusterIndex;
                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)
                {}
        };
        /* Impulse              */ 
        struct  Impulse
        {
                btVector3                                       m_velocity;
                btVector3                                       m_drift;
                int                                                     m_asVelocity:1;
                int                                                     m_asDrift:1;
                Impulse() : m_velocity(0,0,0),m_drift(0,0,0),m_asVelocity(0),m_asDrift(0)       {}
                Impulse                                         operator -() const
                {
                        Impulse i=*this;
                        i.m_velocity=-i.m_velocity;
                        i.m_drift=-i.m_drift;
                        return(i);
                }
                Impulse                                         operator*(btScalar x) const
                {
                        Impulse i=*this;
                        i.m_velocity*=x;
                        i.m_drift*=x;
                        return(i);
                }
        };
        /* Body                 */ 
        struct  Body
        {
                Cluster*                        m_soft;
                btRigidBody*            m_rigid;
                btCollisionObject*      m_collisionObject;

                Body() : m_soft(0),m_rigid(0),m_collisionObject(0)                              {}
                Body(Cluster* p) : m_soft(p),m_rigid(0),m_collisionObject(0)    {}
                Body(btCollisionObject* colObj) : m_soft(0),m_collisionObject(colObj)
                {
                        m_rigid = btRigidBody::upcast(m_collisionObject);
                }

                void                                            activate() const
                {
                        if(m_rigid) 
                                m_rigid->activate();
                        if (m_collisionObject)
                                m_collisionObject->activate();

                }
                const btMatrix3x3&                      invWorldInertia() const
                {
                        static const btMatrix3x3        iwi(0,0,0,0,0,0,0,0,0);
                        if(m_rigid) return(m_rigid->getInvInertiaTensorWorld());
                        if(m_soft)      return(m_soft->m_invwi);
                        return(iwi);
                }
                btScalar                                        invMass() const
                {
                        if(m_rigid) return(m_rigid->getInvMass());
                        if(m_soft)      return(m_soft->m_imass);
                        return(0);
                }
                const btTransform&                      xform() const
                {
                        static const btTransform        identity=btTransform::getIdentity();            
                        if(m_collisionObject) return(m_collisionObject->getWorldTransform());
                        if(m_soft)      return(m_soft->m_framexform);
                        return(identity);
                }
                btVector3                                       linearVelocity() const
                {
                        if(m_rigid) return(m_rigid->getLinearVelocity());
                        if(m_soft)      return(m_soft->m_lv);
                        return(btVector3(0,0,0));
                }
                btVector3                                       angularVelocity(const btVector3& rpos) const
                {                       
                        if(m_rigid) return(btCross(m_rigid->getAngularVelocity(),rpos));
                        if(m_soft)      return(btCross(m_soft->m_av,rpos));
                        return(btVector3(0,0,0));
                }
                btVector3                                       angularVelocity() const
                {                       
                        if(m_rigid) return(m_rigid->getAngularVelocity());
                        if(m_soft)      return(m_soft->m_av);
                        return(btVector3(0,0,0));
                }
                btVector3                                       velocity(const btVector3& rpos) const
                {
                        return(linearVelocity()+angularVelocity(rpos));
                }
                void                                            applyVImpulse(const btVector3& impulse,const btVector3& rpos) const
                {
                        if(m_rigid)     m_rigid->applyImpulse(impulse,rpos);
                        if(m_soft)      btSoftBody::clusterVImpulse(m_soft,rpos,impulse);
                }
                void                                            applyDImpulse(const btVector3& impulse,const btVector3& rpos) const
                {
                        if(m_rigid)     m_rigid->applyImpulse(impulse,rpos);
                        if(m_soft)      btSoftBody::clusterDImpulse(m_soft,rpos,impulse);
                }               
                void                                            applyImpulse(const Impulse& impulse,const btVector3& rpos) const
                {
                        if(impulse.m_asVelocity)        
                        {
//                              printf("impulse.m_velocity = %f,%f,%f\n",impulse.m_velocity.getX(),impulse.m_velocity.getY(),impulse.m_velocity.getZ());
                                applyVImpulse(impulse.m_velocity,rpos);
                        }
                        if(impulse.m_asDrift)           
                        {
//                              printf("impulse.m_drift = %f,%f,%f\n",impulse.m_drift.getX(),impulse.m_drift.getY(),impulse.m_drift.getZ());
                                applyDImpulse(impulse.m_drift,rpos);
                        }
                }
                void                                            applyVAImpulse(const btVector3& impulse) const
                {
                        if(m_rigid)     m_rigid->applyTorqueImpulse(impulse);
                        if(m_soft)      btSoftBody::clusterVAImpulse(m_soft,impulse);
                }
                void                                            applyDAImpulse(const btVector3& impulse) const
                {
                        if(m_rigid)     m_rigid->applyTorqueImpulse(impulse);
                        if(m_soft)      btSoftBody::clusterDAImpulse(m_soft,impulse);
                }
                void                                            applyAImpulse(const Impulse& impulse) const
                {
                        if(impulse.m_asVelocity)        applyVAImpulse(impulse.m_velocity);
                        if(impulse.m_asDrift)           applyDAImpulse(impulse.m_drift);
                }
                void                                            applyDCImpulse(const btVector3& impulse) const
                {
                        if(m_rigid)     m_rigid->applyCentralImpulse(impulse);
                        if(m_soft)      btSoftBody::clusterDCImpulse(m_soft,impulse);
                }
        };
        /* Joint                */ 
        struct  Joint
        {
                struct eType { enum _ {
                        Linear=0,
                        Angular,
                        Contact
                };};
                struct Specs
                {
                        Specs() : erp(1),cfm(1),split(1) {}
                        btScalar        erp;
                        btScalar        cfm;
                        btScalar        split;
                };
                Body                                            m_bodies[2];
                btVector3                                       m_refs[2];
                btScalar                                        m_cfm;
                btScalar                                        m_erp;
                btScalar                                        m_split;
                btVector3                                       m_drift;
                btVector3                                       m_sdrift;
                btMatrix3x3                                     m_massmatrix;
                bool                                            m_delete;
                virtual                                         ~Joint() {}
                Joint() : m_delete(false) {}
                virtual void                            Prepare(btScalar dt,int iterations);
                virtual void                            Solve(btScalar dt,btScalar sor)=0;
                virtual void                            Terminate(btScalar dt)=0;
                virtual eType::_                        Type() const=0;
        };
        /* LJoint               */ 
        struct  LJoint : Joint
        {
                struct Specs : Joint::Specs
                {
                        btVector3       position;
                };              
                btVector3                                       m_rpos[2];
                void                                            Prepare(btScalar dt,int iterations);
                void                                            Solve(btScalar dt,btScalar sor);
                void                                            Terminate(btScalar dt);
                eType::_                                        Type() const { return(eType::Linear); }
        };
        /* AJoint               */ 
        struct  AJoint : Joint
        {
                struct IControl
                {
                        virtual void                    Prepare(AJoint*)                                {}
                        virtual btScalar                Speed(AJoint*,btScalar current) { return(current); }
                        static IControl*                Default()                                               { static IControl def;return(&def); }
                };
                struct Specs : Joint::Specs
                {
                        Specs() : icontrol(IControl::Default()) {}
                        btVector3       axis;
                        IControl*       icontrol;
                };              
                btVector3                                       m_axis[2];
                IControl*                                       m_icontrol;
                void                                            Prepare(btScalar dt,int iterations);
                void                                            Solve(btScalar dt,btScalar sor);
                void                                            Terminate(btScalar dt);
                eType::_                                        Type() const { return(eType::Angular); }
        };
        /* CJoint               */ 
        struct  CJoint : Joint
        {               
                int                                                     m_life;
                int                                                     m_maxlife;
                btVector3                                       m_rpos[2];
                btVector3                                       m_normal;
                btScalar                                        m_friction;
                void                                            Prepare(btScalar dt,int iterations);
                void                                            Solve(btScalar dt,btScalar sor);
                void                                            Terminate(btScalar dt);
                eType::_                                        Type() const { return(eType::Contact); }
        };
        /* Config               */ 
        struct  Config
        {
                eAeroModel::_                   aeromodel;              // Aerodynamic model (default: V_Point)
                btScalar                                kVCF;                   // Velocities correction factor (Baumgarte)
                btScalar                                kDP;                    // Damping coefficient [0,1]
                btScalar                                kDG;                    // Drag coefficient [0,+inf]
                btScalar                                kLF;                    // Lift coefficient [0,+inf]
                btScalar                                kPR;                    // Pressure coefficient [-inf,+inf]
                btScalar                                kVC;                    // Volume conversation coefficient [0,+inf]
                btScalar                                kDF;                    // Dynamic friction coefficient [0,1]
                btScalar                                kMT;                    // Pose matching coefficient [0,1]              
                btScalar                                kCHR;                   // Rigid contacts hardness [0,1]
                btScalar                                kKHR;                   // Kinetic contacts hardness [0,1]
                btScalar                                kSHR;                   // Soft contacts hardness [0,1]
                btScalar                                kAHR;                   // Anchors hardness [0,1]
                btScalar                                kSRHR_CL;               // Soft vs rigid hardness [0,1] (cluster only)
                btScalar                                kSKHR_CL;               // Soft vs kinetic hardness [0,1] (cluster only)
                btScalar                                kSSHR_CL;               // Soft vs soft hardness [0,1] (cluster only)
                btScalar                                kSR_SPLT_CL;    // Soft vs rigid impulse split [0,1] (cluster only)
                btScalar                                kSK_SPLT_CL;    // Soft vs rigid impulse split [0,1] (cluster only)
                btScalar                                kSS_SPLT_CL;    // Soft vs rigid impulse split [0,1] (cluster only)
                btScalar                                maxvolume;              // Maximum volume ratio for pose
                btScalar                                timescale;              // Time scale
                int                                             viterations;    // Velocities solver iterations
                int                                             piterations;    // Positions solver iterations
                int                                             diterations;    // Drift solver iterations
                int                                             citerations;    // Cluster solver iterations
                int                                             collisions;             // Collisions flags
                tVSolverArray                   m_vsequence;    // Velocity solvers sequence
                tPSolverArray                   m_psequence;    // Position solvers sequence
                tPSolverArray                   m_dsequence;    // Drift solvers sequence
        };
        /* SolverState  */ 
        struct  SolverState
        {
                btScalar                                sdt;                    // dt*timescale
                btScalar                                isdt;                   // 1/sdt
                btScalar                                velmrg;                 // velocity margin
                btScalar                                radmrg;                 // radial margin
                btScalar                                updmrg;                 // Update margin
        };      
        struct  RayFromToCaster : btDbvt::ICollide
        {
                btVector3                       m_rayFrom;
                btVector3                       m_rayTo;
                btVector3                       m_rayNormalizedDirection;
                btScalar                        m_mint;
                Face*                           m_face;
                int                                     m_tests;
                RayFromToCaster(const btVector3& rayFrom,const btVector3& rayTo,btScalar mxt);
                void                                    Process(const btDbvtNode* leaf);

                static inline btScalar  rayFromToTriangle(const btVector3& rayFrom,
                        const btVector3& rayTo,
                        const btVector3& rayNormalizedDirection,
                        const btVector3& a,
                        const btVector3& b,
                        const btVector3& c,
                        btScalar maxt=SIMD_INFINITY);
        };

        //
        // Typedefs
        //

        typedef void                                                            (*psolver_t)(btSoftBody*,btScalar,btScalar);
        typedef void                                                            (*vsolver_t)(btSoftBody*,btScalar);
        typedef btAlignedObjectArray<Cluster*>          tClusterArray;
        typedef btAlignedObjectArray<Note>                      tNoteArray;
        typedef btAlignedObjectArray<Node>                      tNodeArray;
        typedef btAlignedObjectArray<btDbvtNode*>       tLeafArray;
        typedef btAlignedObjectArray<Link>                      tLinkArray;
        typedef btAlignedObjectArray<Face>                      tFaceArray;
        typedef btAlignedObjectArray<Tetra>                     tTetraArray;
        typedef btAlignedObjectArray<Anchor>            tAnchorArray;
        typedef btAlignedObjectArray<RContact>          tRContactArray;
        typedef btAlignedObjectArray<SContact>          tSContactArray;
        typedef btAlignedObjectArray<Material*>         tMaterialArray;
        typedef btAlignedObjectArray<Joint*>            tJointArray;
        typedef btAlignedObjectArray<btSoftBody*>       tSoftBodyArray; 

        //
        // Fields
        //

        Config                                  m_cfg;                  // Configuration
        SolverState                             m_sst;                  // Solver state
        Pose                                    m_pose;                 // Pose
        void*                                   m_tag;                  // User data
        btSoftBodyWorldInfo*    m_worldInfo;    // World info
        tNoteArray                              m_notes;                // Notes
        tNodeArray                              m_nodes;                // Nodes
        tLinkArray                              m_links;                // Links
        tFaceArray                              m_faces;                // Faces
        tTetraArray                             m_tetras;               // Tetras
        tAnchorArray                    m_anchors;              // Anchors
        tRContactArray                  m_rcontacts;    // Rigid contacts
        tSContactArray                  m_scontacts;    // Soft contacts
        tJointArray                             m_joints;               // Joints
        tMaterialArray                  m_materials;    // Materials
        btScalar                                m_timeacc;              // Time accumulator
        btVector3                               m_bounds[2];    // Spatial bounds       
        bool                                    m_bUpdateRtCst; // Update runtime constants
        btDbvt                                  m_ndbvt;                // Nodes tree
        btDbvt                                  m_fdbvt;                // Faces tree
        btDbvt                                  m_cdbvt;                // Clusters tree
        tClusterArray                   m_clusters;             // Clusters

        btAlignedObjectArray<bool>m_clusterConnectivity;//cluster connectivity, for self-collision

        btTransform                     m_initialWorldTransform;

        btVector3                       m_windVelocity;
        //
        // Api
        //

        /* ctor                                                                                                                                 */ 
        btSoftBody(     btSoftBodyWorldInfo* worldInfo,int node_count,          const btVector3* x,             const btScalar* m);

        /* ctor                                                                                                                                 */ 
        btSoftBody(     btSoftBodyWorldInfo* worldInfo);

        void    initDefaults();

        /* dtor                                                                                                                                 */ 
        virtual ~btSoftBody();
        /* Check for existing link                                                                                              */ 

        btAlignedObjectArray<int>       m_userIndexMapping;

        btSoftBodyWorldInfo*    getWorldInfo()
        {
                return m_worldInfo;
        }

        virtual void    setCollisionShape(btCollisionShape* collisionShape)
        {
                
        }

        bool                            checkLink(      int node0,
                int node1) const;
        bool                            checkLink(      const Node* node0,
                const Node* node1) const;
        /* Check for existring face                                                                                             */ 
        bool                            checkFace(      int node0,
                int node1,
                int node2) const;
        /* Append material                                                                                                              */ 
        Material*                       appendMaterial();
        /* Append note                                                                                                                  */ 
        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);
        void                            appendNote(     const char* text,
                const btVector3& o,
                Node* feature);
        void                            appendNote(     const char* text,
                const btVector3& o,
                Link* feature);
        void                            appendNote(     const char* text,
                const btVector3& o,
                Face* feature);
        /* Append node                                                                                                                  */ 
        void                            appendNode(     const btVector3& x,btScalar m);
        /* Append link                                                                                                                  */ 
        void                            appendLink(int model=-1,Material* mat=0);
        void                            appendLink(     int node0,
                int node1,
                Material* mat=0,
                bool bcheckexist=false);
        void                            appendLink(     Node* node0,
                Node* node1,
                Material* mat=0,
                bool bcheckexist=false);
        /* Append face                                                                                                                  */ 
        void                            appendFace(int model=-1,Material* mat=0);
        void                            appendFace(     int node0,
                int node1,
                int node2,
                Material* mat=0);
        void                    appendTetra(int model,Material* mat);
        //
        void                    appendTetra(int node0,
                                                                                int node1,
                                                                                int node2,
                                                                                int node3,
                                                                                Material* mat=0);


        /* Append anchor                                                                                                                */ 
        void                            appendAnchor(   int node,
                btRigidBody* body, bool disableCollisionBetweenLinkedBodies=false,btScalar influence = 1);
        void                    appendAnchor(int node,btRigidBody* body, const btVector3& localPivot,bool disableCollisionBetweenLinkedBodies=false,btScalar influence = 1);
        /* Append linear joint                                                                                                  */ 
        void                            appendLinearJoint(const LJoint::Specs& specs,Cluster* body0,Body body1);
        void                            appendLinearJoint(const LJoint::Specs& specs,Body body=Body());
        void                            appendLinearJoint(const LJoint::Specs& specs,btSoftBody* body);
        /* Append linear joint                                                                                                  */ 
        void                            appendAngularJoint(const AJoint::Specs& specs,Cluster* body0,Body body1);
        void                            appendAngularJoint(const AJoint::Specs& specs,Body body=Body());
        void                            appendAngularJoint(const AJoint::Specs& specs,btSoftBody* body);
        /* Add force (or gravity) to the entire body                                                    */ 
        void                            addForce(               const btVector3& force);
        /* Add force (or gravity) to a node of the body                                                 */ 
        void                            addForce(               const btVector3& force,
                int node);
        /* Add velocity to the entire body                                                                              */ 
        void                            addVelocity(    const btVector3& velocity);

        /* Set velocity for the entire body                                                                             */ 
        void                            setVelocity(    const btVector3& velocity);

        /* Add velocity to a node of the body                                                                   */ 
        void                            addVelocity(    const btVector3& velocity,
                int node);
        /* Set mass                                                                                                                             */ 
        void                            setMass(                int node,
                btScalar mass);
        /* Get mass                                                                                                                             */ 
        btScalar                        getMass(                int node) const;
        /* Get total mass                                                                                                               */ 
        btScalar                        getTotalMass() const;
        /* Set total mass (weighted by previous masses)                                                 */ 
        void                            setTotalMass(   btScalar mass,
                bool fromfaces=false);
        /* Set total density                                                                                                    */ 
        void                            setTotalDensity(btScalar density);
        /* Set volume mass (using tetrahedrons)                                                                 */
        void                            setVolumeMass(          btScalar mass);
        /* Set volume density (using tetrahedrons)                                                              */
        void                            setVolumeDensity(       btScalar density);
        /* Transform                                                                                                                    */ 
        void                            transform(              const btTransform& trs);
        /* Translate                                                                                                                    */ 
        void                            translate(              const btVector3& trs);
        /* Rotate                                                                                                                       */ 
        void                            rotate( const btQuaternion& rot);
        /* Scale                                                                                                                                */ 
        void                            scale(  const btVector3& scl);
        /* Set current state as pose                                                                                    */ 
        void                            setPose(                bool bvolume,
                bool bframe);
        /* Return the volume                                                                                                    */ 
        btScalar                        getVolume() const;
        /* Cluster count                                                                                                                */ 
        int                                     clusterCount() const;
        /* Cluster center of mass                                                                                               */ 
        static btVector3        clusterCom(const Cluster* cluster);
        btVector3                       clusterCom(int cluster) const;
        /* Cluster velocity at rpos                                                                                             */ 
        static btVector3        clusterVelocity(const Cluster* cluster,const btVector3& rpos);
        /* Cluster impulse                                                                                                              */ 
        static void                     clusterVImpulse(Cluster* cluster,const btVector3& rpos,const btVector3& impulse);
        static void                     clusterDImpulse(Cluster* cluster,const btVector3& rpos,const btVector3& impulse);
        static void                     clusterImpulse(Cluster* cluster,const btVector3& rpos,const Impulse& impulse);
        static void                     clusterVAImpulse(Cluster* cluster,const btVector3& impulse);
        static void                     clusterDAImpulse(Cluster* cluster,const btVector3& impulse);
        static void                     clusterAImpulse(Cluster* cluster,const Impulse& impulse);
        static void                     clusterDCImpulse(Cluster* cluster,const btVector3& impulse);
        /* Generate bending constraints based on distance in the adjency graph  */ 
        int                                     generateBendingConstraints(     int distance,
                Material* mat=0);
        /* Randomize constraints to reduce solver bias                                                  */ 
        void                            randomizeConstraints();
        /* Release clusters                                                                                                             */ 
        void                            releaseCluster(int index);
        void                            releaseClusters();
        /* Generate clusters (K-mean)                                                                                   */ 
        int                                     generateClusters(int k,int maxiterations=8192);
        /* Refine                                                                                                                               */ 
        void                            refine(ImplicitFn* ifn,btScalar accurary,bool cut);
        /* CutLink                                                                                                                              */ 
        bool                            cutLink(int node0,int node1,btScalar position);
        bool                            cutLink(const Node* node0,const Node* node1,btScalar position);

        bool                            rayTest(const btVector3& rayFrom,
                const btVector3& rayTo,
                sRayCast& results);
        /* Solver presets                                                                                                               */ 
        void                            setSolver(eSolverPresets::_ preset);
        /* predictMotion                                                                                                                */ 
        void                            predictMotion(btScalar dt);
        /* solveConstraints                                                                                                             */ 
        void                            solveConstraints();
        /* staticSolve                                                                                                                  */ 
        void                            staticSolve(int iterations);
        /* solveCommonConstraints                                                                                               */ 
        static void                     solveCommonConstraints(btSoftBody** bodies,int count,int iterations);
        /* solveClusters                                                                                                                */ 
        static void                     solveClusters(const btAlignedObjectArray<btSoftBody*>& bodies);
        /* integrateMotion                                                                                                              */ 
        void                            integrateMotion();
        /* defaultCollisionHandlers                                                                                             */ 
        void                            defaultCollisionHandler(btCollisionObject* pco);
        void                            defaultCollisionHandler(btSoftBody* psb);



        //
        // Functionality to deal with new accelerated solvers.
        //

        void setWindVelocity( const btVector3 &velocity );


        const btVector3& getWindVelocity();

        //
        // Set the solver that handles this soft body
        // Should not be allowed to get out of sync with reality
        // Currently called internally on addition to the world
        void setSoftBodySolver( btSoftBodySolver *softBodySolver )
        {
                m_softBodySolver = softBodySolver;
        }

        //
        // Return the solver that handles this soft body
        // 
        btSoftBodySolver *getSoftBodySolver()
        {
                return m_softBodySolver;
        }

        //
        // Return the solver that handles this soft body
        // 
        btSoftBodySolver *getSoftBodySolver() const
        {
                return m_softBodySolver;
        }


        //
        // Cast
        //

        static const btSoftBody*        upcast(const btCollisionObject* colObj)
        {
                if (colObj->getInternalType()==CO_SOFT_BODY)
                        return (const btSoftBody*)colObj;
                return 0;
        }
        static btSoftBody*                      upcast(btCollisionObject* colObj)
        {
                if (colObj->getInternalType()==CO_SOFT_BODY)
                        return (btSoftBody*)colObj;
                return 0;
        }

        //
        // ::btCollisionObject
        //

        virtual void getAabb(btVector3& aabbMin,btVector3& aabbMax) const
        {
                aabbMin = m_bounds[0];
                aabbMax = m_bounds[1];
        }
        //
        // Private
        //
        void                            pointersToIndices();
        void                            indicesToPointers(const int* map=0);

        int                                     rayTest(const btVector3& rayFrom,const btVector3& rayTo,
                btScalar& mint,eFeature::_& feature,int& index,bool bcountonly) const;
        void                            initializeFaceTree();
        btVector3                       evaluateCom() const;
        bool                            checkContact(btCollisionObject* colObj,const btVector3& x,btScalar margin,btSoftBody::sCti& cti) const;
        void                            updateNormals();
        void                            updateBounds();
        void                            updatePose();
        void                            updateConstants();
        void                            initializeClusters();
        void                            updateClusters();
        void                            cleanupClusters();
        void                            prepareClusters(int iterations);
        void                            solveClusters(btScalar sor);
        void                            applyClusters(bool drift);
        void                            dampClusters();
        void                            applyForces();  
        static void                     PSolve_Anchors(btSoftBody* psb,btScalar kst,btScalar ti);
        static void                     PSolve_RContacts(btSoftBody* psb,btScalar kst,btScalar ti);
        static void                     PSolve_SContacts(btSoftBody* psb,btScalar,btScalar ti);
        static void                     PSolve_Links(btSoftBody* psb,btScalar kst,btScalar ti);
        static void                     VSolve_Links(btSoftBody* psb,btScalar kst);
        static psolver_t        getSolver(ePSolver::_ solver);
        static vsolver_t        getSolver(eVSolver::_ solver);


        virtual int     calculateSerializeBufferSize()  const;

        virtual const char*     serialize(void* dataBuffer,  class btSerializer* serializer) const;

        //virtual void serializeSingleObject(class btSerializer* serializer) const;


};




#endif //_BT_SOFT_BODY_H