RigidBodyConstraint.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
#ifndef ATOMS_UNREAL
#include <Atoms/Globals.h>
#include <AtomsCore/AtomsMath.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <limits>
 
namespace physx
{
    class PxJoint;
}
 
namespace Atoms
{
    class ATOMS_EXPORT RigidBodyConstraintAttributes
    {
    public:
 
        struct Type
        {
            enum Enum
            {
                kFixed = 0,
                kDistance,
                kSpherical,
                kRevolute,
                kPrismatic,
                kD6
            };
        };
 
        struct D6Drive
        {
            enum Enum
            {
                kX = 0, 
                kY = 1, 
                kZ = 2, 
                kSWING = 3, 
                kTWIST = 4, 
                kSLERP = 5, 
                kCOUNT = 6
            };
        };
 
        struct D6Axis
        {
            enum Enum
            {
                kX = 0, 
                kY = 1, 
                kZ = 2, 
                kTWIST = 3, 
                kSWING1 = 4,    
                kSWING2 = 5,    
                kCOUNT = 6
            };
        };
 
        struct D6Motion
        {
            enum Enum
            {
                kLOCKED,    
                kLIMITED,   
                kFREE       
            };
        };
 
        class Drive
        {
        public:
            Drive():
                stiffness(0.0f),
                damping(0.0f),
                restitution(0.0f),
                bounceThreshold(0.5f),
                forceLimit(std::numeric_limits<float>::max()),
                isAcceleration(false),
                enable(false)
            {}
            float stiffness;
            float damping;
            float restitution;
            float bounceThreshold;
            float forceLimit;
            bool isAcceleration;
            bool enable;
        };
 
        RigidBodyConstraintAttributes();
 
        ~RigidBodyConstraintAttributes();
 
    public:
 
        bool serialise(std::string& outStream) const;
 
        bool deserialise(const std::string& inStream);
 
        bool serialise(AtomsCore::MapMetadata* outStream) const;
 
        bool deserialise(const AtomsCore::MapMetadata* inStream);
 
    public:
 
        static const size_t version;
 
    public:
 
        std::string name;
 
        short constraintType;
 
        // Flags
        bool enableCollision;
        bool driveLimitsAreForces;
        bool improveSlerp;
        bool disablePreprocessing;
        bool enableExtendedLimits;
 
        //Projection
        bool enableProjection;
        float projectionLinearTollerance;
        float projectionAngularTollerance;
 
        // limit spring
        bool enableSpring;
        float stiffness;
        float damping;
        float restitution;
        float bounceThreshold;
 
        // limits
        bool enableLimit;
        AtomsCore::Vector3f limit;
 
        // breakable
        bool breakable;
        AtomsCore::Vector2f breakForce;
 
        // Distant joint
        bool enableMinDistance;
        float minDistance;
        bool enableMaxDistance;
        float maxDistance;
        float tollerance;
 
        // Revolute
        bool enableDrive;
        bool enableFreeSpin;
        float driveVelocity;
        float driveForceLimit;
        float driveGearRatio;
 
        // D6
        short linearMotionX;
        short linearMotionY;
        short linearMotionZ;
 
        short angularMotionX;
        short angularMotionY;
        short angularMotionZ;
 
        bool enableDistanceLimit;
        bool enableTwistLimit;
        bool enableSwingLimit;
        bool enablePyramidLimit;
        AtomsCore::Vector2f distanceLimit;
        AtomsCore::Vector3f twistLimit;
        AtomsCore::Vector3f swingLimit;
        AtomsCore::Vector3f pyramidYSwingLimit;
        AtomsCore::Vector3f pyramidZSwingLimit;
 
        bool enableLinearXLimit;
        bool enableLinearYLimit;
        bool enableLinearZLimit;
        AtomsCore::Vector3f linearXlimit;
        AtomsCore::Vector3f linearYlimit;
        AtomsCore::Vector3f linearZlimit;
 
        bool enableXLimitSpring;
        bool enableYLimitSpring;
        bool enableZLimitSpring;
        float xLimitStiffnessSpring;
        float xLimitDampingSpring;
        float xLimitRestitutionSpring;
        float xLimitBounceThresholdSpring;
        float yLimitStiffnessSpring;
        float yLimitDampingSpring;
        float yLimitRestitutionSpring;
        float yLimitBounceThresholdSpring;
        float zLimitStiffnessSpring;
        float zLimitDampingSpring;
        float zLimitRestitutionSpring;
        float zLimitBounceThresholdSpring;
 
        Drive drive[6];
        AtomsCore::Vector3f driveLinearVelocity;
        AtomsCore::Vector3f driveAngularVelocity;
        AtomsCore::Matrixf drivePose;
    };
 
    class ATOMS_EXPORT RigidBodyConstraint
    {
    public:
        RigidBodyConstraint();
 
        ~RigidBodyConstraint();
 
        void setDrivePose();
 
        void updateDrivePose(const AtomsCore::Matrixf& matrix);
 
        void updateDrive(short driveType, RigidBodyConstraintAttributes::Drive& driveAttributes);
 
        void force(AtomsCore::Vector3f& linear, AtomsCore::Vector3f& angular) const;
 
        void setBreakForce(float force, float torque);
 
        AtomsCore::Matrixf localPose(size_t actor) const;
 
        AtomsCore::Matrixf relativePose() const;
 
        void breakConstraint();
 
        void remove();
 
        void release();
 
    public:
 
        physx::PxJoint* joint;
 
        AtomsCore::Matrixf drivePose;
 
        bool drivePoseUpdated;
 
        bool removeFlag;
    };
}
#endif