vector3.hpp

// 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/SIMD.hpp"
#include "../macros.hpp"
#include <exception>
#include <format>
#include <ostream>
#include <compare>
 
hi_export_module(hikogui.geometry : vector3);
 
hi_export namespace hi { inline namespace v1 {
 
class vector3 {
public:
    using array_type = simd<float, 4>;
    using value_type = array_type::value_type;
 
    constexpr vector3(vector3 const&) noexcept = default;
    constexpr vector3(vector3&&) noexcept = default;
    constexpr vector3& operator=(vector3 const&) noexcept = default;
    constexpr vector3& operator=(vector3&&) noexcept = default;
 
    [[nodiscard]] constexpr vector3(vector2 const& other) noexcept : _v(static_cast<array_type>(other))
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr explicit operator vector2() noexcept
    {
        auto tmp = _v;
        tmp.z() = 0.0f;
        return vector2{tmp};
    }
 
    [[nodiscard]] constexpr explicit operator array_type() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit vector3(array_type const& other) noexcept : _v(other)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr vector3() noexcept : _v(0.0f, 0.0f, 0.0f, 0.0f) {}
 
    [[nodiscard]] constexpr vector3(float x, float y, float z = 0.0f) noexcept : _v(x, y, z, 0.0f) {}
 
    [[nodiscard]] constexpr float& x() noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float& y() noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float& z() noexcept
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr float x() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float y() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float z() const noexcept
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr vector3 operator-() const noexcept
    {
        return vector3{-_v};
    }
 
    constexpr vector3& operator+=(vector3 const& rhs) noexcept
    {
        return *this = *this + rhs;
    }
 
    constexpr vector3& operator-=(vector3 const& rhs) noexcept
    {
        return *this = *this - rhs;
    }
 
    constexpr vector3& operator*=(float const& rhs) noexcept
    {
        return *this = *this * rhs;
    }
 
    [[nodiscard]] constexpr friend vector3 operator+(vector3 const& lhs, vector3 const& rhs) noexcept
    {
        return vector3{lhs._v + rhs._v};
    }
 
    [[nodiscard]] constexpr friend vector3 operator-(vector3 const& lhs, vector3 const& rhs) noexcept
    {
        return vector3{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend vector3 operator*(vector3 const& lhs, float const& rhs) noexcept
    {
        return vector3{lhs._v * array_type::broadcast(rhs)};
    }
 
    [[nodiscard]] constexpr friend vector3 operator*(float const& lhs, vector3 const& rhs) noexcept
    {
        return vector3{array_type::broadcast(lhs) * rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(vector3 const& lhs, vector3 const& rhs) noexcept
    {
        return equal(lhs._v, rhs._v);
    }
 
    [[nodiscard]] constexpr friend float squared_hypot(vector3 const& rhs) noexcept
    {
        return dot<0b0111>(rhs._v, rhs._v).x();
    }
 
    [[nodiscard]] friend float hypot(vector3 const& rhs) noexcept
    {
        return hypot<0b0111>(rhs._v).x();
    }
 
    [[nodiscard]] constexpr friend float rcp_hypot(vector3 const& rhs) noexcept
    {
        return rhypot<0b0111>(rhs._v).x();
    }
 
    [[nodiscard]] constexpr friend vector3 normalize(vector3 const& rhs) noexcept
    {
        return vector3{normalize<0b0111>(rhs._v)};
    }
 
    [[nodiscard]] constexpr friend float dot(vector3 const& lhs, vector3 const& rhs) noexcept
    {
        return dot<0b0111>(lhs._v, rhs._v).x();
    }
 
    [[nodiscard]] constexpr friend vector3 normal(vector3 const& rhs, float angle) noexcept
    {
        if (angle != float{0}) {
            hi_not_implemented();
        }
        return normal(vector2{array_type{rhs}.xy00()});
    }
 
    [[nodiscard]] constexpr friend vector3 cross(vector3 const& lhs, vector3 const& rhs) noexcept
    {
        auto const a_left = lhs._v.yzxw();
        auto const b_left = rhs._v.zxyw();
        auto const left = a_left * b_left;
 
        auto const a_right = lhs._v.zxyw();
        auto const b_right = rhs._v.yzxw();
        auto const right = a_right * b_right;
        return vector3{left - right};
    }
 
    [[nodiscard]] friend constexpr vector3 min(vector3 const& lhs, vector3 const& rhs) noexcept
    {
        return vector3{min(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector3 max(vector3 const& lhs, vector3 const& rhs) noexcept
    {
        return vector3{max(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector3 round(vector3 const& rhs) noexcept
    {
        return vector3{round(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector3 ceil(vector3 const& rhs) noexcept
    {
        return vector3{ceil(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector3 floor(vector3 const& rhs) noexcept
    {
        return vector3{floor(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr bool holds_invariant() const noexcept
    {
        return _v.w() == 0.0f;
    }
 
    [[nodiscard]] friend std::string to_string(vector3 const& rhs) noexcept
    {
        return std::format("({}, {}, {})", rhs._v.x(), rhs._v.y(), rhs._v.z());
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, vector3 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::vector3, char> {
    auto parse(auto& pc)
    {
        return pc.end();
    }
 
    auto format(hi::vector3 const& t, auto& fc) const
    {
        return std::vformat_to(fc.out(), "({}, {}, {})", std::make_format_args(t.x(), t.y(), t.z()));
    }
};