aarect.hpp

// Copyright 2020 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Foundation/vec.hpp"
#include "TTauri/Foundation/attributes.hpp"
 
namespace tt {
 
class aarect {
private:
    friend class R32G32B32A32SFloat;
 
    vec v;
 
public:
    tt_force_inline aarect() noexcept : v() {}
    tt_force_inline aarect(aarect const &rhs) noexcept = default;
    tt_force_inline aarect &operator=(aarect const &rhs) noexcept = default;
    tt_force_inline aarect(aarect &&rhs) noexcept = default;
    tt_force_inline aarect &operator=(aarect &&rhs) noexcept = default;
 
    
    template<typename X, typename Y, typename W=float, typename H=float,
        std::enable_if_t<std::is_arithmetic_v<X> && std::is_arithmetic_v<Y> && std::is_arithmetic_v<W> && std::is_arithmetic_v<H>,int> = 0>
    tt_force_inline aarect(X x, Y y, W width, H height) noexcept :
        v(vec(
            numeric_cast<float>(x),
            numeric_cast<float>(y),
            numeric_cast<float>(x) + numeric_cast<float>(width),
            numeric_cast<float>(y) + numeric_cast<float>(height)
        )) {}
 
    tt_force_inline aarect(vec const &position, vec const &extent) noexcept :
        v(position.xyxy() + extent._00xy()) {
        tt_assume(position.is_point());
        tt_assume(position.z() == 0.0);
        tt_assume(extent.is_vector());
        tt_assume(extent.z() == 0.0);
    }
 
    tt_force_inline aarect(vec const &extent) noexcept :
        v(extent._00xy()) {
        tt_assume(extent.is_vector());
        tt_assume(extent.z() == 0.0);
    }
 
    [[nodiscard]] tt_force_inline static aarect p0p3(vec const &v) noexcept {
        aarect r;
        r.v = v;
        return r;
    }
 
    [[nodiscard]] tt_force_inline static aarect p0p3(vec const &p0, vec const &p3) noexcept {
        tt_assume(p0.is_point());
        tt_assume(p3.is_point());
        return aarect::p0p3(p0.xy00() + p3._00xy());
    }
 
    operator bool () const noexcept {
        return v.xyxy() != v.zwzw();
    }
 
    aarect &operator|=(aarect const &rhs) noexcept {
        return *this = *this | rhs;
    }
 
    aarect &operator|=(vec const &rhs) noexcept {
        return *this = *this | rhs;
    }
 
 
    aarect &operator+=(vec const &rhs) noexcept {
        return *this = *this + rhs;
    }
 
    aarect &operator-=(vec const &rhs) noexcept {
        return *this = *this - rhs;
    }
 
    aarect &operator*=(float rhs) noexcept {
        return *this = *this * rhs;
    }
 
    template<size_t I>
    [[nodiscard]] tt_force_inline vec corner() const noexcept {
        static_assert(I <= 3);
        if constexpr (I == 0) {
            return v.xy01();
        } else if constexpr (I == 1) {
            return v.zy01();
        } else if constexpr (I == 2) {
            return v.xw01();
        } else {
            return v.zw01();
        }
    }
 
    //template<size_t I, typename Z, std::enable_if_t<std::is_arithmetic_v<Z>,int> = 0>
    //[[nodiscard]] tt_force_inline vec corner(Z z) const noexcept {
    //    return corner<I>().z(numeric_cast<float>(z));
    //}
 
    [[nodiscard]] tt_force_inline vec p0() const noexcept {
        return corner<0>();
    }
 
    [[nodiscard]] tt_force_inline vec p3() const noexcept {
        return corner<3>();
    }
 
 
    [[nodiscard]] tt_force_inline vec offset() const noexcept {
        return v.xy00();
    }
 
    [[nodiscard]] vec extent() const noexcept {
        return (v.zwzw() - v).xy00();
    }
 
    [[nodiscard]] tt_force_inline float x() const noexcept {
        return v.x();
    }
 
    [[nodiscard]] tt_force_inline float y() const noexcept {
        return v.y();
    }
 
    [[nodiscard]] tt_force_inline float width() const noexcept {
        return (v.zwzw() - v).x();
    }
 
    [[nodiscard]] tt_force_inline float height() const noexcept {
        return (v.zwzw() - v).y();
    }
 
    template<typename T, std::enable_if_t<std::is_arithmetic_v<T>,int> = 0>
    tt_force_inline aarect &width(T newWidth) noexcept {
        v = v.xyxw() + vec::make_z(newWidth);
        return *this;
    }
 
