True Axis Physics SDK 1.2.0.1 Beta Documentation
www.trueaxis.com

---

PhysicsJoint.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------
// File Name: PhysicsJoint.h
// Description:
//
// Copyright (C) 2004 - 2006 True Axis Pty Ltd, Australia. 
// All Rights Reserved.
//
// History:
//      Created File.
//---------------------------------------------------------------------------------

#ifndef TA_PHYSICSJOINT_H
#define TA_PHYSICSJOINT_H

#ifndef TA_MATRIX_H
#include "../Common/Matrix.h"
#endif // TA_MATRIX_H

#ifndef TA_FLAGS_H
#include "../Common/Flags.h"
#endif // TA_FLAGS_H

#ifndef TA_EULERANLGE_H
#include "../Common/EulerAngles.h"
#endif // TA_EULERANLGE_H

#ifndef TA_PHYSICSCOMMON_H
#include "PhysicsCommon.h"
#endif // TA_PHYSICSCOMMON_H

TA_OBFUSCATION_SKIP_PASS_2

namespace TA
{

class DynamicObject;

class TAPHYSICS_CLASS PhysicsJoint
{
public:
    TA_OBFUSCATION_RESERVED_ON
    //pl.BeginExportClass(PhysicsJoint)
    enum Type
    {
        TYPE_BALL_AND_SOCKET = 0,
        TYPE_LIMITED_BALL_AND_SOCKET = 1,
        TYPE_SQUARE_SOCKET = 2,
        TYPE_EULER_ANGLE_CONSTRAINT = 31,
        TYPE_LINEAR_SLIDER = 4,
        TYPE_ROTATION_CONSTRAINT = 5,
        TYPE_VECTOR_CONSTRAINT = 6,
    };
    PhysicsJoint();
    ~PhysicsJoint();


    void InitialiseEulerConstraint(
        const Vec3& v3Position,
        const Mat33& m33JointOrientation,
        const EulerAngles& minAngles,
        const EulerAngles& maxAngles);
    void InitialiseHinge(
        const Vec3& v3Position,
        const Vec3& v3HingeAxis,
        float fMinAngle,
        float fMaxAngle);
    void InitialiseBallAndSocket(
        const Vec3& v3Position,
        const Vec3& v3LimitCenterDirection,
        float fMaxAngle);
    void InitialiseLimitedBallAndSocket(
        const Vec3& v3Position,
        const Mat33& m33JointOrientation,
        float fMaxAngleY,
        float fMaxAngleXZ);
    void InitialiseSquareSocket(
        const Vec3& v3Position,
        const Mat33& m33JointOrientation,
        float fMinX,
        float fMaxX,
        float fMinY,
        float fMaxY,
        float fMinZ,
        float fMaxZ);
    void InitialiseSlider(
        const Vec3& v3PosOnA,
        const Vec3& v3StartPosOnB,
        const Vec3& v3EndPosPosOnB);
    void InitialiseRotationConstraint(
        const Mat33& m33JointOrientation,
        const EulerAngles& minAngles,
        const EulerAngles& maxAngles);
    void InitialiseVectorConstraint(
        const Vec3& v3LimitCenterDirection,
        float fMaxAngle);



