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 "../utility/utility.hpp"
#include "../macros.hpp"
#include <hikocpu/hikocpu.hpp>
#include <compare>
#include <concepts>
#include <format>
#include <ostream>
#include <exception>
 
hi_export_module(hikogui.geometry : extent2);
 
hi_export 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 * array_type::broadcast(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{array_type::broadcast(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;
 
        auto const equal = (lhs._v == rhs._v).mask() & mask;
        if (equal == mask) {
            // Only equivalent if all elements are equal.
            return std::partial_ordering::equivalent;
        }
 
        auto const 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;
        }
 
        auto const 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 dot<0b0011>(rhs._v, rhs._v).x();
    }
 
    [[nodiscard]] friend float hypot(extent2 const& rhs) noexcept
    {
        return hypot<0b0011>(rhs._v).x();
    }
 
    [[nodiscard]] constexpr friend float rcp_hypot(extent2 const& rhs) noexcept
    {
        return rhypot<0b0011>(rhs._v).x();
    }
 
    [[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
 
// XXX #617 MSVC bug does not handle partial specialization in modules.
hi_export template<>
struct std::formatter<hi::extent2, char> : std::formatter<std::string, char> {
    auto format(hi::extent2 const& t, auto& fc) const
    {
        return std::formatter<std::string, char>::format(std::format("[{}, {}]", t.width(), t.height()), fc);
    }
};