RigidBody.h

#pragma once
#ifndef ATOMS_UNREAL
// ===========================================================================
// 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.
// ===========================================================================
 
#include <Atoms/Globals.h>
#include <AtomsCore/AtomsMath.h>
#include <AtomsUtils/Mesh.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <string>
#include <atomic>
#ifdef VS2012
#include <tbb/atomic.h>
#endif
 
#define GETSET_RIGID_BODY_ATTRIBUTE( SET_NAME, GET_NAME, TYPE, ATTRIBUTE ) \
inline TYPE GET_NAME() const { return ATTRIBUTE; } \
void SET_NAME(TYPE value) { ATTRIBUTE = value; } \
 
 
namespace physx
{
    class PxPhysics;
    class PxScene;
    class PxGeometry;
    class PxRigidDynamic;
    class PxRigidActor;
    class PxTransform;
    class PxCooking;
}
 
namespace Atoms
{
    class ATOMS_EXPORT RigidBodyAttributes
    {
    public:
 
        enum State
        {
            kStatic = 0,
            kDynamic = 1,
            kKinematic = 2
        };
 
        enum Type
        {
            kPlane = 0,
            kSphere,
            kBox,
            kCapsule,
            kConvexMesh,
            kTriangleMesh,
            kHeightField
        };
 
        enum Axis
        {
            kX = 0,
            kY,
            kZ
        };
 
        enum RotationOrder
        {
            kXYZ = 0,
            kYZX,
            kZXY,
            kXZY,
            kYXZ,
            kZYX,
        };
 
        RigidBodyAttributes();
 
        ~RigidBodyAttributes();
 
    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:
        AtomsCore::Vector3f dimension;
        AtomsCore::Vector3f linearVelocity;
        AtomsCore::Vector3f angularVelocity;
        AtomsCore::Vector3f massSpaceInertiaTensor;
        AtomsCore::Matrixf transform;
        AtomsCore::Matrixf shapeOffset;
        AtomsCore::Matrixf cMassLocalPose;
        AtomsCore::Vector3f rotatePivot;
        AtomsCore::Vector3f scalePivot;
        AtomsCore::Vector3f scalePivotTranslate;
        AtomsCore::Vector3f rotatePivotTranslate;
        AtomsCore::Vector3f scale;
        AtomsCore::Vector3f position;
        AtomsCore::Quaternionf rotation;
        AtomsCore::Vector2f stuckOnCollisionBreakForce;
        AtomsCore::Vector2f solverIteratorCount;
        float collisionForceThreshold;
        float maxAngularVelocity;
        float angularDamping;
        float linearDamping;
        float density;
        float sleepThreshold;
        float stabilizationThreshold;
        float wakeCounter;
        float mass;
        float staticFriction;
        float dynamicFriction;
        float restitution;
        float restOffset;
        float contactOffset;
        float contactReportThreshold;
        float stuckOnCollisionImpulse;
        float heightFieldScale;
        int aggregate;
        int collisionPool;
        int dynamicOnCollisionPool;
        int stuckOnCollisionPool;
        int heightFieldRows;
        int heightFieldColumns;
        short state;
        short type;
        short axis;
        short rotationOrder;
        bool active;
        bool useMass;
        bool dynamicOnCollision;
        bool disableCollisionEvent;
        bool stuckOnCollision;
        bool aggregateSelfCollision;
        bool storeImpactData;
    };
 
    class ATOMS_EXPORT RigidBody
    {
    public:
 
        enum ShapeType
        {
            kSphere = 0,
            kPlane,
            kCapsule,
            kBox,
            kConvexMesh,
            kTriangleMesh,
            kHeightfield,
            kGeometryCount, 
            kInvalid = -1       
        };
 
        struct ShapeData
        {
            AtomsCore::Matrixf transform;
            short shapeType;
            AtomsCore::Vector3f size;
            std::vector<AtomsCore::Vector3f> points;
            std::vector<AtomsCore::Vector3f> normals;
            std::vector<unsigned int> indices;
        };
 
