OgreNewt_BasicJoints.h

Go to the documentation of this file.

/* 
    OgreNewt Library
 
    Ogre implementation of Newton Game Dynamics SDK
 
    OgreNewt basically has no license, you may use any or all of the library however you desire... I hope it can help you in any way.
 
        by Walaber
        some changes by melven
 
*/
#ifndef _INCLUDE_OGRENEWT_BASICJOINTS
#define _INCLUDE_OGRENEWT_BASICJOINTS
 
#include "OgreNewt_Prerequisites.h"
#include "OgreNewt_Joint.h"
 
 
// OgreNewt namespace.  all functions and classes use this namespace.
namespace OgreNewt
{
 
 
        class _OgreNewtExport BallAndSocketLimits : public Joint
        {
  private:
        public:
 
                BallAndSocketLimits( const OgreNewt::Body* child, const OgreNewt::Body* parent, const Ogre::Vector3& pos );
 
                ~BallAndSocketLimits();
 
                Ogre::Vector3 getJointAngle();
 
                Ogre::Vector3 getJointOmega();
 
 
                Ogre::Vector3 getJointForce();
 
 
                void setLimits(Ogre::Radian maxCone, Ogre::Radian minTwist, Ogre::Radian maxTwist);
        };
 
 
 
        class _OgreNewtExport BallAndSocket : public Joint
        {
  private:
        public:
 
                BallAndSocket( const OgreNewt::Body* child, const OgreNewt::Body* parent, const Ogre::Vector3& pos );
 
                ~BallAndSocket();
 
                Ogre::Vector3 getJointAngle();
 
                Ogre::Vector3 getJointOmega();
 
 
                Ogre::Vector3 getJointForce();
        };
 
 
        class _OgreNewtExport ControlledBallAndSocket : public Joint
        {
  private:
        public:
 
                ControlledBallAndSocket( const OgreNewt::Body* child, const OgreNewt::Body* parent, const Ogre::Vector3& pos );
 
                ~ControlledBallAndSocket();
 
                Ogre::Vector3 getJointAngle();
 
                Ogre::Vector3 getJointOmega();
 
 
                Ogre::Vector3 getJointForce();
 
          void SetAngularVelocity(Ogre::Real omegaMag);
          Ogre::Real GetAngularVelocity() const;
 
          void SetPitchAngle(Ogre::Real angle);
          Ogre::Real GetPitchAngle() const;
 
          void SetYawAngle(Ogre::Real angle);
          Ogre::Real GetYawAngle() const;
 
          void SetRollAngle(Ogre::Real angle);
          Ogre::Real GetRollAngle() const;
        };
 
 
        class _OgreNewtExport Hinge : public Joint
        {
 
        public:
 
 
                Hinge (const OgreNewt::Body* child, const OgreNewt::Body* parent, const Ogre::Vector3& pos, const Ogre::Vector3& pin );
 
                ~Hinge();
 
                void enableLimits(bool state);
 
    void enableMotor(bool state);
 
                void setLimits(Ogre::Radian minAngle, Ogre::Radian maxAngle);
 
                Ogre::Radian getJointAngle () const;
 
 
                Ogre::Vector3 getJointForce();
 
                Ogre::Radian getJointAngularVelocity () const;
 
                Ogre::Vector3 getJointPin () const;
 
                void setDesiredOmega(Ogre::Radian omega, Ogre::Real strength = 0.5f);
 
                void setDesiredAngle(Ogre::Radian angle, Ogre::Real minFriction = 0, Ogre::Real maxFriction = 0);
 
 
                void setTorque(Ogre::Real torque);
 
                //   0: brake with infinite force
                // > 0: brake with limited force
                void setBrake(Ogre::Real maxForce = 0);
 
                void clearConstraints() {m_constraintType = CONSTRAINT_NONE;}
 
                virtual void submitConstraint(Ogre::Real timestep, int threadindex);
 
        protected:
                enum ConstraintType { CONSTRAINT_NONE, CONSTRAINT_OMEGA, CONSTRAINT_ANGLE, CONSTRAINT_BRAKE };
 
                ConstraintType m_constraintType;
                ConstraintType m_lastConstraintType;
 
                Ogre::Radian m_desiredOmega;
                Ogre::Radian m_desiredAngle;
 
    bool m_useLimits;
    bool m_useMotor;
    Ogre::Radian m_minAngle;
                Ogre::Radian m_maxAngle;
 
