Layers.hpp

#pragma once
#ifdef StevEngine_PHYSICS
#include <unordered_map>
 
#include "Jolt.h"
#include <Jolt/Physics/Collision/BroadPhase/BroadPhaseLayer.h>
 
 
namespace StevEngine::Physics {
    typedef JPH::ObjectLayer LayerID;
 
    namespace BroadPhaseLayers
    {
        static constexpr JPH::BroadPhaseLayer NON_MOVING(0);
        static constexpr JPH::BroadPhaseLayer MOVING(1);
    };

    class Layer {
        friend class LayerManager;
 
        public:
            const bool isStatic;                            
            const LayerID id;                             
            const JPH::BroadPhaseLayer BroadPhaseLayer;      

            Layer(const Layer& copy);
 
        private:
            Layer(LayerID id, bool isStatic = false);
    };

    class LayerManager {
        public:
            enum DefaultLayers {
                STATIC = (LayerID)0,
                DEFAULT = (LayerID)1,
            };
 
            LayerManager();

            LayerID CreateLayer(bool isStatic = true);

            const Layer& GetLayer(LayerID id);
 
        private:
            std::unordered_map<LayerID, Layer> layers;
 
            LayerID currentId;  
    };
 
    // Jolt management

    class BPLayerInterfaceImpl final : public JPH::BroadPhaseLayerInterface {
        public:
            BPLayerInterfaceImpl();

            virtual unsigned int GetNumBroadPhaseLayers() const override;

            virtual JPH::BroadPhaseLayer GetBroadPhaseLayer(JPH::ObjectLayer inLayer) const override;
    };

    class ObjectVsBroadPhaseLayerFilterImpl : public JPH::ObjectVsBroadPhaseLayerFilter
    {
        public:
            virtual bool ShouldCollide(JPH::ObjectLayer inLayer1, JPH::BroadPhaseLayer inLayer2) const override;
    };

    class ObjectLayerPairFilterImpl : public JPH::ObjectLayerPairFilter
    {
        public:
            virtual bool ShouldCollide(JPH::ObjectLayer inObject1, JPH::ObjectLayer inObject2) const override;
    };
}
 
template<> struct std::hash<StevEngine::Physics::Layer> {
    std::size_t operator()(const StevEngine::Physics::Layer& k) const {
        return std::hash<StevEngine::Physics::LayerID>()(k.id);
    }
};
#endif