point.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 "../rapid/numeric_array.hpp"
#include "vector.hpp"
#include <format>
 
namespace tt {
namespace geo {
 
template<int D>
class point {
public:
    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<E> const &other) noexcept : _v(static_cast<f32x4>(other))
    {
        tt_axiom(is_valid());
    }
 
    template<int E>
    requires(E > D) [[nodiscard]] constexpr explicit point(point<E> const &other) noexcept : _v(static_cast<f32x4>(other))
    {
        for (size_t i = D; i != E; ++i) {
            _v[i] = 0.0f;
        }
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] constexpr explicit operator f32x4() const noexcept
    {
        tt_axiom(is_valid());
        return _v;
    }
 
    [[nodiscard]] constexpr explicit point(f32x4 const &other) noexcept : _v(other)
    {
        tt_axiom(is_valid());
    }
 
    [[nodiscard]] constexpr point() noexcept : _v(0.0, 0.0, 0.0, 1.0) {}
 
    [[nodiscard]] constexpr point(float x, float y) noexcept requires(D == 2) : _v(x, y, 0.0, 1.0) {}
 
    [[nodiscard]] constexpr point(float x, float y, float z = 0.0) noexcept requires(D == 3) : _v(x, y, z, 1.0) {}
 
    [[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();
    }
 
    template<int E>
    requires(E <= D) constexpr point &operator+=(vector<E> const &rhs) noexcept
    {
        tt_axiom(is_valid() && rhs.is_valid());
        _v = _v + static_cast<f32x4>(rhs);
        return *this;
    }
 
    template<int E>
    [[nodiscard]] constexpr friend point<std::max(D, E)> operator+(point const &lhs, vector<E> const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return point<std::max(D, E)>{lhs._v + static_cast<f32x4>(rhs)};
    }
 
    template<int E>
    [[nodiscard]] constexpr friend point<std::max(D, E)> operator+(vector<E> const &rhs, point const &lhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return point<std::max(D, E)>{lhs._v + static_cast<f32x4>(rhs)};
    }
 
    template<int E>
    [[nodiscard]] constexpr friend point<std::max(D, E)> operator-(point const &lhs, vector<E> const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return point<std::max(D, E)>{lhs._v - static_cast<f32x4>(rhs)};
    }
 
    [[nodiscard]] constexpr friend vector<D> operator-(point const &lhs, point const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return vector<D>{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(point const &lhs, point const &rhs) noexcept
    {
        tt_axiom(lhs.is_valid() && rhs.is_valid());
        return lhs._v == rhs._v;
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto midpoint(point const &lhs, point<E> const &rhs) noexcept
    {
        return point<std::max(D, E)>{midpoint(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs))};
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto reflect(point const &lhs, point<E> const &rhs) noexcept
    {
        return point<std::max(D, E)>{reflect_point(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs))};
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto min(point const &lhs, point<E> const &rhs) noexcept
    {
        return point<std::max(D, E)>{min(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs))};
    }
 
    template<int E>
    [[nodiscard]] friend constexpr auto max(point const &lhs, point<E> const &rhs) noexcept
    {
        return point<std::max(D, E)>{max(static_cast<f32x4>(lhs), static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] friend constexpr point round(point const &rhs) noexcept
    {
        return point{round(static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] friend constexpr point ceil(point const &rhs) noexcept
    {
        return point{ceil(static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] friend constexpr point floor(point const &rhs) noexcept
    {
        return point{floor(static_cast<f32x4>(rhs))};
    }
 
    [[nodiscard]] constexpr bool is_valid() const noexcept
    {
        return _v.w() != 0.0f && (D == 3 || _v.z() == 0.0f);
    }
 
    [[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 {
            tt_static_no_default();
        }
    }
 
    friend std::ostream &operator<<(std::ostream &lhs, point const &rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    f32x4 _v;
};
 
} // namespace geo
 
using point2 = geo::point<2>;
using point3 = geo::point<3>;
 
} // namespace tt
 
namespace std {
 
template<typename CharT>
struct formatter<tt::geo::point<2>, CharT>  {
    auto parse(auto &pc)
    {
        return pc.end();
    }
 
    auto format(tt::geo::point<2> const &t, auto &fc)
    {
        return std::vformat_to(fc.out(), "<{}, {}>", std::make_format_args(t.x(), t.y()));
    }
};
 
template<typename CharT>
struct formatter<tt::geo::point<3>, CharT> : formatter<float, CharT> {
    auto parse(auto &pc)
    {
        return pc.end();
    }
 
    auto format(tt::geo::point<3> const &t, auto &fc)
    {
        return std::vformat_to(fc.out(), "<{}, {}, {}>", std::make_format_args(t.x(), t.y(), t.z()));
    }
};
 
} // namespace std