AtomsPhysx.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 <Atoms/Physx/RigidBody.h>
#include <Atoms/Physx/RigidBodyConstraint.h>
#include <string>
#include <unordered_map>
#include <mutex>
 
namespace physx
{
    class PxFoundation;
    class PxPhysics;
    class PxDefaultCpuDispatcher;
    class PxScene;
    class PxPvd;
    class PxRigidActor;
    class PxCooking;
    class PxAggregate;
    class PxMaterial;
    class PxHeightField;
    class PxCudaContextManager;
}
 
namespace Atoms
{
    class ContactFilterCallback;
    class ContactModifyCallback;
    class AtomsCCDContactModification;
 
    class ATOMS_EXPORT AtomsPhysx
    {
    public:
 
        struct LazyAggregateData
        {
            std::unordered_map<int, std::vector<int>> aggregates;
            std::unordered_map<int, bool> aggregateEnableCollisions;
        };
 
        struct LazyRigidBodyData
        {
            size_t id;
            RigidBodyAttributes attributes;
            AtomsUtils::Mesh* mesh;
        };
 
        struct LazyRigidBodyConstraintData
        {
            RigidBodyConstraintAttributes attributes;
            Atoms::RigidBody* firstRb;
            AtomsCore::Matrixf fMatrix;
            Atoms::RigidBody* secondRb;
            AtomsCore::Matrixf sMatrix;
            std::string name;
            bool lateCompute;
        };
 
        enum SolverType
        {
            kPGS = 0,
            kTGS
        };
 
        AtomsPhysx();
 
        ~AtomsPhysx();
 
        void init();
 
        void release();
 
        void initScene();
 
        void releaseScene();
 
        void updateKinematics(float stepSize);
 
        void updateDynamicPool(float stepSize);
 
        void updateKinematicAgents(float stepSize);
 
        void updatedForces(float stepSize);
 
        void clearForces();
 
        void clearFeedbacks();
 
        void storeTransforms();
 
        void fetchStates();
 
        void storeStates();
 
        void updateConstraints();
 
        void createLazyData();
 
        void createDynamicConstraintData();
 
        void updateForceCollisionThreshold();
 
        void stepPhysics();
 
        //Attributes Pvd
 
        const std::string& pvdHost() const;
 
        void setPvdHost(const std::string& host);
 
        int pvdPort() const;
 
        void setPvdPort(int value);
 
        unsigned int pvdTimeout() const;
 
        void setPvdTimeout(unsigned int value);
 
 
        // Sim attributes
 
        double fps() const;
 
        void setFps(double value);
 
        unsigned int subSamples() const;
 
        void setSubSamples(unsigned int value);
 
        double scale() const;
 
        void setScale(double value);
 
        const AtomsCore::Vector3& gravity() const;
 
        void setGravity(const AtomsCore::Vector3& value);
 
        void enablePvd(bool value);
 
        bool isPvdEnabled() const;
 
        bool isInitialized() const;
 
        unsigned int threadsNumber() const;
 
        void setThreadsNumber(unsigned int value);
 
        void setFrictionOffsetThreshold(double value);
        
        void setCcdMaxSeparation(double value);
        
        void setSolverOffsetSlop(double value);
        
        void setBounceThresholdVelocity(double value);
 
        short solverType() const;
 
        void setSolverType(short value);
 
        void setKinematicKinematicFilter(bool value);
 
        void setStaticKinematicFilter(bool value);
 
        bool useGpu() const;
 
        void setUseGpu(bool value);
 
        bool enableStabilization() const;
 
        void setEnableStabilization(bool value);
 
        bool enableEnhancedDeterminism() const;
 
        void setEnableEnhancedDeterminism(bool value);
 
        bool enableFrictionEveryIteration() const;
 
        void setEnableFrictionEveryIteration(bool value);
 
        bool enablePCM() const;
 
        void setEnablePCM(bool value);
 
        bool enableAdaptiveForce() const;
 
        void setEnableAdaptiveForce(bool value);
 
        bool enableCCD() const;
 
        void setEnableCCD(bool value);
 
        double elapsedTime() const;
 
        // Rbs
        RigidBody* addRigidBody(
            const std::string& name,
            const RigidBodyAttributes& attributes, 
            AtomsUtils::Mesh* mesh = nullptr,
            bool lazyCreation = false);
 
        void rigidBodyPose(const std::string& name, AtomsCore::Vector3f& pos, AtomsCore::Quaternionf& rot) const;
 
        void rigidBodyPose(size_t id, AtomsCore::Vector3f& pos, AtomsCore::Quaternionf& rot) const;
 
        std::unordered_map<size_t, RigidBody>& rigidBodies();
 
        const RigidBody* rigidBody(size_t id) const;
 
        const std::unordered_map<size_t, RigidBody>& rigidBodies() const;
 
        const std::unordered_map<size_t, std::string>& rigidBodyNames() const;
 
        const std::map<std::string, size_t>& rigidBodyNameIds() const;
 
        std::map<std::string, RigidBodyConstraint>& constraints();
 
        const std::map<std::string, RigidBodyConstraint>& constraints() const;
 
        const std::map<std::pair<size_t, size_t>, std::string>& constraintNames() const;
 
