extent2.hpp

Go to the documentation of this file.

// Copyright Take Vos 2021-2022.
// 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 "vector2.hpp"
#include "../SIMD/module.hpp"
#include "../utility/utility.hpp"
#include "../macros.hpp"
#include <compare>
#include <concepts>
 
 
 
namespace hi { inline namespace v1 {

class extent2 {
public:
    using array_type = simd<float, 4>;
    using value_type = array_type::value_type;
 
    constexpr extent2(extent2 const&) noexcept = default;
    constexpr extent2(extent2&&) noexcept = default;
    constexpr extent2& operator=(extent2 const&) noexcept = default;
    constexpr extent2& operator=(extent2&&) noexcept = default;
 
    [[nodiscard]] constexpr explicit extent2(array_type const& other) noexcept : _v(other)
    {
        hi_axiom(holds_invariant());
    }

    [[nodiscard]] constexpr explicit operator array_type() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit extent2(vector2 const &other) noexcept : _v(f32x4{other})
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr explicit operator vector2() const noexcept
    {
        return vector2{static_cast<array_type>(*this)};
    }

    [[nodiscard]] constexpr extent2() noexcept : _v(0.0f, 0.0f, 0.0f, 0.0f) {}

    [[nodiscard]] constexpr extent2(float width, float height) noexcept : _v(width, height, 0.0f, 0.0f)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr static extent2 infinity() noexcept
    {
        return extent2{std::numeric_limits<value_type>::infinity(), std::numeric_limits<value_type>::infinity()};
    }
 
    [[nodiscard]] constexpr static extent2 large() noexcept
    {
        return extent2{large_number_v<float>, large_number_v<float>};
    }
 
    [[nodiscard]] constexpr static extent2 nan() noexcept
    {
        auto r = extent2{};
        r._v.x() = std::numeric_limits<value_type>::signaling_NaN();
        r._v.y() = std::numeric_limits<value_type>::signaling_NaN();
        return r;
    }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept
    {
        return _v.x() != 0.0f or _v.y() != 0.0f or _v.z() != 0.0f;
    }

    [[nodiscard]] constexpr float& width() noexcept
    {
        return _v.x();
    }

    [[nodiscard]] constexpr float& height() noexcept
    {
        return _v.y();
    }

    [[nodiscard]] constexpr float width() const noexcept
    {
        return _v.x();
    }

    [[nodiscard]] constexpr float height() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr vector2 right() const noexcept
    {
        return vector2{_v.x000()};
    }
 
    [[nodiscard]] constexpr vector2 up() const noexcept
    {
        return vector2{_v._0y00()};
    }
 
    constexpr extent2& operator+=(extent2 const& rhs) noexcept
    {
        return *this = *this + rhs;
    }

    [[nodiscard]] constexpr friend extent2 operator+(extent2 const& lhs, extent2 const& rhs) noexcept
    {
        return extent2{lhs._v + rhs._v};
    }

    [[nodiscard]] constexpr friend extent2 operator-(extent2 const& lhs, extent2 const& rhs) noexcept
    {
        return extent2{lhs._v - rhs._v};
    }

    [[nodiscard]] constexpr friend extent2 operator*(extent2 const& lhs, float const& rhs) noexcept
    {
        return extent2{lhs._v * rhs};
    }
 
    [[nodiscard]] constexpr friend extent2 operator+(extent2 const& lhs, vector2 const& rhs) noexcept
    {
        return extent2{static_cast<array_type>(lhs) + static_cast<array_type>(rhs)};
    }
 
    [[nodiscard]] constexpr friend vector2 operator+(vector2 const& lhs, extent2 const& rhs) noexcept
    {
        return vector2{static_cast<array_type>(lhs) + static_cast<array_type>(rhs)};
    }

    [[nodiscard]] constexpr friend extent2 operator+(extent2 const& lhs, float const& rhs) noexcept
    {
        auto r = extent2{};
        for (std::size_t i = 0; i != 2; ++i) {
            r._v[i] = lhs._v[i] + rhs;
        }
 
        return r;
    }

    [[nodiscard]] constexpr friend extent2 operator*(float const& lhs, extent2 const& rhs) noexcept
    {
        return extent2{lhs * rhs._v};
    }

    [[nodiscard]] constexpr friend bool operator==(extent2 const& lhs, extent2 const& rhs) noexcept
    {
        return equal(lhs._v, rhs._v);
    }
 
    [[nodiscard]] constexpr friend std::partial_ordering operator<=>(extent2 const& lhs, extent2 const& rhs) noexcept
    {
        constexpr std::size_t mask = 0b0011;
 
        hilet equal = (lhs._v == rhs._v).mask() & mask;
        if (equal == mask) {
            // Only equivalent if all elements are equal.
            return std::partial_ordering::equivalent;
        }
 
        hilet less = (lhs._v < rhs._v).mask() & mask;
        if ((less | equal) == mask) {
            // If one or more elements is less (but none are greater) then the ordering is less.
            return std::partial_ordering::less;
        }
 
        hilet greater = (lhs._v > rhs._v).mask() & mask;
        if ((greater | equal) == mask) {
            // If one or more elements is greater (but none are less) then the ordering is greater.
            return std::partial_ordering::greater;
        }
 
        // Some elements are less and others are greater, we don't have an ordering.
        return std::partial_ordering::unordered;
    }

    [[nodiscard]] hi_force_inline constexpr friend float squared_hypot(extent2 const& rhs) noexcept
    {
        return squared_hypot<0b0011>(rhs._v);
    }

    [[nodiscard]] friend float hypot(extent2 const& rhs) noexcept
    {
        return hypot<0b0011>(rhs._v);
    }

    [[nodiscard]] constexpr friend float rcp_hypot(extent2 const& rhs) noexcept
    {
        return rcp_hypot<0b0011>(rhs._v);
    }

    [[nodiscard]] constexpr friend extent2 normalize(extent2 const& rhs) noexcept
    {
        return extent2{normalize<0b0011>(rhs._v)};
    }
 
    [[nodiscard]] constexpr friend extent2 ceil(extent2 const& rhs) noexcept
    {
        return extent2{ceil(array_type{rhs})};
    }
 
    [[nodiscard]] constexpr friend extent2 floor(extent2 const& rhs) noexcept
    {
        return extent2{floor(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent2 round(extent2 const& rhs) noexcept
    {
        return extent2{round(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent2 min(extent2 const& lhs, extent2 const& rhs) noexcept
    {
        return extent2{min(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent2 max(extent2 const& lhs, extent2 const& rhs) noexcept
    {
        return extent2{max(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent2 clamp(extent2 const& value, extent2 const& min, extent2 const& max) noexcept
    {
        return extent2{clamp(static_cast<array_type>(value), static_cast<array_type>(min), static_cast<array_type>(max))};
    }

    [[nodiscard]] constexpr bool holds_invariant() const noexcept
    {
        return _v.x() >= 0.0f and _v.y() >= 0.0f and _v.z() == 0.0f and _v.w() == 0.0f;
    }
 
    [[nodiscard]] friend std::string to_string(extent2 const& rhs) noexcept
    {
        return std::format("[{}, {}]", rhs._v.x(), rhs._v.y());
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, extent2 const& rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    array_type _v;
};
 
}} // namespace hi::v1
 
template<typename CharT>
struct std::formatter<hi::extent2, CharT> {
    auto parse(auto& pc)
    {
        return pc.end();
    }
 
    auto format(hi::extent2 const& t, auto& fc) const
    {
        return std::vformat_to(fc.out(), "[{}, {}]", std::make_format_args(t.width(), t.height()));
    }
};