AABBCollider.h

#pragma once
 
#include <array>
#include <glm/glm.hpp>
#include <memory>
#include <vector>
 
namespace engine {
 
    class World;
    struct AABB;
 
    struct CollisionInfo {
        static constexpr int AXIS_X_MASK = 1;
        static constexpr int AXIS_Y_MASK = 2;
        static constexpr int AXIS_Z_MASK = 4;
 
        glm::vec3 correction{0.f};
 
        glm::vec3 t{1.f};
 
        std::array<std::vector<glm::vec3>, 3> hitPositions;
 
        unsigned int axis : 3 = 0b000;
 
        bool grounded : 1 = false;
 
        float stepHeight = 0.0f;
    };
 
    class AABBCollider {
      public:
        AABBCollider(std::shared_ptr<AABB> aabb, float stepHeight = 0.0f);
 
        void setWorld(std::shared_ptr<World> world);
 
        void setAABB(std::shared_ptr<AABB> aabb);
 
        CollisionInfo collide(glm::vec3& moveStep, const glm::vec3& position, float dt);
 
      protected:
        static constexpr glm::vec3 s_checkBox{1.5f};
        static constexpr float s_epsGap = std::numeric_limits<float>::epsilon() * 64.0f;
 
        std::shared_ptr<World> m_world = nullptr;
        std::shared_ptr<AABB> m_aabb;
        float m_stepHeight;
        float m_height;
 
        std::vector<AABB> m_aabbCache;
        glm::ivec3 m_lastPosition;
        // TODO remove or implement. Should be indicating the direction/velocity for which the AABB cache is generated.
        glm::vec3 m_cacheDirection;
 
        float m_stepUpCooldown = 0.0f;
 
 
        struct SweptResult {
            float time;
            int axis;
            const AABB* bb;
        };
 
        void updateAABBCache(const glm::vec3& velocity, const glm::vec3& position);
        SweptResult swept(const glm::vec3& velocity, const AABB& other) const;
        float swept1D(int axis, float velocity, const AABB& other);
 
        float tryStepUp(const glm::vec3& horizontalMove, const SweptResult& bestRes);
    };
 
}  // namespace engine