vector2.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 "../utility/utility.hpp"
#include "../macros.hpp"
#include <hikocpu/hikocpu.hpp>
#include <exception>
#include <format>
#include <ostream>
#include <compare>
 
hi_export_module(hikogui.geometry : vector2);
 
hi_export namespace hi {
inline namespace v1 {
 
class vector2 {
public:
    using array_type = simd<float, 4>;
    using value_type = array_type::value_type;
 
    constexpr vector2(vector2 const&) noexcept = default;
    constexpr vector2(vector2&&) noexcept = default;
    constexpr vector2& operator=(vector2 const&) noexcept = default;
    constexpr vector2& operator=(vector2&&) noexcept = default;
 
    [[nodiscard]] constexpr explicit operator array_type() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit vector2(array_type const& other) noexcept : _v(other)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr vector2() noexcept : _v(0.0f, 0.0f, 0.0f, 0.0f) {}
 
    [[nodiscard]] constexpr vector2(float x, float y) noexcept : _v(x, y, 0.0f, 0.0f) {}
 
    [[nodiscard]] constexpr float& x() noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float& y() noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float x() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float y() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr vector2 operator-() const noexcept
    {
        return vector2{-_v};
    }
 
    constexpr vector2& operator+=(vector2 const& rhs) noexcept
    {
        return *this = *this + rhs;
    }
 
    constexpr vector2& operator-=(vector2 const& rhs) noexcept
    {
        return *this = *this - rhs;
    }
 
    constexpr vector2& operator*=(float const& rhs) noexcept
    {
        return *this = *this * rhs;
    }
 
    [[nodiscard]] constexpr friend vector2 operator+(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        return vector2{lhs._v + rhs._v};
    }
 
    [[nodiscard]] constexpr friend vector2 operator-(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        return vector2{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend vector2 operator*(vector2 const& lhs, float const& rhs) noexcept
    {
        return vector2{lhs._v * array_type::broadcast(rhs)};
    }
 
    [[nodiscard]] constexpr friend vector2 operator*(float const& lhs, vector2 const& rhs) noexcept
    {
        return vector2{array_type::broadcast(lhs) * rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        return equal(lhs._v, rhs._v);
    }
 
    [[nodiscard]] constexpr friend float squared_hypot(vector2 const& rhs) noexcept
    {
        return dot<0b0011>(rhs._v, rhs._v).x();
    }
 
    [[nodiscard]] friend float hypot(vector2 const& rhs) noexcept
    {
        return hypot<0b0011>(rhs._v).x();
    }
 
    [[nodiscard]] constexpr friend float rcp_hypot(vector2 const& rhs) noexcept
    {
        return rhypot<0b0011>(rhs._v).x();
    }
 
    [[nodiscard]] constexpr friend vector2 normalize(vector2 const& rhs) noexcept
    {
        return vector2{normalize<0b0011>(rhs._v)};
    }
 
    [[nodiscard]] constexpr friend float dot(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        return dot<0b0011>(lhs._v, rhs._v).x();
    }
 
    [[nodiscard]] constexpr friend float det(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        return lhs.x() * rhs.y() - lhs.y() * rhs.x();
    }
 
    [[nodiscard]] constexpr friend vector2 cross(vector2 const& rhs) noexcept
    {
        return vector2{-rhs._v.y(), rhs._v.x()};
    }
 
    [[nodiscard]] constexpr friend float cross(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        auto const tmp1 = rhs._v.yxwz();
        auto const tmp2 = lhs._v * tmp1;
        auto const tmp3 = hsub(tmp2, tmp2);
        return tmp3.x();
    }
 
    [[nodiscard]] constexpr friend vector2 normal(vector2 const& rhs) noexcept
    {
        return normalize(cross(rhs));
    }
 
    [[nodiscard]] friend constexpr vector2 min(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        return vector2{min(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector2 max(vector2 const& lhs, vector2 const& rhs) noexcept
    {
        return vector2{max(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector2 round(vector2 const& rhs) noexcept
    {
        return vector2{round(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector2 ceil(vector2 const& rhs) noexcept
    {
        return vector2{ceil(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr vector2 floor(vector2 const& rhs) noexcept
    {
        return vector2{floor(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] constexpr bool holds_invariant() const noexcept
    {
        return _v.z() == 0.0f and _v.w() == 0.0f;
    }
 
    [[nodiscard]] friend std::string to_string(vector2 const& rhs) noexcept
    {
        return std::format("({}, {})", rhs._v.x(), rhs._v.y());
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, vector2 const& rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    array_type _v;
};
 
} // namespace v1
} // namespace hi::v1
 
// XXX #617 MSVC bug does not handle partial specialization in modules.
hi_export template<>
struct std::formatter<hi::vector2, char> : std::formatter<std::string, char> {
    auto format(hi::vector2 const& t, auto& fc) const
    {
        return std::formatter<std::string, char>::format(std::format("({}, {})", t.x(), t.y()), fc);
    }
};