CcdPhysicsController.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 BULLET2_PHYSICSCONTROLLER_H
#define BULLET2_PHYSICSCONTROLLER_H

#include <vector>
#include <map>

#include "PHY_IPhysicsController.h"

#include "btBulletDynamicsCommon.h"
#include "LinearMath/btTransform.h"

#include "PHY_IMotionState.h"

extern float gDeactivationTime;
extern float gLinearSleepingTreshold;
extern float gAngularSleepingTreshold;
extern bool gDisableDeactivation;
class CcdPhysicsEnvironment;
class btMotionState;
class RAS_MeshObject;
struct DerivedMesh;
class btCollisionShape;


#define CCD_BSB_SHAPE_MATCHING  2
#define CCD_BSB_BENDING_CONSTRAINTS 8
#define CCD_BSB_AERO_VPOINT 16 /* aero model, Vertex normals are oriented toward velocity*/
#define CCD_BSB_AERO_VTWOSIDE 32 /* aero model, Vertex normals are flipped to match velocity */

/* BulletSoftBody.collisionflags */
#define CCD_BSB_COL_SDF_RS  2 /* SDF based rigid vs soft */
#define CCD_BSB_COL_CL_RS   4 /* Cluster based rigid vs soft */
#define CCD_BSB_COL_CL_SS   8 /* Cluster based soft vs soft */
#define CCD_BSB_COL_VF_SS   16 /* Vertex/Face based soft vs soft */


// Shape contructor
// It contains all the information needed to create a simple bullet shape at runtime
class CcdShapeConstructionInfo
{
public:
    struct UVco 
    {
        float uv[2];
    };
    
    static CcdShapeConstructionInfo* FindMesh(class RAS_MeshObject* mesh, struct DerivedMesh* dm, bool polytope);

    CcdShapeConstructionInfo() :
        m_shapeType(PHY_SHAPE_NONE),
        m_radius(1.0),
        m_height(1.0),
        m_halfExtend(0.f,0.f,0.f),
        m_childScale(1.0f,1.0f,1.0f),
        m_userData(NULL),
        m_refCount(1),
        m_meshObject(NULL),
        m_unscaledShape(NULL),
        m_forceReInstance(false),
        m_weldingThreshold1(0.f),
        m_shapeProxy(NULL)
    {
        m_childTrans.setIdentity();
    }

    ~CcdShapeConstructionInfo();

    CcdShapeConstructionInfo* AddRef()
    { 
        m_refCount++;
        return this;
    }

    int Release()
    {
        if (--m_refCount > 0)
            return m_refCount;
        delete this;
        return 0;
    }

    bool IsUnused(void)
    {
        return (m_meshObject==NULL && m_shapeArray.size() == 0 && m_shapeProxy == NULL);
    }

    void AddShape(CcdShapeConstructionInfo* shapeInfo);

    btTriangleMeshShape* GetMeshShape(void)
    {
        return (m_unscaledShape);
    }
    CcdShapeConstructionInfo* GetChildShape(int i)
    {
        if (i < 0 || i >= (int)m_shapeArray.size())
            return NULL;

        return m_shapeArray.at(i);
    }
    int FindChildShape(CcdShapeConstructionInfo* shapeInfo, void* userData)
    {
        if (shapeInfo == NULL)
            return -1;
        for (int i=0; i<(int)m_shapeArray.size(); i++)
        {
            CcdShapeConstructionInfo* childInfo = m_shapeArray.at(i);
            if ((userData == NULL || userData == childInfo->m_userData) &&
                (childInfo == shapeInfo ||
                 (childInfo->m_shapeType == PHY_SHAPE_PROXY && 
                  childInfo->m_shapeProxy == shapeInfo)))
                return i;
        }
        return -1;
    }

    bool RemoveChildShape(int i)
    {
        if (i < 0 || i >= (int)m_shapeArray.size())
            return false;
        m_shapeArray.at(i)->Release();
        if (i < (int)m_shapeArray.size()-1)
            m_shapeArray[i] = m_shapeArray.back();
        m_shapeArray.pop_back();
        return true;
    }

