Rect.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Matrix.hpp"
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine::inline Math {
 
    template<typename T> using TPoint2 = TVector2<T>;
 
    using Point2 = TPoint2<double>;
 
    template<typename T> struct TSize2 {
        T width = 0.0;
 
        T height = 0.0;
 
        TSize2() = default;
        TSize2(T width, T height) : width(width), height(height) {}
 
        explicit TSize2(const TVector2<T>& vec) : width(vec.x), height(vec.y) {}
        explicit operator TVector2<T>() const { return Vector2(width, height); }
 
        [[nodiscard]] TSize2 transform(const TMatrix3<T>& matrix) const;
 
        friend bool operator==(const TSize2& lhs, const TSize2& rhs) { return lhs.width == rhs.width && lhs.height == rhs.height; }
        friend bool operator!=(const TSize2& lhs, const TSize2& rhs) { return !(rhs == lhs); }
 
        [[nodiscard]] friend inline TSize2 operator+(const TSize2& lhs, const TSize2& rhs) { return {lhs.width + rhs.width, lhs.height + rhs.height}; }
        [[nodiscard]] friend inline TSize2 operator+(const TSize2& lhs, T rhs) { return {lhs.width + rhs, lhs.height + rhs}; }
 
        [[nodiscard]] friend inline TSize2 operator-(const TSize2& lhs, const TSize2& rhs) { return {lhs.width - rhs.width, lhs.height - rhs.height}; }
        [[nodiscard]] friend inline TSize2 operator-(const TSize2& lhs, T rhs) { return {lhs.width - rhs, lhs.height - rhs}; }
 
        [[nodiscard]] friend inline TSize2 operator*(const TSize2& lhs, T rhs) { return {lhs.width * rhs, lhs.height * rhs}; }
        [[nodiscard]] friend inline TSize2 operator/(const TSize2& lhs, T rhs) { return {lhs.width / rhs, lhs.height / rhs}; }
    };
 
    extern template struct TSize2<double>;
 
    using Size2 = TSize2<double>;
 
    template<typename T> struct TRect2Edge {
        T bottom = 0.0;
 
        T left = 0.0;
 
        T right = 0.0;
 
        T top = 0.0;
    };
 
    extern template struct TRect2Edge<double>;
 
    using Rect2Edge = TRect2Edge<double>;
 
    template<typename T> struct TRect2 {
        TPoint2<T> origin = TPoint2<T>(0.0, 0.0);
        TSize2<T> size = TSize2<T>(0.0, 0.0);
 
        TRect2() = default;
        TRect2(const TPoint2<T>& origin, const TSize2<T>& size) : origin(origin), size(size) {}
        TRect2(const TPoint2<T>& center, const TRect2Edge<T>& edge);
        TRect2(T x, T y, T width, T height) : origin(x, y), size(width, height) {}
 
        static TRect2 fromCenterAndSize(const TPoint2<T>& center, const TSize2<T>& size) { return TRect2(center - TPoint2<T>(size / T(2)), size); }
 
        static TRect2 fromCenterAndSize(const TPoint2<T>& center, T size) { return TRect2(center - size / T(2), TSize2<T>(size, size)); }
 
    public:
        [[nodiscard]] bool contains(const TPoint2<T>& point) const;
 
        [[nodiscard]] bool contains(const TRect2<T>& rect) const;
 
        [[nodiscard]] bool overlaps(const TRect2& other) const;
 
        void encapsulate(const TRect2& other);
 
        void clip(const TRect2& clipRect);
 
        [[nodiscard]] TRect2 intersection(const TRect2& other) const;
        [[nodiscard]] bool fullyContained(const TRect2& other) const;
 
        [[nodiscard]] TRect2 inset(const TRect2Edge<T>& insets) const;
 
        [[nodiscard]] TRect2 inset(T value) const { return inset(TRect2Edge<T>{value, value, value, value}); }
 
        [[nodiscard]] TRect2 outset(const TRect2Edge<T>& insets) const;
 
        [[nodiscard]] TRect2 outset(T value) const { return outset(TRect2Edge<T>{value, value, value, value}); }
 
        [[nodiscard]] static Vector<TRect2> getIntersectionGroups(const Vector<TRect2>& rects);
 
        void transform(const TMatrix4<T>& matrix);
 
        void transform(const TMatrix3<T>& matrix);
 
        [[nodiscard]] TPoint2<T> getCenter() const;
 
        [[nodiscard]] TSize2<T> getHalfSize() const;
 
        [[nodiscard]] TPoint2<T> getTopLeft() const { return origin; }
 
        void setTopLeft(const TPoint2<T>& topLeft) { origin = topLeft; }
 
        [[nodiscard]] TPoint2<T> getTopRight() const { return origin + TPoint2<T>(size.width, 0); }
 
        void setTopRight(const TPoint2<T>& topRight) {
            size.width = topRight.x - origin.x;
            origin.y = topRight.y;
        }
 
        [[nodiscard]] TPoint2<T> getBottomLeft() const { return origin + TPoint2<T>(0, size.height); }
 
        void setBottomLeft(const TPoint2<T>& bottomLeft) {
            origin.x = bottomLeft.x;
            size.height = bottomLeft.y - origin.y;
        }
 
        [[nodiscard]] TPoint2<T> getBottomRight() const { return origin + TPoint2<T>(size.width, size.height); }
 
        void setBottomRight(const TPoint2<T>& bottomRight) {
            size.width = bottomRight.x - origin.x;
            size.height = bottomRight.y - origin.y;
        }
 
        friend bool operator==(const TRect2& lhs, const TRect2& rhs) { return lhs.origin == rhs.origin && lhs.size == rhs.size; }
        friend bool operator!=(const TRect2& lhs, const TRect2& rhs) { return !(rhs == lhs); }
 
        template<std::size_t I> [[nodiscard]] friend T& get(TRect2& rect) noexcept {
            static_assert(I <= 3);
            if constexpr(I == 0) {
                return rect.origin.x;
            } else if constexpr(I == 1) {
                return rect.origin.y;
            } else if constexpr(I == 2) {
                return rect.size.width;
            } else if constexpr(I == 3) {
                return rect.size.height;
            }
        }
 
        template<std::size_t I> [[nodiscard]] friend const T& get(const TRect2& rect) noexcept {
            static_assert(I <= 3);
            if constexpr(I == 0) {
                return rect.origin.x;
            } else if constexpr(I == 1) {
                return rect.origin.y;
            } else if constexpr(I == 2) {
                return rect.size.width;
            } else if constexpr(I == 3) {
                return rect.size.height;
            }
        }
    };
 
    extern template struct TRect2<double>;
 
    template<typename T> [[nodiscard]] constexpr inline T MinX(const TRect2<T>& rect) { return rect.origin.x; }
    template<typename T> [[nodiscard]] constexpr inline T MinY(const TRect2<T>& rect) { return rect.origin.y; }
    template<typename T> [[nodiscard]] constexpr inline T Width(const TRect2<T>& rect) { return rect.size.width; }
    template<typename T> [[nodiscard]] constexpr inline T Height(const TRect2<T>& rect) { return rect.size.height; }
    template<typename T> [[nodiscard]] constexpr inline T MaxX(const TRect2<T>& rect) { return rect.origin.x + rect.size.width; }
    template<typename T> [[nodiscard]] constexpr inline T MaxY(const TRect2<T>& rect) { return rect.origin.y + rect.size.height; }
    template<typename T> [[nodiscard]] constexpr inline T MidX(const TRect2<T>& rect) { return rect.origin.x + rect.size.width / 2; }
    template<typename T> [[nodiscard]] constexpr inline T MidY(const TRect2<T>& rect) { return rect.origin.y + rect.size.height / 2; }
 
    using Rect2 = TRect2<double>;
 
    template<typename T> struct TAffineTransform {
        TMatrix3<T> raw = glm::identity<TMatrix3<T>>();
 
    public:
        TAffineTransform() = default;
        CE_EXPLICIT(false) TAffineTransform(const TMatrix3<T>& raw) : raw(raw) {}
 
    public:
        [[nodiscard]] TAffineTransform concatenating(const TAffineTransform& t) const { return TAffineTransform(raw * t.raw); }
 
        [[nodiscard]] TAffineTransform operator*(const TAffineTransform& rhs) const { return concatenating(rhs); }
 
        [[nodiscard]] TAffineTransform rotatedBy(T angle) const { return TAffineTransform(rotate(raw, angle)); }
 
        [[nodiscard]] static TAffineTransform rotation(T angle) { return TAffineTransform().rotatedBy(angle); }
 
        [[nodiscard]] TAffineTransform operator>>(T angle) { return rotatedBy(angle); }
 
        [[nodiscard]] TAffineTransform operator<<(T angle) { return rotatedBy(-angle); }
 
        [[nodiscard]] TAffineTransform scaledBy(T sx, T sy) const { return TAffineTransform(scale(raw, TVector2<T>{sx, sy})); }
 
        [[nodiscard]] static TAffineTransform scaling(T sx, T sy) { return TAffineTransform().scaledBy(sx, sy); }
 
        [[nodiscard]] TAffineTransform operator*(const TVector2<T>& point) { return scaledBy(point.x, point.y); }
 
        [[nodiscard]] TAffineTransform operator/(const TVector2<T>& point) { return scaledBy(T(1) / point.x, T(1) / point.y); }
 
        [[nodiscard]] TAffineTransform operator*(const T& scale) { return scaledBy(scale, scale); }
 
        [[nodiscard]] TAffineTransform operator/(const T& scale) { return scaledBy(scale, scale); }
 
        [[nodiscard]] TAffineTransform translatedBy(T x, T y) const { return TAffineTransform(translate(raw, TVector2<T>{x, y})); }
 
        [[nodiscard]] static TAffineTransform translation(T x, T y) { return TAffineTransform().translatedBy(x, y); }
 
        [[nodiscard]] TAffineTransform operator+(const TVector2<T>& point) { return translatedBy(point.x, point.y); }
 
        [[nodiscard]] TAffineTransform operator-(const TVector2<T>& point) { return translatedBy(-point.x, -point.y); }
 
        [[nodiscard]] TAffineTransform invert() const { return TAffineTransform(inverse(raw)); }
 
    public:
        [[nodiscard]] TPoint2<T> operator()(const TPoint2<T>& point) const { return TPoint2<T>(raw * TVector3<T>(point, T(1))); }
 
        [[nodiscard]] TSize2<T> operator()(const TSize2<T>& size) const { return TSize2<T>(TVector2<T>(raw * TVector3<T>(TVector2<T>(size), T(0)))); }
 
        [[nodiscard]] TRect2<T> operator()(TRect2<T> rect) const {
            rect.transform(raw);
            return rect;
        }
 
        friend bool operator==(const TAffineTransform& lhs, const TAffineTransform& rhs) { return lhs.raw == rhs.raw; }
        friend bool operator!=(const TAffineTransform& lhs, const TAffineTransform& rhs) { return !(rhs == lhs); }
    };
 
    using AffineTransform = TAffineTransform<double>;
 
} // namespace CeresEngine::inline Math
 
