Joint.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#ifndef PHY_JOINT_H
#define PHY_JOINT_H

#include <ode/ode.h>
#include <PVLE/Physics/Converters.h>
#include <PVLE/Physics/Contact.h>
#include <PVLE/Export.h>
#include <PVLE/Util/Util.h>
#include <PVLE/Util/TracedException.h>

#include <set>
#include <osg/ref_ptr>
#include <osg/Vec3>
#include <osg/Referenced>

namespace Physics {

// Forward declarations
class World;
class Body;
class Visitor;

class JointFeedback : protected dJointFeedback {
public:
    osg::Vec3 getF1() const { return toGraphVec3(f1); }
    osg::Vec3 getT1() const { return toGraphVec3(t1); }
    osg::Vec3 getF2() const { return toGraphVec3(f2); }
    osg::Vec3 getT2() const { return toGraphVec3(t2); }

    friend class Joint;
};


class PVLE_EXPORT Joint : public osg::Referenced {
public:
    enum EJointType {
        BALL = dJointTypeBall,                  
        HINGE = dJointTypeHinge,                
        HINGE2 = dJointTypeHinge2,              
        UNIVERSAL = dJointTypeUniversal,        

        SLIDER = dJointTypeSlider,              
        PRISMATIC_ROTOIDE = dJointTypePR,       
        FIXED = dJointTypeFixed,                

        CONTACT = dJointTypeContact,            

        ANGULAR_MOTOR = dJointTypeAMotor,       
        LINEAR_MOTOR = dJointTypeLMotor,        

        PLANE2D = dJointTypePlane2D             // TODO PLANE2D not implemented
    };

    enum EAnchoredTo {
        GLOBAL = 0,
        BODY1 = 1,
        BODY2 = 2
    };

    enum EAMotorMode {
        ANGULAR_MOTOR_USER = dAMotorUser,
        ANGULAR_MOTOR_EULER = dAMotorEuler
    };

    Joint(World * pWorld, EJointType type);
    Joint(World * pWorld, Contact * pContact = NULL);
    Joint(const Joint & v);

    ~Joint() { if (id) dJointDestroy(id); }     // Kept public for C3DPhyOwner - No need to be virtual then

    inline EJointType getType() const { return static_cast<EJointType>(dJointGetType(id)); }
    void attach(Body * pBody1, Body * pBody2);

    Body * getBody1();
    Body * getBody2();

    const Body * getBody1() const;
    const Body * getBody2() const;

    UINT getNumBodies() const { return static_cast<UINT>(dJointGetNumBodies(id)); }

    void setFeedback(JointFeedback * pJointFeedback) { dJointSetFeedback(id, pJointFeedback); }
    inline JointFeedback * getFeedback() { return static_cast<JointFeedback *>(dJointGetFeedback(id)); }
    inline const JointFeedback * getFeedback() const { return static_cast<const JointFeedback *>(dJointGetFeedback(id)); }


    void setPos(const osg::Vec3 & pos);
    osg::Vec3 getPosBody1() const;
    osg::Vec3 getPosBody2() const;

    void setAxis1(const osg::Vec3 & axis);
    osg::Vec3 getAxis1() const;
    void setAxis2(const osg::Vec3 & axis);
    osg::Vec3 getAxis2() const;

    void setAMotorMode(EAMotorMode mode);
    EAMotorMode getAMotorMode() const;
    void setNumAxes(UCHAR num);
    UCHAR getNumAxes() const;
    // The axis vector is always specified in global coordinates regardless of the frame.
    void setMotorAxis(UCHAR num, EAnchoredTo frame, const osg::Vec3 & axis);
    osg::Vec3 getMotorAxis(UCHAR num) const;
    EAnchoredTo getAxisFrameAMotor(UCHAR num) const;
    void setAxisAngleAMotor(UCHAR num, dReal angle);
    dReal getAxisAngleAMotor(UCHAR num) const;
    dReal getAxisAngleRateAMotor(UCHAR num) const;

    dReal getRelAngleAxis1() const;
    dReal getRelAngleRateAxis1() const;
    dReal getRelAngleRateAxis2() const;

    dReal getRelPosAxis1() const;
    dReal getRelPosRateAxis1() const;