    bool SetMesh(class RAS_MeshObject* mesh, struct DerivedMesh* dm, bool polytope);
    RAS_MeshObject* GetMesh(void)
    {
        return m_meshObject;
    }

    bool UpdateMesh(class KX_GameObject* gameobj, class RAS_MeshObject* mesh);


    bool SetProxy(CcdShapeConstructionInfo* shapeInfo);
    CcdShapeConstructionInfo* GetProxy(void)
    {
        return m_shapeProxy;
    }

    btCollisionShape* CreateBulletShape(btScalar margin, bool useGimpact=false, bool useBvh=true);

    // member variables
    PHY_ShapeType           m_shapeType;
    btScalar                m_radius;
    btScalar                m_height;
    btVector3               m_halfExtend;
    btTransform             m_childTrans;
    btVector3               m_childScale;
    void*                   m_userData; 
    btAlignedObjectArray<btScalar>  m_vertexArray;  // Contains both vertex array for polytope shape and
                                            // triangle array for concave mesh shape. Each vertex is 3 consecutive values
                                            // In this case a triangle is made of 3 consecutive points
    std::vector<int>        m_polygonIndexArray;    // Contains the array of polygon index in the 
                                                    // original mesh that correspond to shape triangles.
                                                    // only set for concave mesh shape.
    
    std::vector<int>        m_triFaceArray; // Contains an array of triplets of face indicies
                                            // quads turn into 2 tris

    std::vector<UVco>       m_triFaceUVcoArray; // Contains an array of pair of UV coordinate for each vertex of faces
                                                // quads turn into 2 tris

    void    setVertexWeldingThreshold1(float threshold)
    {
        m_weldingThreshold1  = threshold*threshold;
    }
protected:
    static std::map<RAS_MeshObject*, CcdShapeConstructionInfo*> m_meshShapeMap;
    int                     m_refCount;     // this class is shared between replicas
                                            // keep track of users so that we can release it 
    RAS_MeshObject* m_meshObject;           // Keep a pointer to the original mesh 
    btBvhTriangleMeshShape* m_unscaledShape;// holds the shared unscale BVH mesh shape, 
                                            // the actual shape is of type btScaledBvhTriangleMeshShape
    std::vector<CcdShapeConstructionInfo*> m_shapeArray;    // for compound shapes
    bool    m_forceReInstance; //use gimpact for concave dynamic/moving collision detection
    float   m_weldingThreshold1;    //welding closeby vertices together can improve softbody stability etc.
    CcdShapeConstructionInfo* m_shapeProxy; // only used for PHY_SHAPE_PROXY, pointer to actual shape info


#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:CcdShapeConstructionInfo"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

struct CcdConstructionInfo
{

    enum CollisionFilterGroups
    {
        DefaultFilter = 1,
        StaticFilter = 2,
        KinematicFilter = 4,
        DebrisFilter = 8,
        SensorFilter = 16,
        AllFilter = DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorFilter,
    };