template<typename T> struct std::tuple_size<CeresEngine::TRect2<T>> : std::integral_constant<std::size_t, 4> {};
 
template<std::size_t N, typename T> struct std::tuple_element<N, CeresEngine::TRect2<T>> {
    using type = decltype(get<N>(std::declval<CeresEngine::TRect2<T>>()));
};
 
template<typename T> struct std::tuple_size<const CeresEngine::TRect2<T>> : std::tuple_size<CeresEngine::TRect2<T>> {};
 
template<std::size_t N, typename T> struct std::tuple_element<N, const CeresEngine::TRect2<T>> {
    using type = decltype(get<N>(std::declval<const CeresEngine::TRect2<T>>()));
};
 
template<typename T> struct std::hash<CeresEngine::TSize2<T>> {
    using Type = CeresEngine::TSize2<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.width, obj.height); }
};
 
template<typename T> struct std::hash<CeresEngine::TRect2Edge<T>> {
    using Type = CeresEngine::TRect2Edge<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.origin, obj.size); }
};
 
template<typename T> struct std::hash<CeresEngine::TRect2<T>> {
    using Type = CeresEngine::TRect2<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.origin, obj.size); }
};
 
template<typename T> struct std::hash<CeresEngine::TAffineTransform<T>> {
    using Type = CeresEngine::TAffineTransform<T>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.raw); }
};