vector.hpp

// Copyright Take Vos 2021.
// 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 "../numeric_array.hpp"
 
namespace tt {
namespace geo {
 
template<int D>
class vector {
public:
    static_assert(D == 2 || D == 3, "Only 2D or 3D vectors are supported");
 
    constexpr vector(vector const &) noexcept = default;
    constexpr vector(vector &&) noexcept = default;
    constexpr vector &operator=(vector const &) noexcept = default;
    constexpr vector &operator=(vector &&) noexcept = default;
 
    template<int E>
    requires(E < D) [[nodiscard]] constexpr vector(vector<E> const &other) noexcept : _v(static_cast<f32x4>(other))
    {
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] constexpr explicit operator f32x4() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit vector(f32x4 const &other) noexcept : _v(other)
    {
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] constexpr vector() noexcept : _v(0.0f, 0.0f, 0.0f, 0.0f) {}
 
    [[nodiscard]] constexpr vector(float x, float y) noexcept requires(D == 2) : _v(x, y, 0.0f, 0.0f) {}
 
    [[nodiscard]] constexpr vector(float x, float y, float z = 0.0f) noexcept requires(D == 3) : _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 requires(D == 3)
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr float const &x() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float const &y() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float const &z() const noexcept requires(D == 3)
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr vector operator-() const noexcept
    {
        tt_axiom(is_valid());
        return vector{-_v};
    }
 
    [[nodiscard]] constexpr friend vector operator+(vector const &lhs, vector const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return vector{lhs._v + rhs._v};
    }
 
    [[nodiscard]] constexpr friend vector operator-(vector const &lhs, vector const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return vector{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend vector operator*(vector const &lhs, float const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid());
        return vector{lhs._v * rhs};
    }
 
    [[nodiscard]] constexpr friend vector operator*(float const &lhs, vector const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return vector{lhs * rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(vector const &lhs, vector const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return lhs._v == rhs._v;
    }
 
    [[nodiscard]] constexpr friend float squared_hypot(vector const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return squared_hypot<element_mask>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend float hypot(vector const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return hypot<element_mask>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend float rcp_hypot(vector const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return rcp_hypot<element_mask>(rhs._v);
    }
 
    [[nodiscard]] constexpr friend vector normalize(vector const &rhs) noexcept
    {
        tt_axiom(rhs.is_valid());
        return vector{normalize<element_mask>(rhs._v)};
    }
 
    [[nodiscard]] constexpr friend float dot(vector const &lhs, vector const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return dot<element_mask>(lhs._v, rhs._v);
    }
 
    [[nodiscard]] constexpr bool is_valid() const noexcept
    {
        return _v.w() == 0.0f && (D == 3 || _v.z() == 0.0f);
    }
 
private:
    f32x4 _v;
 
    static constexpr size_t element_mask = (1_uz << D) - 1;
};
 
[[nodiscard]] constexpr vector<2> cross(vector<2> const &rhs) noexcept
{
    tt_axiom(rhs.is_valid());
    return vector<2>{cross_2D(static_cast<f32x4>(rhs))};
}
 
[[nodiscard]] constexpr vector<2> normal(vector<2> const &rhs) noexcept
{
    tt_axiom(rhs.is_valid());
    return normalize(cross(rhs));
}
 
[[nodiscard]] constexpr float cross(vector<2> const &lhs, vector<2> const &rhs) noexcept
{
    tt_axiom(lhs.is_valid() && rhs.is_valid());
    return cross_2D(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs));
}
 
[[nodiscard]] constexpr vector<3> cross(vector<3> const &lhs, vector<3> const &rhs) noexcept
{
    tt_axiom(lhs.is_valid() && rhs.is_valid());
    return vector<3>{cross_3D(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs))};
}
 
}
 
using vector2 = geo::vector<2>;
using vector3 = geo::vector<3>;
 
} // namespace tt