aabb.hpp

 
#ifndef UFO_GEOMETRY_AABB_HPP
#define UFO_GEOMETRY_AABB_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 AABB {
    using value_type = T;
 
    Vec<Dim, T> min;
 
    Vec<Dim, T> max;
 
    constexpr AABB() noexcept = default;
 
    constexpr AABB(Vec<Dim, T> const& min, Vec<Dim, T> const& max) noexcept
        : min(min), max(max)
    {
    }
 
    constexpr AABB(Vec<Dim, T> const& center, T half_length) noexcept
        : min(center - half_length), max(center + half_length)
    {
    }
 
    constexpr AABB(AABB const&) noexcept = default;
 
    template <std::convertible_to<T> U>
    constexpr explicit AABB(AABB<Dim, U> const& other) noexcept
        : min(other.min), max(other.max)
    {
    }
 
    [[nodiscard]] static constexpr std::size_t dimension() noexcept { return Dim; }
 
    [[nodiscard]] constexpr Vec<Dim, T> center() const noexcept
    {
        return min + halfLength();
    }
 
    [[nodiscard]] constexpr Vec<Dim, T> length() const noexcept { return max - min; }
 
    [[nodiscard]] constexpr Vec<Dim, T> halfLength() const noexcept
    {
        return length() * T(0.5);
    }
 
    [[nodiscard]] constexpr T diagonal() const noexcept { return ufo::length(length()); }
 
    [[nodiscard]] constexpr T volume() const noexcept
    {
        auto l = length();
        T    v = l[0];
        for (std::size_t i = 1; i < Dim; ++i) {
            v *= l[i];
        }
        return v;
    }
 
    [[nodiscard]] constexpr AABB aabb() const noexcept { return *this; }
 
    [[nodiscard]] constexpr bool isDegenerate() const noexcept
    {
        return any(greaterThan(min, max));
    }
 
    [[nodiscard]] bool operator==(AABB const&) const = default;
};
 
//
// Deduction guides
//
 
template <std::size_t Dim, std::floating_point T>
AABB(Vec<Dim, T>, Vec<Dim, T>) -> AABB<Dim, T>;
 
template <std::size_t Dim, std::floating_point T>
AABB(Vec<Dim, T>, T) -> AABB<Dim, T>;
 
template <std::size_t Dim, std::floating_point T>
std::ostream& operator<<(std::ostream& out, AABB<Dim, T> const& aabb)
{
    return out << "Min: [" << aabb.min << "], Max: [" << aabb.max << "]";
}
 
template <std::floating_point T>
using AABB1 = AABB<1, T>;
template <std::floating_point T>
using AABB2 = AABB<2, T>;
template <std::floating_point T>
using AABB3 = AABB<3, T>;
template <std::floating_point T>
using AABB4 = AABB<4, T>;
 
using AABB1f = AABB<1, float>;
using AABB2f = AABB<2, float>;
using AABB3f = AABB<3, float>;
using AABB4f = AABB<4, float>;
 
using AABB1d = AABB<1, double>;
using AABB2d = AABB<2, double>;
using AABB3d = AABB<3, double>;
using AABB4d = AABB<4, double>;
 
}  // namespace ufo
 
template <std::size_t Dim, std::floating_point T>
  requires std::formattable<T, char>
struct std::formatter<ufo::AABB<Dim, T>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::AABB<Dim, T> const& aabb, std::format_context& ctx) const
    {
        return std::format_to(ctx.out(), "Min: [{}], Max: [{}]", aabb.min, aabb.max);
    }
};
 
#endif  // UFO_GEOMETRY_AABB_HPP