PhysicsBodyComponent.hpp

#pragma once
#include "PhysXDefines.h"
#include "Function.hpp"
#include "mathtypes.hpp"
#include "PhysicsCallback.hpp"
#include "Queryable.hpp"
#include <PxScene.h>
#include <PxRigidActor.h>
#include "ComponentWithOwner.hpp"
#include "DataStructures.hpp"
#include "PhysicsCollider.hpp"
 
namespace physx {
    class PxRigidActor;
    struct PxContactPairPoint;
}
 
namespace RavEngine {
    struct Transform;
    // stores contact points
    struct ContactPairPoint {
        vector3 position, normal, impulse;
        decimalType separation;
 
        ContactPairPoint(const physx::PxContactPairPoint& pxcpp);
        
        // default constructor
        ContactPairPoint(){}
    };
 
    class PhysicsBodyComponent : public ComponentWithOwner,
#if !RVE_SERVER
public IDebugRenderable,
#endif
 
public Queryable<PhysicsBodyComponent
#if !RVE_SERVER
,IDebugRenderable
#endif
>
    {
    protected:
        UnorderedSet<std::shared_ptr<PhysicsCallback>> receivers;
        Colony<std::shared_ptr<PhysicsCollider>> colliders;
        void CompleteConstruction();
        friend class PhysicsLinkSystemRead;
        friend class PhysicsLinkSystemWrite;
        mutable bool setPoseNeedsSync = false;
    public:
        using Queryable<PhysicsBodyComponent
#if !RVE_SERVER
        ,IDebugRenderable
#endif
        >::GetQueryTypes;
        
        physx::PxRigidActor* rigidActor = nullptr;
        physx::PxU32 filterGroup = -1;
        physx::PxU32 filterMask = -1;
        
        auto getScene() const{
            return rigidActor->getScene();
        }
        
        PhysicsBodyComponent(Entity owner);
        virtual ~PhysicsBodyComponent();
        
        void Destroy();
        
        struct ColliderHandle{
            decltype(colliders)::iterator id;
        };
        
        template<typename T, typename ... A>
        ColliderHandle EmplaceCollider(A&& ... args){
            auto collider_iter = colliders.emplace(std::make_shared<T>(this,args...));
            
            return ColliderHandle{collider_iter};
        }
        
        template<typename T>
        void DestroyCollider(ColliderHandle handle){
            colliders.erase(handle.id);
        }
 
        void OnDestroyDetatchCollider(RavEngine::PhysicsCollider& collider);
        
        
        void AddReceiver(decltype(receivers)::value_type& obj);
 
        void RemoveReceiver(decltype(receivers)::value_type& obj);
        
        void RemoveReceiver(PhysicsCallback*);
 
        std::pair<vector3,quaternion> getDynamicsWorldPose() const;
 
        void setDynamicsWorldPose(const vector3& worldpos, const quaternion& worldrot) const;
 
        void SetGravityEnabled(bool);
 
        bool GetGravityEnabled() const;
 
        void SetSleepNotificationsEnabled(bool);
 
        bool GetSleepNotificationsEnabled() const;
 
        void SetSimulationEnabled(bool);
 
        bool GetSimulationEnabled() const;
 
        void OnColliderEnter(PhysicsBodyComponent& other, const ContactPairPoint* contactPoints, size_t numContactPoints);
 
        void OnColliderPersist(PhysicsBodyComponent& other, const ContactPairPoint* contactPoints, size_t numContactPoints);
 
        void OnColliderExit(PhysicsBodyComponent& other, const ContactPairPoint* contactPoints, size_t numContactPoints);
        
        void OnTriggerEnter(PhysicsBodyComponent& other);
        
        void OnTriggerExit(PhysicsBodyComponent& other);
 
        inline bool GetWantsContactData() const {
            return wantsContactData;
        }
        inline void SetWantsContactData(bool state) {
            wantsContactData = state;
        }
        
        void DebugDraw(RavEngine::DebugDrawer& dbg, const RavEngine::Transform& tr) const {
#if !RVE_SERVER
            LockRead([&] {
                for (const auto& collider : colliders) {
                    collider->DebugDraw(dbg, debug_color, tr);
                }
            });
#endif
        }
    protected:
        bool wantsContactData = false;
 
        template<typename T>
        inline void LockWrite(const T& func){
            auto scene = rigidActor->getScene();
            if (scene){
                scene->lockWrite();
                func();
                scene->unlockWrite();
            }
            else{
                func();
            }
        }
        
        template<typename T>
        inline void LockRead(const T& func) const{
            auto scene = rigidActor->getScene();
            if(scene){
                scene->lockRead();
                func();
                scene->unlockRead();
            }
            else{
                func();
            }
        }
    private:
        void setDynamicsWorldPoseNoLock(const vector3& worldpos, const quaternion& worldrot) const;
    };
 
    class RigidBodyDynamicComponent : public PhysicsBodyComponent, public QueryableDelta<PhysicsBodyComponent,RigidBodyDynamicComponent> {
    public:
        RigidBodyDynamicComponent(Entity owner);
        RigidBodyDynamicComponent(Entity owner, physx::PxU32 fg, physx::PxU32 fm) : RigidBodyDynamicComponent(owner) {
            this->filterGroup = fg; this->filterMask = fm;
        }
        virtual ~RigidBodyDynamicComponent();
        using QueryableDelta<PhysicsBodyComponent,RigidBodyDynamicComponent>::GetQueryTypes;
        vector3 GetLinearVelocity() const;
 
        vector3 GetAngularVelocity() const;
 
        void SetLinearVelocity(const vector3&, bool);
 
        void SetAngularVelocity(const vector3&, bool);
        
        void SetKinematicTarget(const vector3& targetPos, const quaternion& targetRot);
        std::pair<vector3, quaternion> GetKinematicTarget() const;
 
        void Wake();
 
        void Sleep();
 
        bool IsSleeping() const;
        
        enum AxisLock{
            Linear_X = (1 << 0),
            Linear_Y = (1 << 1),
            Linear_Z = (1 << 2),
            Angular_X = (1 << 3),
            Angular_Y = (1 << 4),
            Angular_Z = (1 << 5)
        };
        
        void SetAxisLock(uint16_t LockFlags);
        
        uint16_t GetAxisLock() const;
        
        void SetMass(decimalType mass);
        
        decimalType GetMass() const;
        
        decimalType GetMassInverse() const;
        
        void AddForce(const vector3& force);
        
        void AddTorque(const vector3& torque);
        
        void ClearAllForces();
        
        void ClearAllTorques();
 
        // call underlying
        void Destroy() {
            PhysicsBodyComponent::Destroy();
        }
    };
 
    struct RigidBodyStaticComponent : public PhysicsBodyComponent, public QueryableDelta<PhysicsBodyComponent,RigidBodyStaticComponent> {
        using QueryableDelta<PhysicsBodyComponent,RigidBodyStaticComponent>::GetQueryTypes;
        RigidBodyStaticComponent(Entity owner);
        virtual ~RigidBodyStaticComponent();
        RigidBodyStaticComponent(Entity owner, physx::PxU32 fg, physx::PxU32 fm) : RigidBodyStaticComponent(owner) {
            this->filterGroup = fg; this->filterMask = fm;
        }
 
        // call underlying
        void Destroy() {
            PhysicsBodyComponent::Destroy();
        }
    };
}