        struct ImpactData
        {
            AtomsCore::Vector3f position;
            AtomsCore::Vector3f force;
            int asImpulse;
            double time;
            size_t obj;
        };
 
        enum DynamicOnCollisionType
        {
            kSingle = 0,
            kAggregate,
            kChildren
        };
 
        RigidBody();
 
        ~RigidBody();
 
        void setKinematicTarget(const AtomsCore::Matrixf& mtx);
 
        void storeTransform();
 
        void setKinematic(bool value);
 
        void pose(AtomsCore::Vector3f& pos, AtomsCore::Quaternionf& rot) const;
 
        void getGeometry(std::vector<AtomsCore::Vector3f>& points,
            std::vector<AtomsCore::Vector3f>& normals,
            std::vector<unsigned int>& indices) const;
 
        void getShape(ShapeData& data) const;
 
        inline bool isStatic() const;
 
        inline bool isKinematic() const;
 
        inline bool isDynamic() const;
 
        void addForce(const AtomsCore::Vector3f& force);
 
        void addImpulse(const AtomsCore::Vector3f& impulse);
 
        void addForceAtPosition(const AtomsCore::Vector3f& force, const AtomsCore::Vector3f& position);
 
        void addImpulseAtPosition(const AtomsCore::Vector3f& impulse, const AtomsCore::Vector3f& position);
 
        void addTorque(const AtomsCore::Vector3f& force);
 
        void addTorqueImpulse(const AtomsCore::Vector3f& impulse);
 
        void applyForces(float scale);
 
        void clearForces();
 
        void clearFeedbacks();
 
        AtomsCore::Matrixf centerOfMass();
 
        float friction();
 
        float bounce();
 
        void release();
 
    public:
 
        std::vector<ImpactData> impacts;
 
        std::vector<ImpactData> feedback;
 
        physx::PxRigidActor* actor;
 
        short state;
 
        short rotationOrder;
 
        AtomsCore::Quaternionf targetRot;
 
        AtomsCore::Quaternionf currentRot;
 
        AtomsCore::Vector3f targetPos;
 
        AtomsCore::Vector3f currentPos;
 
        AtomsCore::Vector3f rotatePivot;
 
        AtomsCore::Vector3f scale;
 
        AtomsCore::Vector3f scalePivot;
 
        AtomsCore::Vector3f scalePivotTranslate;
 
        AtomsCore::Vector3f rotatePivotTranslate;
 
        AtomsCore::Matrixf initTransform;
 
        AtomsCore::Vector3f initPosition;
 
        AtomsCore::Quaternionf initRotation;
#ifndef VS2012
        std::atomic<bool> dynamicSwitch;
 
        std::atomic<int> dynamicPool;
#else
        tbb::atomic<bool> dynamicSwitch;
 
        tbb::atomic<int> dynamicPool;
#endif
        AtomsCore::Vector3f force;
        
        AtomsCore::Vector3f impulse;
        
        AtomsCore::Vector3f torque;
 
        AtomsCore::Vector3f torqueImpulse;
 
        AtomsCore::Vector3f velocity;
 
        AtomsCore::Vector3f angularVelocity;
 
        AtomsCore::Vector3f acceleration;
 
        float mass;
 
        size_t id;
 
        short dynamicOnCollisionType;
 
        int aggregate;
 
        float stuckOnCollisionImpulse;
 
        AtomsCore::Vector2f stuckOnCollisionBreakForce;
 
        float collisionForceThreshold;
 
        int dynamicOnCollisionPool;
 
        int stuckOnCollisionPool;
 
        int collisionPool;
 
        bool dynamicOnCollision;
        
        bool isRoot;
 
        bool stuckOnCollision;
 
        bool aggregateSelfCollision;
 
        bool isJoint;
 
        bool storeImpactData;
    };
 
}
 
#include "RigidBody.impl.h"
#endif