        physx::PxRigidActor* createPhysicObject(size_t id, const RigidBodyAttributes& attributes, physx::PxGeometry* geo, const physx::PxTransform* shapeOffset);
 
        physx::PxRigidActor* createRigidBody(size_t id, const RigidBodyAttributes& attributes, AtomsUtils::Mesh* mesh=nullptr);
 
        void setupDynamicAttributes(physx::PxRigidDynamic* rigid, const RigidBodyAttributes& attributes) const;
 
        void setupKinematicAttributes(physx::PxRigidDynamic* rigid, const RigidBodyAttributes& attributes) const;
 
        // Constraints
 
        RigidBodyConstraint* addRigidBodyConstraint(
            const std::string& name,
            const RigidBodyConstraintAttributes& attributes,
            int first,
            int second,
            const AtomsCore::Matrixf& matrix);
 
        RigidBodyConstraint* addRigidBodyConstraint(
            const std::string& name,
            const RigidBodyConstraintAttributes& attributes,
            Atoms::RigidBody* firstRb,
            const AtomsCore::Matrixf& fMatrix,
            Atoms::RigidBody* secondRb,
            const AtomsCore::Matrixf& sMatrix,
            bool lazyCreation = false);
 
        RigidBodyConstraint* addRigidBodyDynamicConstraint(
            const std::string& name,
            const RigidBodyConstraintAttributes& attributes,
            Atoms::RigidBody* firstRb,
            const AtomsCore::Matrixf& fMatrix,
            Atoms::RigidBody* secondRb,
            const AtomsCore::Matrixf& sMatrix);
 
        physx::PxJoint* createRigidBodyConstraint(
            const RigidBodyConstraintAttributes& attributes,
            physx::PxRigidActor* first,
            physx::PxTransform& firstMatrix,
            physx::PxRigidActor* second,
            physx::PxTransform& secondMatrix);
 
        void addAggregates(
            const std::unordered_map<int, std::vector<int>> &aggregates, 
            const std::unordered_map<int, bool> &aggregateEnableCollisions,
            size_t id = 0,
            bool lazyCreation = false);
 
        void removeRigidBody(size_t id);
 
        void removeConstraint(const std::string& name);
 
    private:
#ifndef VS2012
        AtomsPhysx(const AtomsPhysx&) = delete;
        AtomsPhysx& operator=(const AtomsPhysx&) = delete;
#else
        AtomsPhysx(const AtomsPhysx&);
        AtomsPhysx& operator=(const AtomsPhysx&);
#endif
    private:
 
        std::unordered_map<size_t, RigidBody> m_rbs;
 
        std::unordered_map<size_t, std::string> m_rbNames;
 
        std::map<std::string, size_t> m_rbNameIds;
 
        std::map<std::string, RigidBodyConstraint> m_constraints;
 
        std::map<std::pair<size_t, size_t>, std::string> m_constraintNames;
 
        std::vector<physx::PxAggregate *> m_aggregates;
 
        std::vector<physx::PxHeightField*> m_heigthFields;
 
        physx::PxFoundation* m_foundation;
 
        physx::PxPhysics* m_physics;
 
        physx::PxCooking* m_cooking;
#ifndef ATOMS_UNREAL
        physx::PxCudaContextManager* m_cudaContextManager;
#endif
        physx::PxDefaultCpuDispatcher*  m_dispatcher;
 
        physx::PxScene* m_scene;
 
        physx::PxPvd* m_pvd;
 
        std::string m_pvdHost;
 
        int m_pvdPort;
 
        unsigned int m_pvdTimeout;
 
        double m_fps;
 
        unsigned int m_subSamples;
 
        double m_scale;
 
        AtomsCore::Vector3 m_gravity;
 
        int m_threadsNumber;
 
        unsigned int m_maxThreads;
 
        double m_frictionOffsetThreshold;
 
        double m_ccdMaxSeparation;
 
        double m_solverOffsetSlop;
 
        double m_bounceThresholdVelocity;
 
        short m_solverType;
 
        bool m_isInitialized;
 
        bool m_activePvd;
 
        bool m_filterKinematicKinematicCollision;
 
        bool m_filterStaticKinematicCollision;
 
        std::atomic<size_t> m_freeId;
 
        AtomsUPtr<ContactFilterCallback> m_contactFilterCallback;
 
        AtomsUPtr<ContactModifyCallback> m_contactModifyCallback;
 
        AtomsUPtr<AtomsCCDContactModification> m_ccdContactModifyCallback;
 
        mutable std::mutex m_mutex;
 
        std::map<size_t, LazyAggregateData> m_lazyAggregates;
 
        std::map<std::string, LazyRigidBodyData> m_lazyRigidBodies;
 
        std::map<std::string, LazyRigidBodyConstraintData> m_lazyConstraints;
 
        std::map<size_t, physx::PxMaterial*> m_lazyMaterials;
 
        bool m_useGpu;
 
        bool m_enableStabilization;
 
        bool m_enableEnhancedDeterminism;
 
        bool m_enableFrictionEveryIteration;
 
        bool m_enablePCM;
 
        bool m_enableAdaptiveForce;
 
        bool m_enableCCD;
 
        double m_elapsedTime;
    };
}
#endif