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/module.hpp"
#include "../macros.hpp"
 
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 * 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 squared_hypot<0b0111>(rhs._v);
    }

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

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

    [[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);
    }

    [[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
    {
        return vector3{cross_3D(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }

    [[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
 
template<typename CharT>
struct std::formatter<hi::vector3, CharT> {
    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()));
    }
};