extent.hpp

// Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "vector.hpp"
#include "../rapid/numeric_array.hpp"
 
namespace tt {
namespace geo {
 
template<int D>
class extent {
public:
    static_assert(D == 2 || D == 3, "Only 2D or 3D extents are supported");
 
    constexpr extent(extent const &) noexcept = default;
    constexpr extent(extent &&) noexcept = default;
    constexpr extent &operator=(extent const &) noexcept = default;
    constexpr extent &operator=(extent &&) noexcept = default;
 
    template<int E>
    requires(E < D) [[nodiscard]] constexpr extent(extent<E> const &other) noexcept : _v(static_cast<f32x4>(other))
    {
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] constexpr explicit operator f32x4() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit extent(f32x4 const &other) noexcept : _v(other)
    {
        tt_axiom(is_valid());
    }
 
    template<int E>
    [[nodiscard]] constexpr explicit operator vector<E>() const noexcept requires(E >= D)
    {
        tt_axiom(is_valid());
        return vector<E>{static_cast<f32x4>(*this)};
    }
 
    [[nodiscard]] constexpr extent() noexcept : _v(0.0f, 0.0f, 0.0f, 0.0f)
    {
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] constexpr extent(float width, float height) noexcept requires(D == 2) : _v(width, height, 0.0f, 0.0f)
    {
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] constexpr extent(float width, float height, float depth = 0.0f) noexcept requires(D == 3) :
        _v(width, height, depth, 0.0f)
    {
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] static constexpr extent infinity() noexcept requires(D == 2)
    {
        return extent{std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity()};
    }
 
    [[nodiscard]] static constexpr extent infinity() noexcept requires(D == 3)
    {
        return extent{
            std::numeric_limits<float>::infinity(),
            std::numeric_limits<float>::infinity(),
            std::numeric_limits<float>::infinity()};
    }
 
    [[nodiscard]] static constexpr extent large() noexcept requires(D == 2)
    {
        return extent{32767.0f, 32767.0f};
    }
 
    [[nodiscard]] static constexpr extent large() noexcept requires(D == 3)
    {
        return extent{32767.0f, 32767.0f, 32767.0f};
    }
 
    [[nodiscard]] static constexpr extent nan() noexcept requires(D == 2)
    {
        auto r = extent{};
        r._v.x() = std::numeric_limits<float>::signaling_NaN();
        r._v.y() = std::numeric_limits<float>::signaling_NaN();
        return r;
    }
 
    [[nodiscard]] static constexpr extent nan() noexcept requires(D == 3)
    {
        auto r = extent{};
        r._v.x() = std::numeric_limits<float>::signaling_NaN();
        r._v.y() = std::numeric_limits<float>::signaling_NaN();
        r._v.z() = std::numeric_limits<float>::signaling_NaN();
        return r;
    }
 
    [[nodiscard]] constexpr float &width() noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float &height() noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float &depth() noexcept requires(D == 3)
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr float const &width() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float const &height() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float const &depth() const noexcept requires(D == 3)
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr vector<D> right() const noexcept
    {
        return vector<D>{_v.x000()};
    }
 
    [[nodiscard]] constexpr vector<D> up() const noexcept
    {
        return vector<D>{_v._0y00()};
    }
 
    constexpr extent &operator+=(extent const &rhs) noexcept
    {
        return *this = *this + rhs;
    }
 
    [[nodiscard]] constexpr friend extent operator+(extent const &lhs, extent const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return extent{lhs._v + rhs._v};
    }
 
    [[nodiscard]] constexpr friend extent operator-(extent const &lhs, extent const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return extent{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend extent operator*(extent const &lhs, float const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid());
        return extent{lhs._v * rhs};
    }
 
    template<int E>
    [[nodiscard]] constexpr friend auto operator+(extent const &lhs, vector<E> const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid());
        tt_axiom(rhs.is_valid());
 
        return extent<std::max(D, E)>{static_cast<f32x4>(lhs) + static_cast<f32x4>(rhs)};
    }
 
    template<int E>
    [[nodiscard]] constexpr friend auto operator+(vector<E> const &lhs, extent const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid());
        tt_axiom(rhs.is_valid());
 
        return vector<std::max(D, E)>{static_cast<f32x4>(lhs) + static_cast<f32x4>(rhs)};
    }
 
    [[nodiscard]] constexpr friend extent operator+(extent const &lhs, float const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid());
 
        auto r = extent{};
        for (size_t i = 0; i != D; ++i) {
            r._v[i] = lhs._v[i] + rhs;
        }
 
        return r;
    }
 
