Joint.h

Go to the documentation of this file.

/*************************************************************************
*                                                                       *
* Open Physics Abstraction Layer                                        *
* Copyright (C) 2004-2005                                               *
* Alan Fischer  alan.fischer@gmail.com                                  *
* Andres Reinot  andres@reinot.com                                      *
* Tyler Streeter  tylerstreeter@gmail.com                               *
* All rights reserved.                                                  *
* Web: opal.sourceforge.net                                             *
*                                                                       *
* This library is free software; you can redistribute it and/or         *
* modify it under the terms of EITHER:                                  *
*   (1) The GNU Lesser General Public License as published by the Free  *
*       Software Foundation; either version 2.1 of the License, or (at  *
*       your option) any later version. The text of the GNU Lesser      *
*       General Public License is included with this library in the     *
*       file license-LGPL.txt.                                          *
*   (2) The BSD-style license that is included with this library in     *
*       the file license-BSD.txt.                                       *
*                                                                       *
* This library 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 files    *
* license-LGPL.txt and license-BSD.txt for more details.                *
*                                                                       *
*************************************************************************/

#ifndef OPAL_JOINT_H
#define OPAL_JOINT_H

#include "Defines.h"
#include "JointBreakEventHandler.h"
#include "JointData.h"

namespace opal
{
    class Joint
    {
        public:
            Joint();

            virtual void OPAL_CALL init( const JointData& data );

            virtual const JointData& OPAL_CALL getData();

            virtual void OPAL_CALL setName( const std::string& name );

            virtual const std::string& OPAL_CALL getName() const;

            virtual void OPAL_CALL setContactsEnabled( bool e );

            virtual bool OPAL_CALL areContactsEnabled() const;

            virtual JointType OPAL_CALL getType() const;

            virtual void OPAL_CALL setBreakParams( JointBreakMode mode,
                                                   real breakThresh, real accumThresh = 0 );

            virtual JointBreakMode OPAL_CALL getBreakingMode() const;

            virtual real OPAL_CALL getBreakThresh() const;

            virtual real OPAL_CALL getAccumulatedDamage() const;


            virtual real OPAL_CALL getAccumulatedThresh() const;

            virtual bool OPAL_CALL isBroken() const;

            virtual void OPAL_CALL repairAccumDamage();

            virtual void OPAL_CALL setJointBreakEventHandler(
                JointBreakEventHandler* eventHandler );

            virtual JointBreakEventHandler* OPAL_CALL
            getJointBreakEventHandler() const;

            virtual void OPAL_CALL setLimitsEnabled( int axisNum, bool e );

            virtual bool OPAL_CALL areLimitsEnabled( int axisNum );

            virtual void OPAL_CALL setLimitRange( int axisNum, real low,
                                                  real high );

            virtual real OPAL_CALL getLowLimit( int axisNum ) const;

            virtual real OPAL_CALL getHighLimit( int axisNum ) const;

            virtual void OPAL_CALL setLimitHardness( int axisNum, real h );

            virtual real OPAL_CALL getLimitHardness( int axisNum ) const;

            virtual void OPAL_CALL setLimitBounciness( int axisNum, real b );

            virtual real OPAL_CALL getLimitBounciness( int axisNum ) const;

            virtual real OPAL_CALL getAngle( int axisNum ) const = 0;

            virtual real OPAL_CALL getDistance( int axisNum ) const = 0;

            virtual real OPAL_CALL getVelocity( int axisNum ) const = 0;

            virtual void OPAL_CALL addForce( int axisNum, real magnitude,
                                             real duration, bool singleStep = false );

            virtual void OPAL_CALL addTorque( int axisNum, real magnitude,
                                              real duration, bool singleStep = false );

            virtual void OPAL_CALL wakeSolids();

            virtual Solid* OPAL_CALL getSolid0() const;

            virtual Solid* OPAL_CALL getSolid1() const;

            virtual JointAxis OPAL_CALL getAxis( int axisNum ) const = 0;

            virtual Point3r OPAL_CALL getAnchor() const = 0;

            virtual int OPAL_CALL getNumAxes() const;

            virtual bool OPAL_CALL isEnabled() const;

            virtual void OPAL_CALL setEnabled( bool e );

            virtual bool OPAL_CALL isRotational( int axisNum ) const;

            virtual void OPAL_CALL setUserData( void* data );

            virtual void* OPAL_CALL getUserData();

            virtual void OPAL_CALL internal_update() = 0;

            virtual void OPAL_CALL internal_setDesiredVel( int axisNum,
                    real value ) = 0;

            virtual void OPAL_CALL internal_setMaxTorque( int axisNum,
                    real value ) = 0;

            //virtual bool OPAL_CALL internal_isBroken();

            virtual bool OPAL_CALL internal_dependsOnSolid( Solid* s );

            virtual void OPAL_CALL internal_destroy();

        protected:
            virtual ~Joint();

            void setSolids( Solid* s0, Solid* s1 );

            virtual void setAnchor( const Point3r& anchor );

            virtual void setAxis( int axisNum, const JointAxis& axis );

            void updateDamage( real currentStress );

            JointData mData;

            JointBreakEventHandler* mJointBreakEventHandler;

            void* mUserData;

            bool mInitCalled;

            int mNumAxes;

            // This data stores which axes are rotational, as opposed to
            // translational, degrees of freedom.
            bool mAxisRotational[ 3 ];

        private:

    };
}

#endif

---