normal.hpp

 
#ifndef UFO_CORE_NORMAL_HPP
#define UFO_CORE_NORMAL_HPP
 
// UFO
#include <ufo/numeric/vec.hpp>
 
// STL
#include <concepts>
#include <cstddef>
#include <format>
#include <ostream>
 
namespace ufo
{
template <std::size_t Dim = 3, std::floating_point T = float>
struct Normal : Vec<Dim, T> {
    constexpr Normal() noexcept = default;
 
    constexpr Normal(Vec<Dim, T> const& normal) noexcept : Vec<Dim, T>(normal) {}
 
    template <std::convertible_to<T>... Args>
      requires(sizeof...(Args) == Dim)
    constexpr Normal(Args... args) noexcept : Vec<Dim, T>{static_cast<T>(args)...}
    {
    }
};
 
using Normal2f = Normal<2>;
using Normal3f = Normal<3>;
using Normal4f = Normal<4>;
using Normal2d = Normal<2, double>;
using Normal3d = Normal<3, double>;
using Normal4d = Normal<4, double>;
 
}  // namespace ufo
 
template <std::size_t Dim, std::formattable<char> T>
struct std::formatter<ufo::Normal<Dim, T>> : std::formatter<ufo::Vec<Dim, T>> {
    auto format(ufo::Normal<Dim, T> const& n, std::format_context& ctx) const
    {
        // Explicitly qualify to avoid unqualified lookup resolving back to this
        // overload via the Normal(Vec const&) converting constructor.
        return std::formatter<ufo::Vec<Dim, T>>::format(n, ctx);
    }
};
 
namespace ufo
{
template <std::size_t Dim, class T>
std::ostream& operator<<(std::ostream& out, Normal<Dim, T> const& n)
{
    return out << std::format("{}", n);
}
}  // namespace ufo
 
#endif  // UFO_CORE_NORMAL_HPP