aabb.h

#ifndef OE_SCENE_AABB_H
#define OE_SCENE_AABB_H
 
#include <glm/vec3.hpp>
#include <glm/matrix.hpp>
 
namespace oe::scene
{
    class AABB
    {
        public:
            AABB() = default;
 
            explicit AABB(const glm::vec3& extents):
                min(-0.5f*glm::abs(extents)),
                max(0.5f*glm::abs(extents))
            {}
 
            AABB(const glm::vec3& mini, const glm::vec3& maxi):
                min(glm::min(mini, maxi)),
                max(glm::max(mini, maxi))
            {}
 
            glm::vec3 getCenter() const noexcept
            {
                return 0.5f * (min + max);
            }
 
            void setBounds(const glm::vec3& mini, const glm::vec3& maxi) noexcept
            {
                min = mini;
                max = maxi;
            }
 
            void extendToPoint(const glm::vec3& point) noexcept
            {
                if (point.x < min.x) min.x = point.x;
                if (point.y < min.y) min.y = point.y;
                if (point.z < min.z) min.z = point.z;
 
                if (point.x > max.x) max.x = point.x;
                if (point.y > max.y) max.y = point.y;
                if (point.z > max.z) max.z = point.z;
            }
 
            AABB transform(const glm::mat4& model) const noexcept
            {
                glm::vec3 center = getCenter();
                glm::vec3 demi_extents = max - center;
 
                glm::vec3 transformed_center = glm::vec3(model * glm::vec4(center,1.0));
 
                glm::mat3 abs_mat = glm::mat3(glm::abs(glm::vec3(model[0])), glm::abs(glm::vec3(model[1])), glm::abs(glm::vec3(model[2])));
                glm::vec3 transformed_extents = abs_mat * demi_extents;
 
                glm::vec3 min = transformed_center - transformed_extents;
                glm::vec3 max = transformed_center + transformed_extents;
 
                return AABB(min, max);
            }
 
            void extendToAABB(const oe::scene::AABB& aabb) noexcept
            {
                extendToPoint(aabb.min);
                extendToPoint(aabb.max);
            }
 
            AABB& operator+=(const AABB& aabb) noexcept
            {
                extendToAABB(aabb);
 
                return *this;
            }
 
            void scale(const glm::vec3& scale) noexcept
            {
                glm::vec3 center = getCenter();
                glm::vec3 demi_extents = max - center;
 
                min = center - demi_extents * scale;
                max = center + demi_extents * scale;
            }
 
            glm::vec3 getExtents() const noexcept
            {
                return max - min;
            }
 
            float getVolume() const noexcept
            {
                const glm::vec3 size = getExtents();
                return std::abs(size.x) * std::abs(size.y) * std::abs(size.z);
            }
 
            bool isEmpty() const noexcept
            {
                return max == min;
            };
 
            bool hasCollision(const AABB& box) const noexcept
            {
                return (min.x <= box.max.x && min.x >= box.min.x) &&
                    (min.y <= box.max.y && min.y >= box.min.y) &&
                    (min.z <= box.max.z && min.z >= box.min.z)
                ;
            }
 
            bool hasCollision(const glm::vec3& center, const float& radius) const noexcept
            {
                // Get box closest point to sphere center by clamping
                float x = glm::max(min.x, glm::min(center.x, max.x));
                float y = glm::max(min.y, glm::min(center.y, max.y));
                float z = glm::max(min.z, glm::min(center.z, max.z));
 
                float distance = (x - center.x) * (x - center.x)
                    + (y - center.y) * (y - center.y)
                    + (z - center.z) * (z - center.z);
 
                return distance < radius * radius;
            }
 
            bool contains(const glm::vec3& point) const noexcept
            {
                return (point.x <= max.x && point.x >= min.x) &&
                    (point.y <= max.y && point.y >= min.y) &&
                    (point.z <= max.z && point.z >= min.z)
                ;
            }
 
            bool contains(const AABB& box) const noexcept
            {
                return contains(box.min) && contains(box.max);
            }
 
            glm::vec3 min = glm::vec3(0.0);
 
            glm::vec3 max = glm::vec3(0.0);
    };
 
    inline AABB operator+(const AABB& op1, const AABB& op2) noexcept
    {
        AABB result(op1);
        result.extendToAABB(op2);
 
        return result;
    }
}
 
#endif