                Ogre::Real m_motorStrength;
                Ogre::Real m_motorTorque;
                Ogre::Real m_motorMinFriction;
                Ogre::Real m_motorMaxFriction;
                Ogre::Real m_brakeMaxForce;
                
                bool m_torqueOn;
        };
 
 
 
        class _OgreNewtExport Slider : public Joint
        {
 
                public:
 
 
                Slider(const OgreNewt::Body* child, const OgreNewt::Body* parent, const Ogre::Vector3& pos, const Ogre::Vector3& pin );
 
                ~Slider();
 
                void enableLimits(bool state);
 
    void setFriction(Ogre::Real friction);
 
    void enableMotor(bool state);
 
    void setMotorVelocity(Ogre::Real velocity, Ogre::Real strength);
 
                void setLimits(Ogre::Real minStopDist, Ogre::Real maxStopDist);
 
                void enableSpring(bool state);
 
    void setSpring(Ogre::Real springStrength, Ogre::Real springDamping);
 
 
                Ogre::Vector3 getJointForce();
 
                Ogre::Real getJointVelocity() const;
 
    Ogre::Real getDistance() const;
 
    virtual void submitConstraint(Ogre::Real timestep, int threadindex);
 
 
  private: 
    bool m_useLimits;
    Ogre::Real m_minDist;
                Ogre::Real m_maxDist;
    bool m_useSpring;
    Ogre::Real m_springStrength;
    Ogre::Real m_springDamping;
        };
 
 
 
        class _OgreNewtExport UpVector : public Joint
        {
        public:
                /*
                \param world pointer to the OgreNewt::World.
                \param body pointer to the body to apply the upvector to.
                \param pin direction of the upvector in global space.
                */
                UpVector( const Body* body, const Ogre::Vector3& pin );
 
                ~UpVector();
 
                /*
                by calling this function in realtime, you can effectively "animate" the pin.
                */
                void setPin( const Ogre::Vector3& pin );
 
                const Ogre::Vector3& getPin() const;
 
        private:
                Ogre::Vector3 m_pin;
        };
 
#if 0
 
        class _OgreNewtExport Universal : public Joint
        {
 
        public:
 
 
                typedef void(*UniversalCallback)( Universal* me );
 
 
                Universal( const World* world, const OgreNewt::Body* child, const OgreNewt::Body* parent, const Ogre::Vector3& pos, const Ogre::Vector3& pin0, const Ogre::Vector3& pin1 );
 
                ~Universal();
 
                Ogre::Radian getJointAngle0() const { return Ogre::Radian(NewtonUniversalGetJointAngle0( m_joint )); }
 
                Ogre::Radian getJointAngle1() const { return Ogre::Radian(NewtonUniversalGetJointAngle1( m_joint )); }
 
                Ogre::Real getJointOmega0() const { return (Ogre::Real)NewtonUniversalGetJointOmega0( m_joint ); }
 
                Ogre::Real getJointOmega1() const { return (Ogre::Real)NewtonUniversalGetJointOmega1( m_joint ); }
 
                Ogre::Vector3 getJointForce() const;
 
 
                void setCallback( UniversalCallback callback ) { m_callback = callback; }
 
                // the following commands are only valid from inside a hinge callback function
 
                /*
                this function can only be called from within a custom callback.
                \param accel desired acceleration
                \param axis which pin to use (0 or 1)
                */
                void setCallbackAccel( Ogre::Real accel, unsigned axis );
 
                /*
                this function can only be called from within a custom callback.
                \param min minimum friction
                \param axis which pin to use (0 or 1)
                */
                void setCallbackFrictionMin( Ogre::Real min, unsigned axis );
 
                /*
                this function can only be called from within a custom callback.
                \param max maximum friction
                \param axis which pin to use (0 or 1)
                */
                void setCallbackFrictionMax( Ogre::Real max, unsigned axis );
 
                /*
                this function can only be called from within a custom callback.
                */
                Ogre::Real getCallbackTimestep() const;
 
 
                Ogre::Real calculateStopAlpha0( Ogre::Real angle ) const;
 
 
                Ogre::Real calculateStopAlpha1( Ogre::Real angle ) const;
 
        protected:
 
                static unsigned _CDECL newtonCallback( const NewtonJoint* universal, NewtonHingeSliderUpdateDesc* desc );
 