    void setCFM(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamCFM + dParamGroup*axis, val); }
    dReal getCFM(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamCFM + dParamGroup*axis); }


    void setLoStop(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamLoStop + dParamGroup*axis, val); }
    dReal getLoStop(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamLoStop + dParamGroup*axis); }

    void setHiStop(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamHiStop + dParamGroup*axis, val); }
    dReal getHiStop(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamHiStop + dParamGroup*axis); }

    void setStopBouncyness(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamBounce + dParamGroup*axis, val); }
    dReal getStopBouncyness(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamBounce + dParamGroup*axis); }

    void setStopERP(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamStopERP + dParamGroup*axis, val); }
    dReal getStopERP(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamStopERP + dParamGroup*axis); }

    void setStopCFM(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamStopCFM + dParamGroup*axis, val); }
    dReal getStopCFM(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamStopCFM + dParamGroup*axis); }


    void setMotorVel(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamVel + dParamGroup*axis, val); }
    dReal getMotorVel(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamVel + dParamGroup*axis); }

    void setMotorMaxForce(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamFMax + dParamGroup*axis, val); }
    dReal getMotorMaxForce(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamFMax + dParamGroup*axis); }

    void setMotorFudgeFactor(dReal val, UINT axis=0) { ASSERT(axis<=3); getODESetParamFuncPt()(id, dParamFudgeFactor + dParamGroup*axis, val); }
    dReal getMotorFudgeFactor(UINT axis=0) const { ASSERT(axis<=3); return getODEGetParamFuncPt()(id, dParamFudgeFactor + dParamGroup*axis); }


    void copyParameters(const Joint & v);

    //dJointAddHingeTorque
    //dJointAddHinge2Torques
    //dJointAddUniversalTorques
    //dJointAddPRTorque
    //dJointAddAMotorTorques
    //dJointAddSliderForce

    //void setPos(const osg::Vec3 & pos) { dGeomSetPosition(id, pos.x(), pos.y(), pos.z()); }
    void translate(const osg::Vec3 & vec);
    //osg::Vec3 getPos() const { return toGraphVec3(dGeomGetPosition(id)); }

    //void setQuaternion(const osg::Quat & quat) { dQuaternion q; toPhyQuat(quat, q); dGeomSetQuaternion(id, q); }
    void rotate(const osg::Quat & quat);
    void rotate(const osg::Quat & quat, const osg::Vec3 & center);
    //osg::Quat getQuaternion() const { dQuaternion q; dGeomGetQuaternion(id, q); return toGraphQuat(q); }

    virtual void accept(Visitor & v);
    //virtual void traverse(Visitor & v);

protected:
    friend class JointGroup;
    mutable dJointID id;
    dWorldID worldId;           // Used only for copy constructor

    Joint(World * pWorld, EJointType type, dJointGroupID joinGroup);
    Joint(World * pWorld, Contact * pContact, dJointGroupID joinGroup);

    void init(EJointType type, dContact * pContact = NULL, dJointGroupID joinGroup = NULL);

    // Used for stop and motors
    typedef void(*TFuncODESetParam)(dJointID, int, dReal);
    typedef dReal(*TFuncODEGetParam)(dJointID, int);

    TFuncODESetParam getODESetParamFuncPt() const;      
    TFuncODEGetParam getODEGetParamFuncPt() const;      
};


class JointGroup : public osg::Referenced {
public:
    JointGroup() { id = dJointGroupCreate(0); }

    Joint * createAndAdd(World * pWorld, Joint::EJointType type) {
        Joint * pJ = new Joint(pWorld, type, id);
        vJoints.insert(pJ);
        return pJ;
    }

    Joint * createAndAdd(World * pWorld, Contact * pContact) {
        Joint * pJ = new Joint(pWorld, pContact, id);
        vJoints.insert(pJ);
        return pJ;
    }

    void clear() { vJoints.clear(); dJointGroupEmpty(id); }

protected:
    mutable dJointGroupID id;
    std::set<osg::ref_ptr<Joint> > vJoints;

    virtual ~JointGroup() { dJointGroupDestroy(id); }       // No need to be virtual, except for forcing the derived objects to also behave the same
};

}   // namespace Physics

#endif  // PHY_JOINT_H

---