extent3.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 "vector3.hpp"
#include "extent2.hpp"
#include "../SIMD/module.hpp"
#include "../utility/utility.hpp"
#include "../macros.hpp"
#include <compare>
#include <concepts>
 
 
 
namespace hi { inline namespace v1 {
 
class extent3 {
public:
    using array_type = simd<float, 4>;
    using value_type = array_type::value_type;
 
    constexpr extent3(extent3 const&) noexcept = default;
    constexpr extent3(extent3&&) noexcept = default;
    constexpr extent3& operator=(extent3 const&) noexcept = default;
    constexpr extent3& operator=(extent3&&) noexcept = default;
 
    [[nodiscard]] constexpr extent3(extent2 const& other) noexcept : _v(static_cast<array_type>(other))
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr explicit operator extent2() const noexcept
    {
        auto tmp = _v;
        tmp.z() = 0.0f;
        return extent2{tmp};
    }
 
    [[nodiscard]] constexpr explicit operator array_type() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit extent3(array_type const& other) noexcept : _v(other)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept
    {
        return _v.x() != 0.0f or _v.y() != 0.0f or _v.z() != 0.0f;
    }
 
    [[nodiscard]] constexpr explicit operator vector3() const noexcept
    {
        return vector3{static_cast<array_type>(*this)};
    }
 
    [[nodiscard]] constexpr extent3() noexcept : _v(0.0f, 0.0f, 0.0f, 0.0f) {}
 
    [[nodiscard]] constexpr extent3(float width, float height, float depth = 0.0f) noexcept : _v(width, height, depth, 0.0f)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr static extent3 infinity() noexcept
    {
        return extent3{
            std::numeric_limits<float>::infinity(),
            std::numeric_limits<float>::infinity(),
            std::numeric_limits<float>::infinity()};
    }
 
    [[nodiscard]] constexpr static extent3 large() noexcept
    {
        return extent3{large_number_v<float>, large_number_v<float>, large_number_v<float>};
    }
 
    [[nodiscard]] constexpr static extent3 nan() noexcept
    {
        auto r = extent3{};
        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
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr float width() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float height() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float depth() const noexcept
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr vector3 right() const noexcept
    {
        return vector3{_v.x000()};
    }
 
    [[nodiscard]] constexpr vector3 up() const noexcept
    {
        return vector3{_v._0y00()};
    }
 
    constexpr extent3& operator+=(extent3 const& rhs) noexcept
    {
        return *this = *this + rhs;
    }
 
    [[nodiscard]] constexpr friend extent3 operator+(extent3 const& lhs, extent3 const& rhs) noexcept
    {
        return extent3{lhs._v + rhs._v};
    }
 
    [[nodiscard]] constexpr friend extent3 operator-(extent3 const& lhs, extent3 const& rhs) noexcept
    {
        return extent3{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend extent3 operator*(extent3 const& lhs, float const& rhs) noexcept
    {
        return extent3{lhs._v * rhs};
    }
 
    [[nodiscard]] constexpr friend extent3 operator+(extent3 const& lhs, vector2 const& rhs) noexcept
    {
        return extent3{static_cast<array_type>(lhs) + static_cast<array_type>(rhs)};
    }
 
    [[nodiscard]] constexpr friend extent3 operator+(extent3 const& lhs, vector3 const& rhs) noexcept
    {
        return extent3{static_cast<array_type>(lhs) + static_cast<array_type>(rhs)};
    }
 
    [[nodiscard]] constexpr friend vector3 operator+(vector3 const& lhs, extent3 const& rhs) noexcept
    {
        return vector3{static_cast<array_type>(lhs) + static_cast<array_type>(rhs)};
    }
 
    [[nodiscard]] constexpr friend extent3 operator+(extent3 const& lhs, float const& rhs) noexcept
    {
        auto r = extent3{};
        for (std::size_t i = 0; i != 3; ++i) {
            r._v[i] = lhs._v[i] + rhs;
        }
 
        return r;
    }
 
    [[nodiscard]] constexpr friend extent3 operator*(float const& lhs, extent3 const& rhs) noexcept
    {
        return extent3{lhs * rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(extent3 const& lhs, extent3 const& rhs) noexcept
    {
        return equal(lhs._v, rhs._v);
    }
 
    [[nodiscard]] constexpr friend std::partial_ordering operator<=>(extent3 const& lhs, extent3 const& rhs) noexcept
    {
        constexpr std::size_t mask = 0b0111;
 
        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(extent3 const& rhs) noexcept
    {
        return squared_hypot<0b0111>(rhs._v);
    }
 
    [[nodiscard]] friend float hypot(extent3 const& rhs) noexcept
    {
        return hypot<0b0111>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend float rcp_hypot(extent3 const& rhs) noexcept
    {
        return rcp_hypot<0b0111>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend extent3 normalize(extent3 const& rhs) noexcept
    {
        return extent3{normalize<0b0111>(rhs._v)};
    }
 
    [[nodiscard]] constexpr friend extent3 ceil(extent3 const& rhs) noexcept
    {
        return extent3{ceil(array_type{rhs})};
    }
 
    [[nodiscard]] constexpr friend extent3 floor(extent3 const& rhs) noexcept
    {
        return extent3{floor(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent3 round(extent3 const& rhs) noexcept
    {
        return extent3{round(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent3 min(extent3 const& lhs, extent3 const& rhs) noexcept
    {
        return extent3{min(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent3 max(extent3 const& lhs, extent3 const& rhs) noexcept
    {
        return extent3{max(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr friend extent3 clamp(extent3 const& value, extent3 const& min, extent3 const& max) noexcept
    {
        return extent3{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(extent3 const& rhs) noexcept
    {
        return std::format("[{}, {}, {}]", rhs._v.x(), rhs._v.y(), rhs._v.z());
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, extent3 const& rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    array_type _v;
};
 
}} // namespace hi::v1
 
template<typename CharT>
struct std::formatter<hi::extent3, CharT> {
    auto parse(auto& pc)
    {
        return pc.end();
    }
 
    auto format(hi::extent3 const& t, auto& fc) const
    {
        return std::vformat_to(fc.out(), "[{}, {}, {}]", std::make_format_args(t.width(), t.height(), t.depth()));
    }
};