    CcdConstructionInfo()
        :m_localInertiaTensor(1.f, 1.f, 1.f),
        m_gravity(0,0,0),
        m_scaling(1.f,1.f,1.f),
        m_mass(0.f),
        m_clamp_vel_min(-1.f),
        m_clamp_vel_max(-1.f),
        m_restitution(0.1f),
        m_friction(0.5f),
        m_linearDamping(0.1f),
        m_angularDamping(0.1f),
        m_margin(0.06f),
        m_gamesoftFlag(0),
        m_soft_linStiff(1.f),
        m_soft_angStiff(1.f),
        m_soft_volume(1.f),
        m_soft_viterations(0),
        m_soft_piterations(1),
        m_soft_diterations(0),
        m_soft_citerations(4),
        m_soft_kSRHR_CL(0.1f),
        m_soft_kSKHR_CL(1.f),
        m_soft_kSSHR_CL(0.5f),
        m_soft_kSR_SPLT_CL(0.5f),
        m_soft_kSK_SPLT_CL(0.5f),
        m_soft_kSS_SPLT_CL(0.5f),
        m_soft_kVCF(1.f),
        m_soft_kDP(0.f),
        m_soft_kDG(0.f),
        m_soft_kLF(0.f),
        m_soft_kPR(0.f),
        m_soft_kVC(0.f),
        m_soft_kDF(0.2f),
        m_soft_kMT(0),
        m_soft_kCHR(1.0f),
        m_soft_kKHR(0.1f),
        m_soft_kSHR(1.0f),
        m_soft_kAHR(0.7f),
        m_collisionFlags(0),
        m_bRigid(false),
        m_bSoft(false),
        m_bSensor(false),
        m_bGimpact(false),
        m_collisionFilterGroup(DefaultFilter),
        m_collisionFilterMask(AllFilter),
        m_collisionShape(0),
        m_MotionState(0),
        m_shapeInfo(0),
        m_physicsEnv(0),
        m_inertiaFactor(1.f),
        m_do_anisotropic(false),
        m_anisotropicFriction(1.f,1.f,1.f),
        m_do_fh(false),
        m_do_rot_fh(false),
        m_fh_spring(0.f),
        m_fh_damping(0.f),
        m_fh_distance(1.f),
        m_fh_normal(false),
        m_contactProcessingThreshold(1e10f)
    {

    }

    btVector3   m_localInertiaTensor;
    btVector3   m_gravity;
    btVector3   m_scaling;
    btScalar    m_mass;
    btScalar    m_clamp_vel_min;  
    btScalar    m_clamp_vel_max;  
    btScalar    m_restitution;
    btScalar    m_friction;
    btScalar    m_linearDamping;
    btScalar    m_angularDamping;
    btScalar    m_margin;

    int     m_gamesoftFlag;
    float   m_soft_linStiff;            /* linear stiffness 0..1 */
    float   m_soft_angStiff;        /* angular stiffness 0..1 */
    float   m_soft_volume;          /* volume preservation 0..1 */

    int     m_soft_viterations;     /* Velocities solver iterations */
    int     m_soft_piterations;     /* Positions solver iterations */
    int     m_soft_diterations;     /* Drift solver iterations */
    int     m_soft_citerations;     /* Cluster solver iterations */

    float   m_soft_kSRHR_CL;        /* Soft vs rigid hardness [0,1] (cluster only) */
    float   m_soft_kSKHR_CL;        /* Soft vs kinetic hardness [0,1] (cluster only) */
    float   m_soft_kSSHR_CL;        /* Soft vs soft hardness [0,1] (cluster only) */
    float   m_soft_kSR_SPLT_CL; /* Soft vs rigid impulse split [0,1] (cluster only) */

    float   m_soft_kSK_SPLT_CL; /* Soft vs rigid impulse split [0,1] (cluster only) */
    float   m_soft_kSS_SPLT_CL; /* Soft vs rigid impulse split [0,1] (cluster only) */
    float   m_soft_kVCF;            /* Velocities correction factor (Baumgarte) */
    float   m_soft_kDP;         /* Damping coefficient [0,1] */

    float   m_soft_kDG;         /* Drag coefficient [0,+inf] */
    float   m_soft_kLF;         /* Lift coefficient [0,+inf] */
    float   m_soft_kPR;         /* Pressure coefficient [-inf,+inf] */
    float   m_soft_kVC;         /* Volume conversation coefficient [0,+inf] */

    float   m_soft_kDF;         /* Dynamic friction coefficient [0,1] */
    float   m_soft_kMT;         /* Pose matching coefficient [0,1] */
    float   m_soft_kCHR;            /* Rigid contacts hardness [0,1] */
    float   m_soft_kKHR;            /* Kinetic contacts hardness [0,1] */

    float   m_soft_kSHR;            /* Soft contacts hardness [0,1] */
    float   m_soft_kAHR;            /* Anchors hardness [0,1] */
    int     m_soft_collisionflags;  /* Vertex/Face or Signed Distance Field(SDF) or Clusters, Soft versus Soft or Rigid */
    int     m_soft_numclusteriterations;    /* number of iterations to refine collision clusters*/



    int         m_collisionFlags;
    bool        m_bRigid;
    bool        m_bSoft;
    bool        m_bSensor;
    bool        m_bGimpact;         // use Gimpact for mesh body

