triangle.hpp

 
#ifndef UFO_GEOMETRY_TRIANGLE_HPP
#define UFO_GEOMETRY_TRIANGLE_HPP
 
// UFO
#include <ufo/geometry/aabb.hpp>
#include <ufo/numeric/vec.hpp>
 
// STL
#include <algorithm>
#include <array>
#include <cmath>
#include <concepts>
#include <cstddef>
#include <format>
#include <limits>
#include <ostream>
 
namespace ufo
{
template <std::size_t Dim = 3, std::floating_point T = float>
struct Triangle {
    using value_type = T;
 
    std::array<Vec<Dim, T>, 3> points;
 
    constexpr Triangle() noexcept = default;
 
    constexpr Triangle(Triangle const&) noexcept = default;
 
    constexpr Triangle(Vec<Dim, T> point_1, Vec<Dim, T> point_2,
                       Vec<Dim, T> point_3) noexcept
        : points{point_1, point_2, point_3}
    {
    }
 
    template <std::convertible_to<T> U>
    constexpr explicit Triangle(Triangle<Dim, U> const& other) noexcept
        : points{Vec<Dim, T>(other[0]), Vec<Dim, T>(other[1]), Vec<Dim, T>(other[2])}
    {
    }
 
    [[nodiscard]] static constexpr std::size_t dimension() noexcept { return Dim; }
 
    [[nodiscard]] constexpr auto& operator[](this auto& self, std::size_t pos) noexcept
    {
        return self.points[pos];
    }
 
    [[nodiscard]] constexpr Vec<Dim, T> center() const noexcept
    {
        return (points[0] + points[1] + points[2]) / T(3);
    }
 
    [[nodiscard]] constexpr T area() const noexcept
    {
        Vec<Dim, T> v1  = points[1] - points[0];
        Vec<Dim, T> v2  = points[2] - points[0];
        T           d1  = dot(v1, v1);
        T           d2  = dot(v2, v2);
        T           d12 = dot(v1, v2);
        return T(0.5) * std::sqrt(std::max(T(0), d1 * d2 - d12 * d12));
    }
 
    [[nodiscard]] constexpr AABB<Dim, T> aabb() const noexcept
    {
        return AABB<Dim, T>(ufo::min(points[0], ufo::min(points[1], points[2])),
                            ufo::max(points[0], ufo::max(points[1], points[2])));
    }
 
    [[nodiscard]] constexpr Vec<3, T> normal() const noexcept
      requires(3 == Dim)
    {
        return normalize(cross(points[1] - points[0], points[2] - points[0]));
    }
 
    [[nodiscard]] constexpr bool isDegenerate(
        T eps = std::numeric_limits<T>::epsilon()) const noexcept
    {
        return area() <= eps;
    }
 
    [[nodiscard]] constexpr T volume() const noexcept { return T(0); }
 
    [[nodiscard]] constexpr T diameter() const noexcept
    {
        return std::sqrt(
            std::max({normSquared(points[1] - points[0]), normSquared(points[2] - points[1]),
                      normSquared(points[0] - points[2])}));
    }
 
    [[nodiscard]] bool operator==(Triangle const&) const = default;
};
 
//
// Deduction guides
//
 
template <std::size_t Dim, std::floating_point T>
Triangle(Vec<Dim, T>, Vec<Dim, T>, Vec<Dim, T>) -> Triangle<Dim, T>;
 
template <std::size_t Dim, std::floating_point T>
std::ostream& operator<<(std::ostream& out, Triangle<Dim, T> const& triangle)
{
    return out << "Point 1: [" << triangle[0] << "], Point 2: [" << triangle[1]
               << "], Point 3: [" << triangle[2] << "]";
}
 
template <std::floating_point T>
using Triangle1 = Triangle<1, T>;
template <std::floating_point T>
using Triangle2 = Triangle<2, T>;
template <std::floating_point T>
using Triangle3 = Triangle<3, T>;
template <std::floating_point T>
using Triangle4 = Triangle<4, T>;
 
using Triangle1f = Triangle<1, float>;
using Triangle2f = Triangle<2, float>;
using Triangle3f = Triangle<3, float>;
using Triangle4f = Triangle<4, float>;
 
using Triangle1d = Triangle<1, double>;
using Triangle2d = Triangle<2, double>;
using Triangle3d = Triangle<3, double>;
using Triangle4d = Triangle<4, double>;
 
}  // namespace ufo
 
template <std::size_t Dim, std::floating_point T>
  requires std::formattable<T, char>
struct std::formatter<ufo::Triangle<Dim, T>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Triangle<Dim, T> const& triangle, std::format_context& ctx) const
    {
        return std::format_to(ctx.out(), "Points: [{}], [{}], [{}]", triangle[0], triangle[1],
                              triangle[2]);
    }
};
 
#endif  // UFO_GEOMETRY_TRIANGLE_HPP