point.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 "vector.hpp"
#include "extent.hpp"
#include "../SIMD/module.hpp"
#include "../utility/module.hpp"
#include <format>
 
namespace hi::inline v1 {
namespace geo {
 
template<typename T, int D>
class point {
public:
    using value_type = T;
    using array_type = simd<value_type, 4>;
 
    static_assert(D == 2 || D == 3, "Only 2D or 3D points are supported");
 
    constexpr point(point const&) noexcept = default;
    constexpr point(point&&) noexcept = default;
    constexpr point& operator=(point const&) noexcept = default;
    constexpr point& operator=(point&&) noexcept = default;
 
    template<int E>
        requires(E < D)
    [[nodiscard]] constexpr point(point<value_type, E> const& other) noexcept : _v(static_cast<array_type>(other))
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr point(point<value_type, 2> const& other, value_type z) noexcept
        requires(D == 3)
        : _v(static_cast<array_type>(other))
    {
        _v.z() = z;
        hi_axiom(holds_invariant());
    }
 
    template<int E>
        requires(E > D)
    [[nodiscard]] constexpr explicit point(point<value_type, E> const& other) noexcept : _v(static_cast<array_type>(other))
    {
        for (std::size_t i = D; i != E; ++i) {
            _v[i] = value_type{0};
        }
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr explicit operator array_type() const noexcept
    {
        hi_axiom(holds_invariant());
        return _v;
    }
 
    [[nodiscard]] constexpr explicit point(array_type const& other) noexcept : _v(other)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr point() noexcept : _v(value_type{0}, value_type{0}, value_type{0}, value_type{1}) {}
 
    [[nodiscard]] constexpr point(value_type x, value_type y) noexcept
        requires(D == 2)
        : _v(x, y, value_type{0}, value_type{1})
    {
    }
 
    [[nodiscard]] constexpr point(value_type x, value_type y, value_type z = value_type{0}) noexcept
        requires(D == 3)
        : _v(x, y, z, value_type{1})
    {
    }
 
    [[nodiscard]] constexpr value_type& x() noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr value_type& y() noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr value_type& z() noexcept
        requires(D == 3)
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr value_type x() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr value_type y() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr value_type z() const noexcept
        requires(D == 3)
    {
        return _v.z();
    }
 
    template<int E>
        requires(E <= D)
    constexpr point& operator+=(vector<value_type, E> const& rhs) noexcept
    {
        hi_axiom(holds_invariant() && rhs.holds_invariant());
        _v = _v + static_cast<array_type>(rhs);
        return *this;
    }
 
    template<int E>
        requires(E <= D)
    constexpr point& operator-=(vector<value_type, E> const& rhs) noexcept
    {
        hi_axiom(holds_invariant() && rhs.holds_invariant());
        _v = _v - static_cast<array_type>(rhs);
        return *this;
    }
 
    template<int E>
    [[nodiscard]] constexpr friend auto operator+(point const& lhs, vector<value_type, E> const& rhs) noexcept
    {
        hi_axiom(lhs.holds_invariant() && rhs.holds_invariant());
        return point<value_type, std::max(D, E)>{lhs._v + static_cast<array_type>(rhs)};
    }
 
    template<int E>
    [[nodiscard]] constexpr friend auto operator+(vector<value_type, E> const& rhs, point const& lhs) noexcept
    {
        hi_axiom(lhs.holds_invariant() && rhs.holds_invariant());
        return point<value_type, std::max(D, E)>{lhs._v + static_cast<array_type>(rhs)};
    }
 
    template<int E>
    [[nodiscard]] constexpr friend auto operator-(point const& lhs, vector<value_type, E> const& rhs) noexcept
    {
        hi_axiom(lhs.holds_invariant() && rhs.holds_invariant());
        return point<value_type, std::max(D, E)>{lhs._v - static_cast<array_type>(rhs)};
    }
 
    [[nodiscard]] constexpr friend vector<value_type, D> operator-(point const& lhs, point const& rhs) noexcept
    {
        hi_axiom(lhs.holds_invariant() && rhs.holds_invariant());
        return vector<value_type, D>{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(point const& lhs, point const& rhs) noexcept
    {
        hi_axiom(lhs.holds_invariant() && rhs.holds_invariant());
        return equal(lhs._v, rhs._v);
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto midpoint(point const& lhs, point<value_type, E> const& rhs) noexcept
    {
        return point<value_type, std::max(D, E)>{midpoint(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto reflect(point const& lhs, point<value_type, E> const& rhs) noexcept
    {
        return point<value_type, std::max(D, E)>{reflect_point(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto min(point const& lhs, point<value_type, E> const& rhs) noexcept
    {
        return point<value_type, std::max(D, E)>{min(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto max(point const& lhs, point<value_type, E> const& rhs) noexcept
    {
        return point<value_type, std::max(D, E)>{max(static_cast<array_type>(lhs), static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr point round(point const& rhs) noexcept
        requires std::is_same_v<value_type, float>
    {
        return point{round(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr point ceil(point const& rhs) noexcept
        requires std::is_same_v<value_type, float>
    {
        return point{ceil(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr point floor(point const& rhs) noexcept
        requires std::is_same_v<value_type, float>
    {
        return point{floor(static_cast<array_type>(rhs))};
    }
 
    [[nodiscard]] friend constexpr point ceil(point const& lhs, extent<value_type, D> rhs) noexcept
        requires std::is_same_v<value_type, float>
    {
        hilet rhs_ = array_type{rhs}.xy11();
        return point{ceil(array_type{lhs} / rhs_) * rhs_};
    }
 
    [[nodiscard]] friend constexpr point ceil(point const& lhs, extent<value_type, D> rhs) noexcept
        requires std::is_same_v<value_type, int>
    {
        hilet rhs_ = array_type{rhs}.xy11();
        hilet lhs_ = array_type{lhs};
        return point{(lhs_ + (rhs_ - 1)) / rhs_ * rhs_};
    }
 
    [[nodiscard]] friend constexpr point floor(point const& lhs, extent<value_type, D> rhs) noexcept
        requires std::is_same_v<value_type, float>
    {
        hilet rhs_ = array_type{rhs}.xy11();
        return point{floor(array_type{lhs} / rhs_) * rhs_};
    }
 
    [[nodiscard]] friend constexpr point floor(point const& lhs, extent<value_type, D> rhs) noexcept
        requires std::is_same_v<value_type, int>
    {
        hilet rhs_ = array_type{rhs}.xy11();
        hilet lhs_ = array_type{lhs};
        return point{lhs_ / rhs_ * rhs_};
    }
 
    [[nodiscard]] friend constexpr value_type distance(point const& lhs, point const& rhs) noexcept
    {
        return hypot(rhs - lhs);
    }
 
    [[nodiscard]] constexpr bool holds_invariant() const noexcept
    {
        return _v.w() != value_type{0} && (D == 3 || _v.z() == value_type{0});
    }
 
    [[nodiscard]] friend std::string to_string(point const& rhs) noexcept
    {
        if constexpr (D == 2) {
            return std::format("<{}, {}>", rhs._v.x(), rhs._v.y());
        } else if constexpr (D == 3) {
            return std::format("<{}, {}, {}>", rhs._v.x(), rhs._v.y(), rhs._v.z());
        } else {
            hi_static_no_default();
        }
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, point const& rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    array_type _v;
};
 
} // namespace geo
 
using point2 = geo::point<float, 2>;
using point3 = geo::point<float, 3>;
 
} // namespace hi::inline v1
 
template<typename CharT>
struct std::formatter<hi::geo::point<float, 2>, CharT> {
    auto parse(auto& pc)
    {
        return pc.end();
    }
 
    auto format(hi::geo::point<float, 2> const& t, auto& fc)
    {
        return std::vformat_to(fc.out(), "<{}, {}>", std::make_format_args(t.x(), t.y()));
    }
};
 
template<typename CharT>
struct std::formatter<hi::geo::point<float, 3>, CharT> {
    auto parse(auto& pc)
    {
        return pc.end();
    }
 
    auto format(hi::geo::point<float, 3> const& t, auto& fc)
    {
        return std::vformat_to(fc.out(), "<{}, {}, {}>", std::make_format_args(t.x(), t.y(), t.z()));
    }
};
 
template<typename CharT>
struct std::formatter<hi::geo::point<int, 2>, CharT> {
    auto parse(auto& pc)
    {
        return pc.end();
    }
 
    auto format(hi::geo::point<int, 2> const& t, auto& fc)
    {
        return std::vformat_to(fc.out(), "<{}, {}>", std::make_format_args(t.x(), t.y()));
    }
};
 
template<typename CharT>
struct std::formatter<hi::geo::point<int, 3>, CharT> {
    auto parse(auto& pc)
    {
        return pc.end();
    }
 
    auto format(hi::geo::point<int, 3> const& t, auto& fc)
    {
        return std::vformat_to(fc.out(), "<{}, {}, {}>", std::make_format_args(t.x(), t.y(), t.z()));
    }
};