    short int   m_collisionFilterGroup;
    short int   m_collisionFilterMask;

    class btCollisionShape* m_collisionShape;
    class PHY_IMotionState* m_MotionState;
    class CcdShapeConstructionInfo* m_shapeInfo;
    
    CcdPhysicsEnvironment*  m_physicsEnv; //needed for self-replication
    float   m_inertiaFactor;//tweak the inertia (hooked up to Blender 'formfactor'
    bool    m_do_anisotropic;
    btVector3 m_anisotropicFriction;

    bool        m_do_fh;                 
    bool        m_do_rot_fh;             
    btScalar    m_fh_spring;             
    btScalar    m_fh_damping;            
    btScalar    m_fh_distance;           
    bool        m_fh_normal;             
    float       m_radius;//for fh backwards compatibility
    
    float       m_contactProcessingThreshold;

};


class btRigidBody;
class btCollisionObject;
class btSoftBody;

class CcdPhysicsController : public PHY_IPhysicsController  
{
protected:
    btCollisionObject* m_object;
    

    class PHY_IMotionState*     m_MotionState;
    btMotionState*  m_bulletMotionState;
    class btCollisionShape* m_collisionShape;
    class CcdShapeConstructionInfo* m_shapeInfo;

    friend class CcdPhysicsEnvironment; // needed when updating the controller

    //some book keeping for replication
    bool    m_softbodyMappingDone;
    bool    m_softBodyTransformInitialized;
    bool    m_prototypeTransformInitialized;
    btTransform m_softbodyStartTrans;


    void*       m_newClientInfo;
    int         m_registerCount;    // needed when multiple sensors use the same controller
    CcdConstructionInfo m_cci;//needed for replication

    CcdPhysicsController* m_parentCtrl;

    void GetWorldOrientation(btMatrix3x3& mat);

    void CreateRigidbody();
    bool CreateSoftbody();

    bool Register() { 
        return (m_registerCount++ == 0) ? true : false;
    }
    bool Unregister() {
        return (--m_registerCount == 0) ? true : false;
    }

    void setWorldOrientation(const btMatrix3x3& mat);
    void forceWorldTransform(const btMatrix3x3& mat, const btVector3& pos);

    public:
    
        int             m_collisionDelay;
    

        CcdPhysicsController (const CcdConstructionInfo& ci);

        bool DeleteControllerShape();
        bool ReplaceControllerShape(btCollisionShape *newShape);

        virtual ~CcdPhysicsController();

        CcdConstructionInfo& getConstructionInfo()
        {
            return m_cci;
        }
        const CcdConstructionInfo& getConstructionInfo() const
        {
            return m_cci;
        }


        btRigidBody* GetRigidBody();
        btCollisionObject*  GetCollisionObject();
        btSoftBody* GetSoftBody();

        CcdShapeConstructionInfo* GetShapeInfo() { return m_shapeInfo; }

        btCollisionShape*   GetCollisionShape() { 
            return m_object->getCollisionShape();
        }
        // PHY_IPhysicsController interface


        virtual bool        SynchronizeMotionStates(float time);
        virtual void        WriteMotionStateToDynamics(bool nondynaonly);
        virtual void        WriteDynamicsToMotionState();

        // controller replication
        virtual void        PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl);
        virtual void        SetPhysicsEnvironment(class PHY_IPhysicsEnvironment *env);