    void InitialiseEulerConstraintEx(
        const Vec3& v3LocalPosOnA,
        const Vec3& v3LocalPosOnB,
        const Mat33& m33JointOrientation,
        const Mat33& m33DefaultRotationA,
        const Mat33& m33DefaultRotationB,
        const EulerAngles& minAngles,
        const EulerAngles& maxAngles);
    void InitialiseHingeEx(
        const Vec3& v3LocalPosOnA,
        const Vec3& v3LocalPosOnB,
        const Vec3& v3HingeAxis, 
        const Vec3& v3HingeCenterDirection, 
        const Mat33& m33DefaultRotationA,
        const Mat33& m33DefaultRotationB,
        float fMinAngle,
        float fMaxAngle);
    void InitialiseBallAndSocketEx(
        const Vec3& v3LocalPosOnA,
        const Vec3& v3LocalPosOnB,
        const Vec3& v3LocalLimitCenterDirectionOnA, 
        const Vec3& v3LocalLimitCenterDirectionOnB,
        float fMaxAngle);
    void InitialiseLimitedBallAndSocketEx(
        const Vec3& v3LocalPosOnA,
        const Vec3& v3LocalPosOnB,
        const Mat33& m33JointOrientation,
        const Mat33& m33DefaultRotationA,
        const Mat33& m33DefaultRotationB,
        float fMaxAngleY,
        float fMaxAngleXZ);
    void InitialiseSquareSocketEx(
        const Vec3& v3LocalPosOnA,
        const Vec3& v3LocalPosOnB,
        const Mat33& m33JointOrientation,
        const Mat33& m33DefaultRotationA,
        const Mat33& m33DefaultRotationB,
        float fMinX,
        float fMaxX,
        float fMinY,
        float fMaxY,
        float fMinZ,
        float fMaxZ);   
    void InitialiseSliderEx(
        const Vec3& v3LocalPosOnA,
        const Vec3& v3LocalStartPosOnB,
        const Vec3& v3LocalEndPosPosOnB);
    void InitialiseRotationConstraintEx(
        const Mat33& m33JointOrientation,
        const Mat33& m33DefaultRotationA,
        const Mat33& m33DefaultRotationB,
        const EulerAngles& minAngles,
        const EulerAngles& maxAngles);
    void InitialiseVectorConstraintEx(
        const Vec3& v3LocalLimitCenterDirectionOnA,
        const Vec3& v3LocalLimitCenterDirectionOnB,
        float fMaxAngle);



    //---------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------
    void Reset(
        const Vec3& v3PosOnA,
        const Vec3& v3PosOnB,
        const Mat33& defaultRotationB,
        const EulerAngles& minAngles,
        const EulerAngles& maxAngles);
    
    //---------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------
    void ResetAsTypeHinge(
        const Vec3& v3PosOnA,
        const Vec3& v3PosOnB,
        const Vec3& v3LocalHingeAxis, 
        const Vec3& v3LocalHingeNormal, 
        float fMinAngle,
        float fMaxAngle);
    
    void ResetAsTypeSocket(
        const Vec3& v3PosOnA,
        const Vec3& v3PosOnB,
        const Vec3& v3LimitNormalOnA,   
        const Vec3& v3LimitNormalOnB,
        float fMaxAngle);

    //---------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------
    void ResetAsTypeLimitedSocket(
        const Vec3& v3PosOnA,
        const Vec3& v3PosOnB,
        const Mat33& defaultRotationB,
        float fMaxAngleY,
        float fMaxAngleXZ);

    //---------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------
    void ResetAsTypeSquareSocket(
        const Vec3& v3PosOnA,
        const Vec3& v3PosOnB,
        const Mat33& defaultRotationB,
        float fMinX,
        float fMaxX,
        float fMinY,
        float fMaxY,
        float fMinZ,
        float fMaxZ);
    
    //---------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------
    void ResetAsTypeSlider(
        const Vec3& v3PosOnA,
        const Vec3& v3StartPosOnB,
        const Vec3& v3EndPosPosOnB);
    
    //---------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------
    void ResetAsTypeRotationConstraint(
        const Mat33& defaultRotationB,
        const EulerAngles& minAngles,
        const EulerAngles& maxAngles);
    
    //---------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------
    void ResetAsTypeVectorConstraint(
        const Vec3& v3LimitNormalOnA,
        const Vec3& v3LimitNormalOnB,
        float fMaxAngle);



    bool IsObjectASolid() const;
    void SetObjectASolid(bool bValue);
    bool IsObjectBSolid() const;
    void SetObjectBSolid(bool bValue);
    bool IsCollisionDisabledBetweenObjects() const;
    void SetCollisionDisabledBetweenObjects(bool bValue);


