Rect.hpp

#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Types/Core/Value.hpp>
#include <Infinity/Types/Containers/Array.hpp>
#include <Infinity/Types/Math/Vector2.hpp>
 
namespace Infinity::Types::Math
{
    struct INFINITY_API_PUBLIC Rect
    {
        float l;  
        float r;  
        float t;  
        float b;  
 
        constexpr Rect() : 
            l(0.0f), r(0.0f), t(0.0f), b(0.0f)
        { }
 
        constexpr Rect(const Rect& r) :
            l(r.l), r(r.r), t(r.t), b(r.b)
        { }
 
        constexpr Rect(float l, float r, float t, float b) : 
            l(l), r(r), t(t), b(b)
        { }
 
        constexpr Rect& operator=(const Rect&) = default;
 
        static Rect fromSize(float x, float y, float width, float height);
 
        static constexpr Rect zero()
        {
            return Rect(0.0f, 0.0f, 0.0f, 0.0f);
        }
 
        void set(float in_l, float in_r, float in_t, float in_b);
 
        Vector2 topLeft() const;
 
        Vector2 topRight() const;
 
        Vector2 bottomLeft() const;
 
        Vector2 bottomRight() const;
 
        float width() const;
 
        float height() const;
 
        float area() const;
 
        bool contains(const Vector2& p) const;
 
        Rect translated(const Vector2& offset) const;
 
        Rect scaled(float factor) const;
 
        Vector2 center() const;
 
        Vector2 size() const;
 
        Rect& operator+=(const Rect& rhs);
 
        Rect& operator+=(const Vector2& rhs);
 
        Rect& operator-=(const Rect& rhs);
 
        Rect& operator-=(const Vector2& rhs);
 
        explicit operator bool() const noexcept;
    };
 
    constexpr bool operator==(const Rect& lhs, const Rect& rhs)
    {
        return lhs.l == rhs.l && lhs.r == rhs.r && lhs.t == rhs.t && lhs.b == rhs.b;
    }
 
    constexpr bool operator!=(const Rect& lhs, const Rect& rhs)
    {
        return lhs.l != rhs.l || lhs.r != rhs.r || lhs.t != rhs.t || lhs.b != rhs.b;
    }
 
    constexpr Rect operator-(const Rect& lhs, const Rect& rhs)
    {
        return Rect(lhs.l - rhs.l, lhs.r - rhs.r, lhs.t - rhs.t, lhs.b - rhs.b);
    }
 
    constexpr Rect operator-(const Rect& v)
    {
        return Rect(-v.l, -v.r, -v.t, -v.b);
    }
 
    constexpr Rect operator+(const Rect& lhs, const Rect& rhs)
    {
        return Rect(lhs.l + rhs.l, lhs.r + rhs.r, lhs.t + rhs.t, lhs.b + rhs.b);
    }
 
    inline std::ostream& operator<<(std::ostream& out, const Rect& r)
    {
        out << r.l << " " << r.r << " " << r.t << " " << r.b;
        return out;
    }
 
    inline std::istream& operator>>(std::istream& in, Rect& r)
    {
        in >> r.l >> r.r >> r.t >> r.b;
        return in;
    }
}
 
// Register Rect in the type system
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Rect>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Rect>)