    [[nodiscard]] constexpr friend extent operator*(float const &lhs, extent const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return extent{lhs * rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(extent const &lhs, extent const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return lhs._v == rhs._v;
    }
 
    [[nodiscard]] constexpr friend bool operator<(extent const &lhs, extent const &rhs) noexcept requires(D == 2)
    {
        return lhs.width() < rhs.width() && lhs.height() < rhs.height();
    }
 
    [[nodiscard]] constexpr friend bool operator<(extent const &lhs, extent const &rhs) noexcept requires(D == 3)
    {
        return lhs.width() < rhs.width() && lhs.height() < rhs.height() && lhs.depth() < rhs.depth();
    }
 
    [[nodiscard]] constexpr friend bool operator<=(extent const &lhs, extent const &rhs) noexcept requires(D == 2)
    {
        return lhs.width() <= rhs.width() && lhs.height() <= rhs.height();
    }
 
    [[nodiscard]] constexpr friend bool operator<=(extent const &lhs, extent const &rhs) noexcept requires(D == 3)
    {
        return lhs.width() <= rhs.width() && lhs.height() <= rhs.height() && lhs.depth() <= rhs.depth();
    }
 
    [[nodiscard]] constexpr friend bool operator>(extent const &lhs, extent const &rhs) noexcept requires(D == 2)
    {
        return lhs.width() > rhs.width() && lhs.height() > rhs.height();
    }
 
    [[nodiscard]] constexpr friend bool operator>(extent const &lhs, extent const &rhs) noexcept requires(D == 3)
    {
        return lhs.width() > rhs.width() && lhs.height() > rhs.height() && lhs.depth() > rhs.depth();
    }
 
    [[nodiscard]] constexpr friend bool operator>=(extent const &lhs, extent const &rhs) noexcept requires(D == 2)
    {
        return lhs.width() >= rhs.width() && lhs.height() >= rhs.height();
    }
 
    [[nodiscard]] constexpr friend bool operator>=(extent const &lhs, extent const &rhs) noexcept requires(D == 3)
    {
        return lhs.width() >= rhs.width() && lhs.height() >= rhs.height() && lhs.depth() >= rhs.depth();
    }
 
    [[nodiscard]] constexpr friend float squared_hypot(extent const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return squared_hypot<element_mask>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend float hypot(extent const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return hypot<element_mask>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend float rcp_hypot(extent const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return rcp_hypot<element_mask>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend extent normalize(extent const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return extent{normalize<element_mask>(rhs._v)};
    }
 
    [[nodiscard]] constexpr friend extent ceil(extent const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return extent{ceil(static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent floor(extent const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return extent{floor(static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent min(extent const &lhs, extent const &rhs) noexcept
    {
        return extent{min(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent max(extent const &lhs, extent const &rhs) noexcept
    {
        return extent{max(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent clamp(extent const &value, extent const &min, extent const &max) noexcept
    {
        return extent{clamp(static_cast<f32x4>(value), static_cast<f32x4>(min), static_cast<f32x4>(max))};
    }
 
    [[nodiscard]] constexpr bool is_valid() const noexcept
    {
        return _v.x() >= 0.0f && _v.y() >= 0.0f && _v.z() >= 0.0f && _v.w() == 0.0f && (D == 3 || _v.z() == 0.0f);
    }
 
    [[nodiscard]] friend std::string to_string(extent const &rhs) noexcept
    {
        if constexpr (D == 2) {
            return std::format("[{}, {}]", rhs._v.x(), rhs._v.y());
        } else if constexpr (D == 3) {
            return std::format("[{}, {}, {}]", rhs._v.x(), rhs._v.y(), rhs._v.z());
        } else {
            tt_static_no_default();
        }
    }
 
    friend std::ostream &operator<<(std::ostream &lhs, extent const &rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    f32x4 _v;
 
    static constexpr size_t element_mask = (1_uz << D) - 1;
};
 
} // namespace geo
 
using extent2 = geo::extent<2>;
using extent3 = geo::extent<3>;
 
} // namespace tt
 
namespace std {
 
template<typename CharT>
struct formatter<tt::geo::extent<2>, CharT> {
    auto parse(auto &pc)
    {
        return pc.end();
    }
 
    auto format(tt::geo::extent<2> const &t, auto &fc)
    {
        return std::vformat_to(fc.out(), "[{}, {}]", std::make_format_args(t.width(), t.height()));
    }
};
 
template<typename CharT>
struct formatter<tt::geo::extent<3>, CharT> : formatter<float, CharT> {
    auto parse(auto &pc)
    {
        return pc.end();
    }
 
    auto format(tt::geo::extent<3> const &t, auto &fc)
    {
        return std::vformat_to(fc.out(), "[{}, {}, {}]", std::make_format_args(t.width(), t.height(), t.depth()));
    }
};
 
} // namespace std