include/fsdk/Types/Rect.h

#pragma once

#include <fsdk/Types/Vector2.h>

namespace fsdk {
    template <typename Type>
    struct BaseRect {
        typedef Type ElementType;

        Type x;      
        Type y;      
        Type width;  
        Type height; 

        BaseRect() noexcept
            : x(0)
            , y(0)
            , width(0)
            , height(0) {
        }

        BaseRect(Type x_, Type y_, Type w_, Type h_) noexcept
            : x(x_)
            , y(y_)
            , width(w_)
            , height(h_) {
        }

        BaseRect(const Vector2<Type>& topLeft, const Vector2<Type>& bottomRight) noexcept {
            set(topLeft, bottomRight);
        }

        BaseRect(const BaseRect& other) noexcept {
            *this = other;
        }

        template <typename OtherType>
        BaseRect(const BaseRect<OtherType>& other) noexcept {
            *this = other;
        }

        void setLeft(Type l) noexcept {
            const auto r = right();
            x = l;
            setRight(r);
        }

        void setTop(Type t) noexcept {
            const auto b = bottom();
            y = t;
            setBottom(b);
        }

        void setRight(Type r) noexcept {
            width = r - x;
        }

        void setBottom(Type b) noexcept {
            height = b - y;
        }

        static BaseRect coords(Type x0, Type y0, Type x1, Type y1) noexcept {
            return BaseRect(x0, y0, x1 - x0, y1 - y0);
        }

        static float intersectionOverFirstRect(const BaseRect& rect1, const BaseRect& rect2) {
            const float inter = (rect1 & rect2).getArea();
            return inter / rect1.getArea();
        }

        static float intersectionOverUnion(const BaseRect& rect1, const BaseRect& rect2) {
            const float inter = (rect1 & rect2).getArea();
            return inter / (rect1.getArea() + rect2.getArea() - inter);
        }

        static float intersectionOverForeground(const BaseRect& rect1, const BaseRect& rect2) {
            if(rect1.getArea() < rect2.getArea()) {
                return intersectionOverFirstRect(rect1, rect2);
            }
            return intersectionOverFirstRect(rect2, rect1);
        }

        template <typename OtherType>
        BaseRect& operator=(const BaseRect<OtherType>& other) noexcept {
            if(reinterpret_cast<const void*>(this) != reinterpret_cast<const void*>(&other)) {
                x = static_cast<Type>(other.x);
                y = static_cast<Type>(other.y);
                width = static_cast<Type>(other.width);
                height = static_cast<Type>(other.height);
            }
            return *this;
        }

        template <typename OtherType>
        bool operator==(const BaseRect<OtherType>& other) const noexcept {
            return x == other.x && y == other.y && width == other.width && height == other.height;
        }

        template <typename OtherType>
        bool operator!=(const BaseRect<OtherType>& other) const noexcept {
            return !(*this == other);
        }

        BaseRect operator&(const BaseRect& other) const noexcept {
            BaseRect newRect;
            newRect.x = x > other.x ? x : other.x;
            newRect.y = y > other.y ? y : other.y;
            newRect.width = (x + width < other.x + other.width ? x + width : other.x + other.width) - newRect.x;
            newRect.height =
                (y + height < other.y + other.height ? y + height : other.y + other.height) - newRect.y;
            if(newRect.width <= 0 || newRect.height <= 0)
                newRect = BaseRect();
            return newRect;
        }

        BaseRect operator&=(const BaseRect& other) noexcept {
            if(this != &other)
                *this = *this & other;

            return *this;
        }

        BaseRect operator|(const BaseRect& other) const noexcept {
            BaseRect newRect;
            newRect.x = x < other.x ? x : other.x;
            newRect.y = y < other.y ? y : other.y;
            newRect.width = (x + width > other.x + other.width ? x + width : other.x + other.width) - newRect.x;
            newRect.height =
                (y + height > other.y + other.height ? y + height : other.y + other.height) - newRect.y;

            return newRect;
        }

        BaseRect operator|=(const BaseRect& other) noexcept {
            if(this != &other)
                *this = *this & other;

            return *this;
        }

        BaseRect operator*(float scaleFactor) const noexcept {
            BaseRect newRect;
            newRect.x = static_cast<Type>(x * scaleFactor);
            newRect.y = static_cast<Type>(y * scaleFactor);
            newRect.width = static_cast<Type>(width * scaleFactor);
            newRect.height = static_cast<Type>(height * scaleFactor);

            return newRect;
        }

        BaseRect operator/(float scaleFactor) const noexcept {
            BaseRect newRect;
            newRect.x = static_cast<Type>(x / scaleFactor);
            newRect.y = static_cast<Type>(y / scaleFactor);
            newRect.width = static_cast<Type>(width / scaleFactor);
            newRect.height = static_cast<Type>(height / scaleFactor);

            return newRect;
        }

        BaseRect operator+(Vector2<typename BaseRect::ElementType> vec) {
            BaseRect newRect = *this;
            newRect.x += vec.x;
            newRect.y += vec.y;

            return newRect;
        }

        BaseRect operator-(Vector2<typename BaseRect::ElementType> vec) {
            BaseRect newRect = *this;
            newRect.x -= vec.x;
            newRect.y -= vec.y;

            return newRect;
        }

        Vector2<Type> size() const noexcept {
            return Vector2<Type>(width, height);
        }

        Vector2<Type> topLeft() const noexcept {
            return Vector2<Type>(x, y);
        }

        Vector2<Type> center() const noexcept {
            return Vector2<Type>(x + width / 2, y + height / 2);
        }

        Vector2<Type> bottomRight() const noexcept {
            return Vector2<Type>(x + width, y + height);
        }

        Type top() const noexcept {
            return y;
        }

        Type bottom() const noexcept {
            return y + height;
        }

        Type left() const noexcept {
            return x;
        }

        Type right() const noexcept {
            return x + width;
        }

        void set(const Vector2<Type>& topLeft, const Vector2<Type>& bottomRight) noexcept {
            x = topLeft.x;
            y = topLeft.y;
            width = bottomRight.x - x;
            height = bottomRight.y - y;
        }

        void adjust(Type dx, Type dy, Type dw, Type dh) noexcept {
            x += dx;
            y += dy;
            width += dw;
            height += dh;
        }

        BaseRect adjusted(Type dx, Type dy, Type dw, Type dh) const noexcept {
            BaseRect rect(*this);
            rect.adjust(dx, dy, dw, dh);
            return rect;
        }

        Type getArea() const noexcept {
            return width * height;
        }

        bool inside(const BaseRect& other) const noexcept {
            return topLeft() >= other.topLeft() && bottomRight() <= other.bottomRight();
        }

        bool isValid() const noexcept {
            return width > 0 && height > 0;
        }
    };

    template <typename Type>
    BaseRect<Type> centerScale(const BaseRect<Type>& in, float scaleFactor) noexcept {
        BaseRect<Type> out;
        out.x = in.x - 0.5 * (scaleFactor - 1) * in.width;
        out.y = in.y - 0.5 * (scaleFactor - 1) * in.height;
        out.width = in.width * scaleFactor;
        out.height = in.height * scaleFactor;
        return out;
    }

    using Rect = BaseRect<int>;
    using FloatRect = BaseRect<float>;
} // namespace fsdk