        // kinematic methods
        virtual void        RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local);
        virtual void        RelativeRotate(const float drot[9],bool local);
        virtual void        getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal);
        virtual void        setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal);
        virtual void        setPosition(float posX,float posY,float posZ);
        virtual void        getPosition(PHY__Vector3&   pos) const;

        virtual void        setScaling(float scaleX,float scaleY,float scaleZ);
        
        // physics methods
        virtual void        ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local);
        virtual void        ApplyForce(float forceX,float forceY,float forceZ,bool local);
        virtual void        SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local);
        virtual void        SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local);
        virtual void        applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ);
        virtual void        SetActive(bool active);

        // reading out information from physics
        virtual void        GetLinearVelocity(float& linvX,float& linvY,float& linvZ);
        virtual void        GetAngularVelocity(float& angVelX,float& angVelY,float& angVelZ);
        virtual void        GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ); 
        virtual void        getReactionForce(float& forceX,float& forceY,float& forceZ);

        // dyna's that are rigidbody are free in orientation, dyna's with non-rigidbody are restricted 
        virtual void        setRigidBody(bool rigid);

        
        virtual void        resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);

        // clientinfo for raycasts for example
        virtual void*               getNewClientInfo();
        virtual void                setNewClientInfo(void* clientinfo);
        virtual PHY_IPhysicsController* GetReplica();
        
        short int   GetCollisionFilterGroup() const
        {
            return m_cci.m_collisionFilterGroup;
        }
        short int   GetCollisionFilterMask() const
        {
            return m_cci.m_collisionFilterMask;
        }

        virtual void    calcXform() {} ;
        virtual void SetMargin(float margin) 
        {
            if (m_collisionShape)
                m_collisionShape->setMargin(btScalar(margin));
        }
        virtual float GetMargin() const 
        {
            return (m_collisionShape) ? m_collisionShape->getMargin() : 0.f;
        }
        virtual float GetRadius() const 
        { 
            // this is not the actual shape radius, it's only used for Fh support
            return m_cci.m_radius;
        }
        virtual void  SetRadius(float margin) 
        {
            if (m_collisionShape && m_collisionShape->getShapeType() == SPHERE_SHAPE_PROXYTYPE)
            {
                btSphereShape* sphereShape = static_cast<btSphereShape*>(m_collisionShape);
                sphereShape->setUnscaledRadius(margin);
            }
            m_cci.m_radius = margin;
        }
        
        // velocity clamping
        virtual void SetLinVelocityMin(float val) 
        {
            m_cci.m_clamp_vel_min= val;
        }
        virtual float GetLinVelocityMin() const 
        {
            return m_cci.m_clamp_vel_min;
        }
        virtual void SetLinVelocityMax(float val) 
        {
            m_cci.m_clamp_vel_max= val;
        }
        virtual float GetLinVelocityMax() const 
        {
            return m_cci.m_clamp_vel_max;
        }

        bool    wantsSleeping();

        void    UpdateDeactivation(float timeStep);

        void    SetCenterOfMassTransform(btTransform& xform);

        static btTransform& GetTransformFromMotionState(PHY_IMotionState* motionState);

        void    setAabb(const btVector3& aabbMin,const btVector3& aabbMax);


        class   PHY_IMotionState*           GetMotionState()
        {
            return m_MotionState;
        }

        const class PHY_IMotionState*           GetMotionState() const
        {
            return m_MotionState;
        }

        class CcdPhysicsEnvironment* GetPhysicsEnvironment()
        {
            return m_cci.m_physicsEnv;
        }

        void    setParentCtrl(CcdPhysicsController* parentCtrl)
        {
            m_parentCtrl = parentCtrl;
        }

        CcdPhysicsController*   getParentCtrl()
        {
            return m_parentCtrl;
        }

        const CcdPhysicsController* getParentCtrl() const
        {
            return m_parentCtrl;
        }

        virtual const char* getName()
        {
            return 0;
        }

#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:CcdPhysicsController"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};




class   DefaultMotionState : public PHY_IMotionState

{
    public:
        DefaultMotionState();

        virtual ~DefaultMotionState();

        virtual void    getWorldPosition(float& posX,float& posY,float& posZ);
        virtual void    getWorldScaling(float& scaleX,float& scaleY,float& scaleZ);
        virtual void    getWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal);
        
        virtual void    setWorldPosition(float posX,float posY,float posZ);
        virtual void    setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal);
        virtual void    getWorldOrientation(float* ori);
        virtual void    setWorldOrientation(const float* ori);
        
        virtual void    calculateWorldTransformations();
        
        btTransform m_worldTransform;
        btVector3       m_localScaling;
    
    
#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:DefaultMotionState"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};


#endif //BULLET2_PHYSICSCONTROLLER_H