plane.hpp

 
#ifndef UFO_GEOMETRY_PLANE_HPP
#define UFO_GEOMETRY_PLANE_HPP
 
// UFO
#include <ufo/numeric/vec.hpp>
 
// STL
#include <concepts>
#include <cstddef>
#include <limits>
#include <ostream>
 
#include "ufo/geometry/aabb.hpp"
 
namespace ufo
{
template <std::size_t Dim = 3, std::floating_point T = float>
struct Plane {
    using value_type = T;
 
    Vec<Dim, T> normal;
 
    T distance{};
 
    constexpr Plane() noexcept = default;
 
    constexpr Plane(Plane const&) noexcept = default;
 
    constexpr explicit Plane(Vec<Dim, T> const& normal) noexcept : normal(normal) {}
 
    constexpr Plane(Vec<Dim, T> const& normal, T distance) noexcept
        : normal(normal), distance(distance)
    {
    }
 
    constexpr Plane(Vec<Dim, T> const& v_1, Vec<Dim, T> const& v_2) noexcept
      requires(2 == Dim)
    {
        auto aux = v_2 - v_1;
        normal   = normalize(Vec<2, T>(-aux.y(), aux.x()));
        distance = dot(normal, v_1);
    }
 
    constexpr Plane(Vec<Dim, T> const& v_1, Vec<Dim, T> const& v_2,
                    Vec<Dim, T> const& v_3) noexcept
      requires(3 == Dim)
    {
        auto aux_1 = v_1 - v_2;
        auto aux_2 = v_3 - v_2;
        normal     = normalize(cross(aux_2, aux_1));
        distance   = dot(normal, v_2);
    }
 
    template <std::convertible_to<T> U>
    constexpr explicit Plane(Plane<Dim, U> const& other) noexcept
        : normal(Vec<Dim, T>(other.normal)), distance(static_cast<T>(other.distance))
    {
    }
 
    [[nodiscard]] static constexpr std::size_t dimension() noexcept { return Dim; }
 
    [[nodiscard]] bool operator==(Plane const&) const = default;
 
    [[nodiscard]] constexpr bool isDegenerate() const noexcept
    {
        return dot(normal, normal) < std::numeric_limits<T>::epsilon();
    }
 
    [[nodiscard]] constexpr T volume() const noexcept { return T(0); }
 
    [[nodiscard]] constexpr T diameter() const noexcept
    {
        return std::numeric_limits<T>::infinity();
    }
 
    [[nodiscard]] constexpr AABB<Dim, T> aabb() const noexcept
    {
        // A plane is infinite
        return AABB<Dim, T>(Vec<Dim, T>(-std::numeric_limits<T>::infinity()),
                            Vec<Dim, T>(std::numeric_limits<T>::infinity()));
    }
};
 
template <std::size_t Dim, std::floating_point T>
std::ostream& operator<<(std::ostream& out, Plane<Dim, T> const& plane)
{
    return out << "Normal: [" << plane.normal << "], Distance: " << plane.distance;
}
 
using Plane3f = Plane<3, float>;
using Plane3d = Plane<3, double>;
 
}  // namespace ufo
 
template <std::size_t Dim, std::floating_point T>
  requires std::formattable<T, char>
struct std::formatter<ufo::Plane<Dim, T>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Plane<Dim, T> const& plane, std::format_context& ctx) const
    {
        return std::format_to(ctx.out(), "Normal: [{}], Distance: {}", plane.normal,
                              plane.distance);
    }
};
 
#endif  // UFO_GEOMETRY_PLANE_HPP