Rect.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_MATH_RECT_HPP_
#define GALAXY_MATH_RECT_HPP_
 
#include <compare>
 
#include <glm/vec2.hpp>
 
#include "galaxy/meta/Concepts.hpp"
 
namespace galaxy
{
    template<meta::is_arithmetic Type>
    class Rect final
    {
    public:
        Rect() noexcept;
 
        Rect(const Type x, const Type y, const Type width, const Type height) noexcept;
 
        ~Rect() noexcept;
 
        [[nodiscard]]
        bool contains(const Type _x, const Type _y) const noexcept;
 
        [[nodiscard]]
        bool contains(const Rect<Type>& b) const noexcept;
 
        [[nodiscard]]
        bool overlaps(const Rect<Type>& b) noexcept;
 
        [[nodiscard]]
        bool intersects(const Rect<Type>& b) const noexcept;
 
        void set_top_left(const glm::vec<2, Type, glm::defaultp>& pos) noexcept;
 
        [[nodiscard]]
        Type get_right() const noexcept;
 
        [[nodiscard]]
        Type get_bottom() const noexcept;
 
        [[nodiscard]]
        glm::vec<2, Type, glm::defaultp> get_top_left() const noexcept;
 
        [[nodiscard]]
        glm::vec<2, Type, glm::defaultp> get_center() const noexcept;
 
        [[nodiscard]]
        glm::vec<2, Type, glm::defaultp> get_size() const noexcept;
 
        [[nodiscard]]
        auto operator<=>(const Rect&) const noexcept = default;
 
    public:
        Type x;
 
        Type y;
 
        Type width;
 
        Type height;
 
    private:
        [[nodiscard]]
        bool value_in_range(const Type value, const Type min, const Type max) noexcept;
    };
 
    typedef Rect<int> iRect;
 
    typedef Rect<float> fRect;
 
    template<meta::is_arithmetic Type>
    inline Rect<Type>::Rect() noexcept
        : x {0}
        , y {0}
        , width {0}
        , height {0}
    {
    }
 
    template<meta::is_arithmetic Type>
    inline Rect<Type>::Rect(const Type x, const Type y, const Type width, const Type height) noexcept
        : x {x}
        , y {y}
        , width {width}
        , height {height}
    {
    }
 
    template<meta::is_arithmetic Type>
    inline Rect<Type>::~Rect() noexcept
    {
    }
 
    template<meta::is_arithmetic Type>
    inline bool Rect<Type>::contains(const Type _x, const Type _y) const noexcept
    {
        // Checks if the rectangle contains the point (x, y) using some basic math.
        return ((_x > x) && (_x < (x + width)) && (_y > y) && (_y < (y + height)));
    }
 
    template<meta::is_arithmetic Type>
    inline bool Rect<Type>::contains(const Rect<Type>& b) const noexcept
    {
        return x <= b.x && b.get_right() <= get_right() && y <= b.y && b.get_bottom() <= get_bottom();
    }
 
    template<meta::is_arithmetic Type>
    inline bool Rect<Type>::overlaps(const Rect<Type>& b) noexcept
    {
        // Check for overlaps using math.
        const auto _x = value_in_range(x, b.x, b.x + b.width) || value_in_range(b.x, x, x + width);
        const auto _y = value_in_range(y, b.y, b.y + b.height) || value_in_range(b.y, y, y + height);
 
        return _x && _y;
    }
 
    template<meta::is_arithmetic Type>
    inline bool Rect<Type>::intersects(const Rect<Type>& b) const noexcept
    {
        return !(x >= b.get_right() || get_right() <= b.x || y >= b.get_bottom() || get_bottom() <= b.y);
    }
 
    template<meta::is_arithmetic Type>
    inline void Rect<Type>::set_top_left(const glm::vec<2, Type, glm::defaultp>& pos) noexcept
    {
        x = pos.x;
        y = pos.y;
    }
 
    template<meta::is_arithmetic Type>
    inline Type Rect<Type>::get_right() const noexcept
    {
        return x + width;
    }
 
    template<meta::is_arithmetic Type>
    inline Type Rect<Type>::get_bottom() const noexcept
    {
        return y + height;
    }
 
    template<meta::is_arithmetic Type>
    inline glm::vec<2, Type, glm::defaultp> Rect<Type>::get_top_left() const noexcept
    {
        return {x, y};
    }
 
    template<meta::is_arithmetic Type>
    inline glm::vec<2, Type, glm::defaultp> Rect<Type>::get_center() const noexcept
    {
        return {(x + width) / 2.0, (y + height) / 2.0};
    }
 
    template<meta::is_arithmetic Type>
    inline glm::vec<2, Type, glm::defaultp> Rect<Type>::get_size() const noexcept
    {
        return {width, height};
    }
 
    template<meta::is_arithmetic Type>
    inline bool Rect<Type>::value_in_range(const Type value, const Type min, const Type max) noexcept
    {
        // Check if a value is between min and max - i.e. in range.
        return (value >= min) && (value <= max);
    }
} // namespace galaxy
 
#endif