                UniversalCallback m_callback;
                NewtonHingeSliderUpdateDesc* m_desc;
 
                unsigned m_retval;
        };
 
 
 
 
        class _OgreNewtExport UpVector : public Joint
        {
 
        public:
                /*
                \param world pointer to the OgreNewt::World.
                \param body pointer to the body to apply the upvector to.
                \param pin direction of the upvector in global space.
                */
                UpVector( const World* world, const Body* body, const Ogre::Vector3& pin );
 
                ~UpVector();
 
                /*
                by calling this function in realtime, you can effectively "animate" the pin.
                */
                void setPin( const Ogre::Vector3& pin ) const { NewtonUpVectorSetPin( m_joint, &pin.x ); }
 
                Ogre::Vector3 getPin() const;
        };
 
 
 
        namespace PrebuiltCustomJoints
        {
 
 
                class _OgreNewtExport Custom2DJoint : public OgreNewt::OgCustomJoint
                {
                public:
                        Custom2DJoint( const OgreNewt::Body* body, const Ogre::Vector3& pin );
 
                        ~Custom2DJoint() {}
 
                        virtual void submitConstraint( Ogre::Real timeStep, int threadIndex );
 
                        Ogre::Radian getAngle() const { return mAngle; }
 
                        void setLimits( Ogre::Degree min, Ogre::Degree max ) { mMin = min, mMax = max; }
 
                        void setLimitsOn( bool onoff ) { mLimitsOn = onoff; }
 
                        bool getLimitsOn() const { return mLimitsOn; }
 
                        void addAccel( Ogre::Real accel ) { mAccel = accel; }
 
                        void resetAngle() { mAngle = Ogre::Radian(0.0f); }
 
                        Ogre::Vector3 getPin() { return mPin; }
 
                private:
                        Ogre::Vector3 mPin;
                        Ogre::Quaternion mLocalOrient0, mLocalOrient1;
                        Ogre::Vector3 mLocalPos0, mLocalPos1;
 
                        Ogre::Radian mAngle;
 
                        Ogre::Radian mMin;
                        Ogre::Radian mMax;
 
                        bool mLimitsOn;
 
                        Ogre::Real mAccel;
                };
 
 
                class _OgreNewtExport CustomRigidJoint : public OgreNewt::OgCustomJoint
                {
                public:
                        CustomRigidJoint( OgreNewt::Body* child, OgreNewt::Body* parent, Ogre::Vector3 dir, Ogre::Vector3 pos);
                        ~CustomRigidJoint();
 
                        virtual void submitConstraint( Ogre::Real timeStep, int threadIndex );
 
                private:
                        Ogre::Vector3 mLocalPos0;
                        Ogre::Vector3 mLocalPos1;
 
                        Ogre::Quaternion mLocalOrient0;
                        Ogre::Quaternion mLocalOrient1;
                };
 
 
                /* // not tested yet
                class _OgreNewtExport CustomDryRollingFriction : public OgreNewt::OgCustomJoint
                {
                public:
                CustomDryRollingFriction( OgreNewt::Body* child, Ogre::Real radius, Ogre::Real rollingFrictionCoefficient );
                ~CustomDryRollingFriction();
 
                virtual void submitConstraint( Ogre::Real timestep, int threadIndex );
 
                private:
                Ogre::Real mFrictionCoefficient;
                Ogre::Real mFrictionTorque;
                OgreNewt::Body* mChild;
                };
                */
 
        }   // end NAMESPACE PrebuiltCustomJoints
 
#endif
 
 
 
        class _OgreNewtExport KinematicController : public Joint
        {
 
                public:
 
 
                KinematicController(const OgreNewt::Body* child, const Ogre::Vector3& pos);
 
                ~KinematicController();
 
 
                void setPickingMode (int mode);
 
 
                void setMaxLinearFriction(Ogre::Real accel); 
 
 
                void setMaxAngularFriction(Ogre::Real alpha); 
 
 
                void setTargetPosit (const Ogre::Vector3& position);
 
 
                void setTargetRotation (const Ogre::Quaternion& rotation); 
 
 
                void setTargetMatrix (const Ogre::Vector3& position, const Ogre::Quaternion& rotation); 
 
 
                void getTargetMatrix (Ogre::Vector3& position, Ogre::Quaternion& rotation) const;
 
        };
 
}   // end NAMESPACE OgreNewt
 
#endif
// _INCLUDE_OGRENEWT_BASICJOINTS