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 m_xpos;

        Type m_ypos;

        Type m_width;

        Type m_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
        : m_xpos {0}
        , m_ypos {0}
        , m_width {0}
        , m_height {0}
    {
    }
 
    template<meta::is_arithmetic Type>
    inline Rect<Type>::Rect(const Type x, const Type y, const Type width, const Type height) noexcept
        : m_xpos {x}
        , m_ypos {y}
        , m_width {width}
        , m_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 > m_xpos) && (x < (m_xpos + m_width)) && (y > m_ypos) && (y < (m_ypos + m_height)));
    }
 
    template<meta::is_arithmetic Type>
    inline bool Rect<Type>::contains(const Rect<Type>& b) const noexcept
    {
        return m_xpos <= b.m_xpos && b.get_right() <= get_right() && m_ypos <= b.m_ypos && 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(m_xpos, b.m_xpos, b.m_xpos + b.m_width) || value_in_range(b.m_xpos, m_xpos, m_xpos + m_width);
        const auto y = value_in_range(m_ypos, b.m_ypos, b.m_ypos + b.m_height) || value_in_range(b.m_ypos, m_ypos, m_ypos + m_height);
 
        return x && y;
    }
 
    template<meta::is_arithmetic Type>
    inline bool Rect<Type>::intersects(const Rect<Type>& b) const noexcept
    {
        return !(m_xpos >= b.get_right() || get_right() <= b.m_xpos || m_ypos >= b.get_bottom() || get_bottom() <= b.m_ypos);
    }
 
    template<meta::is_arithmetic Type>
    inline void Rect<Type>::set_top_left(const glm::vec<2, Type, glm::defaultp>& pos) noexcept
    {
        m_xpos = pos.x;
        m_ypos = pos.y;
    }
 
    template<meta::is_arithmetic Type>
    inline Type Rect<Type>::get_right() const noexcept
    {
        return m_xpos + m_width;
    }
 
    template<meta::is_arithmetic Type>
    inline Type Rect<Type>::get_bottom() const noexcept
    {
        return m_ypos + m_height;
    }
 
    template<meta::is_arithmetic Type>
    inline glm::vec<2, Type, glm::defaultp> Rect<Type>::get_top_left() const noexcept
    {
        return {m_xpos, m_ypos};
    }
 
    template<meta::is_arithmetic Type>
    inline glm::vec<2, Type, glm::defaultp> Rect<Type>::get_center() const noexcept
    {
        return {(m_xpos + m_width) / 2.0, (m_ypos + m_height) / 2.0};
    }
 
    template<meta::is_arithmetic Type>
    inline glm::vec<2, Type, glm::defaultp> Rect<Type>::get_size() const noexcept
    {
        return {m_width, m_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