    template<typename T, std::enable_if_t<std::is_arithmetic_v<T>,int> = 0>
    tt_force_inline aarect &height(T newHeight) noexcept {
        v = v.xyzy() + vec::make_w(newHeight);
        return *this;
    }
 
    [[nodiscard]] bool contains(vec const &rhs) const noexcept {
        return (rhs.xyxy() >= v) == 0b0011;
    }
 
    [[nodiscard]] friend aarect align(aarect haystack, aarect needle, Alignment alignment) noexcept {
        float x;
        if (alignment == HorizontalAlignment::Left) {
            x = haystack.p0().x();
 
        } else if (alignment == HorizontalAlignment::Right) {
            x = haystack.p3().x() - needle.width();
 
        } else if (alignment == HorizontalAlignment::Center) {
            x = (haystack.p0().x() + (haystack.width() * 0.5f)) - (needle.width() * 0.5f);
 
        } else {
            tt_no_default;
        }
 
        float y;
        if (alignment == VerticalAlignment::Bottom) {
            y = haystack.p0().y();
 
        } else if (alignment == VerticalAlignment::Top) {
            y = haystack.p3().y() - needle.height();
 
        } else if (alignment == VerticalAlignment::Middle) {
            y = (haystack.p0().y() + (haystack.height() * 0.5f)) - (needle.height() * 0.5f);
 
        } else {
            tt_no_default;
        }
 
        return {vec::point(x, y), needle.extent()};
    }
 
    [[nodiscard]] static aarect _align(aarect outside, aarect inside, Alignment alignment) noexcept {
        return align(outside, inside, alignment);
    }
 
    [[nodiscard]] friend bool operator==(aarect const &lhs, aarect const &rhs) noexcept {
        return lhs.v == rhs.v;
    }
 
    [[nodiscard]] friend bool operator!=(aarect const &lhs, aarect const &rhs) noexcept {
        return !(lhs == rhs);
    }
 
    [[nodiscard]] friend bool overlaps(aarect const &lhs, aarect const &rhs) noexcept {
        ttlet rhs_swap = rhs.v.zwxy();
        if (((lhs.v > rhs_swap) & 0x0011) != 0) {
            return false;
        }
        if (((lhs.v < rhs_swap) & 0x1100) != 0) {
            return false;
        }
        return true;
    }
 
    [[nodiscard]] friend aarect operator|(aarect const &lhs, aarect const &rhs) noexcept {
        return aarect::p0p3(min(lhs.p0(), rhs.p0()), max(lhs.p3(), rhs.p3()));
    }
 
    [[nodiscard]] friend aarect operator|(aarect const &lhs, vec const &rhs) noexcept {
        tt_assume(rhs.is_point());
        return aarect::p0p3(min(lhs.p0(), rhs), max(lhs.p3(), rhs));
    }
 
    [[nodiscard]] friend aarect operator+(aarect const &lhs, vec const &rhs) noexcept {
        return aarect::p0p3(lhs.v + rhs.xyxy());
    }
 
    [[nodiscard]] friend aarect operator-(aarect const &lhs, vec const &rhs) noexcept {
        return aarect::p0p3(lhs.v - rhs.xyxy());
    }
 
    [[nodiscard]] friend aarect operator*(aarect const &lhs, float rhs) noexcept {
        return aarect::p0p3(lhs.v * vec{rhs});
    }
 
    [[nodiscard]] friend aarect scale(aarect const &lhs, float rhs) noexcept {
        ttlet extent = lhs.extent();
        ttlet scaled_extent = extent * rhs;
        ttlet diff_extent = scaled_extent - extent;
        ttlet half_diff_extent = diff_extent * 0.5f;
 
        ttlet p1 = lhs.p0() - half_diff_extent;
        ttlet p2 = lhs.p3() + half_diff_extent;
        return aarect::p0p3(p1, p2);
    }
 
 
    [[nodiscard]] friend aarect expand(aarect const &lhs, float rhs) noexcept {
        return aarect::p0p3(lhs.v + neg<1,1,0,0>(vec{rhs}));
    }
 
    [[nodiscard]] friend aarect shrink(aarect const &lhs, float rhs) noexcept {
        return expand(lhs, -rhs);
    }
 
    [[nodiscard]] friend aarect round(aarect const &rhs) noexcept {
        return aarect::p0p3(round(rhs.v));
    }
};
 
}