    float GetBreakForce() const;
    void SetBreakForce(float fBreakForce);
    void SetBreakable(bool bValue);
    bool IsBreakable() const;
    void SetBroken(bool bValue);
    bool IsBroken() const;


    void* GetUserData() const;
    void SetUserData(void* pUserData);


    Type GetType() const;
    DynamicObject* GetObjectA();
    DynamicObject* GetObjectB();
    const Vec3& GetPosOnObjectA() const;
    const Vec3& GetPosOnObjectB() const;
    const Vec3& GetLimitNormalOnObjectA() const;
    const Vec3& GetLimitNormalOnObjectB() const;
    const Vec3& GetCenterDirectionOnObjectA() const;
    const Vec3& GetCenterDirectionOnObjectB() const;
    float GetMaxAngle() const;
    const Mat33& GetJointOrientationA();
    const Mat33& GetJointOrientationB();
    const EulerAngles& GetMinAngles();
    const EulerAngles& GetMaxAngles();
    const Vec3& GetSliderPos0() const;
    const Vec3& GetSliderPos1() const;

    //pl.EndExportClass(PhysicsJoint)
    TA_OBFUSCATION_RESERVED_OFF
#ifdef TA_PHYSICS_INTERNAL
    bool IsMarked() const { return GetFlag(m_nFlags, FLAG_MARKED); }
    void SetMarked(bool bValue) { SetFlag(m_nFlags, FLAG_MARKED, bValue); }
    bool IsPropagateForward() const { return GetFlag(m_nFlags, FLAG_PROPAGATE_FORWARD); }
    void SetPropagateForward(bool bValue) { SetFlag(m_nFlags, FLAG_PROPAGATE_FORWARD, bValue); }
    const EulerAngles& GetPreviousOrientation() const { return m_previousOrientation; }
    void SetPreviousOrientation(const EulerAngles& orientation) { m_previousOrientation = orientation; }
    float CircularSquareConstrainVector(Vec3& v3ConstrainedVector, Vec3* pv3Normal);
    void Initialise(DynamicObject* pDynamicObjectA, DynamicObject* pDynamicObjectB);
    void Finalise();
    void SetLastUpdateFrame(u32 nValue) { m_nLastUpdateFrame = nValue; }
    u32 GetLastUpdateFrame() const { return m_nLastUpdateFrame; }
#endif // TA_PHYSICS_INTERNAL

private:
    enum 
    {
        FLAG_OBJECTA_SOLID = 0x1,
        FLAG_OBJECTB_SOLID = 0x2,
        FLAG_DISABLE_COLLISION_BETWEEN_OBJECTS = 0x4,
        FLAG_MARKED = 0x8,
        FLAG_PROPAGATE_FORWARD = 0x10,
        FLAG_BREAKABLE = 0x20,
        FLAG_BROKEN = 0x40,
    };
    PhysicsJoint(PhysicsJoint&); // disable copy constructor

    Vec3 m_v3PosOnA;
    Vec3 m_v3PosOnB;
    Vec3 m_v3LimitNormalOnA;
    Vec3 m_v3LimitNormalOnB;
    Mat33 m_m33JointOrientationA;
    Mat33 m_m33JointOrientationB;
    EulerAngles m_minAngles;
    EulerAngles m_maxAngles;
    EulerAngles m_previousOrientation;
    u16 m_eType;
    u16 m_nFlags;
    DynamicObject* m_pDynamicObjectA;
    DynamicObject* m_pDynamicObjectB;
    float m_fMaxAngle;
    float m_fBreakForce;
    int m_nLastUpdateFrame;
    void* m_pUserData;
};

}

#include "PhysicsJoint.inl"

#endif // TA_PHYSICSJOINT_H

---

© Copyright 2004-2006 TRUE AXIS PTY LTD Australia. All rights reserved.