ray.hpp

 
#ifndef UFO_GEOMETRY_RAY_HPP
#define UFO_GEOMETRY_RAY_HPP
 
// UFO
#include <ufo/geometry/aabb.hpp>
#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 Ray {
    using value_type = T;
 
    Vec<Dim, T> origin;
 
    Vec<Dim, T> direction;
 
    constexpr Ray() noexcept = default;
 
    constexpr Ray(Ray const&) noexcept = default;
 
    constexpr Ray(Vec<Dim, T> origin, Vec<Dim, T> direction) noexcept
        : origin(origin), direction(direction)
    {
    }
 
    template <std::convertible_to<T> U>
    constexpr explicit Ray(Ray<Dim, U> const& other) noexcept
        : origin(other.origin), direction(other.direction)
    {
    }
 
    [[nodiscard]] static constexpr std::size_t dimension() noexcept { return Dim; }
 
    [[nodiscard]] constexpr Vec<Dim, T> at(T t) const { return origin + t * direction; }
 
    [[nodiscard]] bool operator==(Ray const&) const = default;
 
    [[nodiscard]] constexpr bool isDegenerate() const noexcept
    {
        return dot(direction, direction) < 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
    {
        Vec<Dim, T> min = origin;
        Vec<Dim, T> max = origin;
        for (std::size_t i = 0; i < Dim; ++i) {
            if (direction[i] > T(0)) {
                max[i] = std::numeric_limits<T>::infinity();
            } else if (direction[i] < T(0)) {
                min[i] = -std::numeric_limits<T>::infinity();
            }
        }
        return AABB<Dim, T>(min, max);
    }
};
 
//
// Deduction guides
//
 
template <std::size_t Dim, std::floating_point T>
Ray(Vec<Dim, T>, Vec<Dim, T>) -> Ray<Dim, T>;
 
template <std::size_t Dim, std::floating_point T>
std::ostream& operator<<(std::ostream& out, Ray<Dim, T> const& ray)
{
    return out << "Origin: [" << ray.origin << "], Direction: [" << ray.direction << "]";
}
 
template <std::floating_point T>
using Ray1 = Ray<1, T>;
template <std::floating_point T>
using Ray2 = Ray<2, T>;
template <std::floating_point T>
using Ray3 = Ray<3, T>;
template <std::floating_point T>
using Ray4 = Ray<4, T>;
 
using Ray1f = Ray<1, float>;
using Ray2f = Ray<2, float>;
using Ray3f = Ray<3, float>;
using Ray4f = Ray<4, float>;
 
using Ray1d = Ray<1, double>;
using Ray2d = Ray<2, double>;
using Ray3d = Ray<3, double>;
using Ray4d = Ray<4, double>;
 
}  // namespace ufo
 
template <std::size_t Dim, std::floating_point T>
  requires std::formattable<T, char>
struct std::formatter<ufo::Ray<Dim, T>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Ray<Dim, T> const& ray, std::format_context& ctx) const
    {
        return std::format_to(ctx.out(), "Origin: [{}], Direction: [{}]", ray.origin,
                              ray.direction);
    }
};
 
#endif  // UFO_GEOMETRY_RAY_HPP