D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Framework/Physics/spPhysicsJoint.hpp

Go to the documentation of this file.

/*
 * Physics joint header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_PHYSICS_JOINT_H__
#define __SP_PHYSICS_JOINT_H__


#include "Base/spStandard.hpp"

#ifdef SP_COMPILE_WITH_PHYSICS


#include "Base/spDimensionVector3D.hpp"
#include "Base/spDimensionMatrix4.hpp"


namespace sp
{
namespace physics
{


class RigidBody;
class PhysicsBaseObject;

enum EPhysicsJoints
{
    JOINT_BALL,         
    JOINT_HINGE,        
    JOINT_SLIDER,       
    JOINT_CORKSCREW,    
    JOINT_UNIVERSAL,    
};

struct SPhysicsJointConstruct
{
    SPhysicsJointConstruct()
    {
    }
    SPhysicsJointConstruct(
        const dim::vector3df &Pnt) :
        PointA(Pnt),
        PointB(Pnt)
    {
    }
    SPhysicsJointConstruct(
        const dim::vector3df &Pnt, const dim::vector3df &Dir) :
        PointA      (Pnt),
        PointB      (Pnt),
        DirectionA  (Dir),
        DirectionB  (Dir)
    {
        DirectionA.normalize();
        DirectionB.normalize();
    }
    SPhysicsJointConstruct(
        const dim::vector3df &PntA, const dim::vector3df &PntB,
        const dim::vector3df &DirA, const dim::vector3df &DirB) :
        PointA      (PntA),
        PointB      (PntB),
        DirectionA  (DirA),
        DirectionB  (DirB)
    {
        DirectionA.normalize();
        DirectionB.normalize();
    }
    SPhysicsJointConstruct(
        const dim::matrix4f TransA, const dim::matrix4f TransB) :
        TransformA(TransA), TransformB(TransB)
    {
    }
    ~SPhysicsJointConstruct()
    {
    }
    
    /* Members */
    dim::vector3df PointA, PointB;
    dim::vector3df DirectionA, DirectionB;
    dim::matrix4f TransformA, TransformB;
};


class SP_EXPORT PhysicsJoint
{
    
    public:
        
        virtual ~PhysicsJoint();
        
        /* === Functions === */
        
        virtual void setPosition(const dim::vector3df &Position) = 0;
        virtual dim::vector3df getPosition() const = 0;
        
        virtual void translate(const dim::vector3df &Direction);
        
        // Enables or disables the limitations. By default disabled.
        virtual void setLimit(bool Enable) = 0;
        virtual bool getLimit() const = 0;
        
        virtual void setLimit(f32 Min, f32 Max, bool Enable = true) = 0;
        virtual void getLimit(f32 &Min, f32 &Max) const = 0;
        
        virtual void setMotor(bool Enable, f32 MotorPower = 100.0f) = 0;
        virtual bool getMotor() const = 0;
        
        virtual void runMotor(f32 Velocity) = 0;
        
        virtual f32 getLinearValue() const = 0;
        
        /* === Inline functions === */
        
        inline EPhysicsJoints getType() const
        {
            return Type_;
        }
        
        inline PhysicsBaseObject* getFirstObject() const
        {
            return ObjectA_;
        }
        inline PhysicsBaseObject* getSecondObject() const
        {
            return ObjectB_;
        }
        
    protected:
        
        PhysicsJoint(
            const EPhysicsJoints Type, PhysicsBaseObject* ObjectA, PhysicsBaseObject* ObjectB
        );
        
        /* === Members === */
        
        EPhysicsJoints Type_;
        
        PhysicsBaseObject* ObjectA_;
        PhysicsBaseObject* ObjectB_;
        
};


} // /namespace physics

} // /namespace sp


#endif

#endif



// ================================================================================