shapes.hpp

Go to the documentation of this file.

#ifndef DONUT_SHAPES_HPP
#define DONUT_SHAPES_HPP
 
#include <donut/math.hpp>
 
namespace donut {
 
template <length_t L, typename T>
using Point = vec<L, T>;
 
template <length_t L, typename T>
using Length = vec<L, T>;
 
template <length_t L, typename T>
struct LineSegment {
    Point<L, T> pointA; 
    Point<L, T> pointB; 
};
 
template <length_t L, typename T>
struct Sphere {
    Point<L, T> center; 
    T radius;           
 
    [[nodiscard]] constexpr bool contains(const Point<L, T>& point) const noexcept;
};
 
template <typename T>
struct Circle {
    Point<2, T> center; 
    T radius;           
 
    constexpr operator Sphere<2, T>() const noexcept {
        return Sphere<2, T>{.center = center, .radius = radius};
    }
 
    [[nodiscard]] constexpr bool contains(const Point<2, T>& point) const noexcept;
};
 
template <length_t L, typename T>
struct Capsule {
    LineSegment<L, T> centerLine; 
    T radius;                     
 
    [[nodiscard]] constexpr bool contains(const Point<L, T>& point) const noexcept;
};
 
template <length_t L, typename T>
struct Box {
    Point<L, T> min; 
    Point<L, T> max; 
 
    [[nodiscard]] constexpr bool contains(const Point<L, T>& point) const noexcept;
};
 
template <typename T>
struct Rectangle {
    Point<2, T> position; 
    Length<2, T> size;    
 
    constexpr operator Box<2, T>() const noexcept {
        return Box<2, T>{.min = position, .max = position + size};
    }
 
    [[nodiscard]] constexpr bool contains(const Point<2, T>& point) const noexcept;
};
 
template <length_t L, typename T>
[[nodiscard]] constexpr Box<L, T> getAabbOf(const LineSegment<L, T>& line) noexcept {
    return {
        .min = min(line.pointA, line.pointB),
        .max = max(line.pointA, line.pointB),
    };
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr Box<L, T> getAabbOf(const Sphere<L, T>& sphere) noexcept {
    return {
        .min = sphere.center - Length<L, T>{sphere.radius},
        .max = sphere.center + Length<L, T>{sphere.radius},
    };
}
 
template <typename T>
[[nodiscard]] constexpr Box<2, T> getAabbOf(const Circle<T>& circle) noexcept {
    return {
        .min = circle.center - Length<2, T>{circle.radius},
        .max = circle.center + Length<2, T>{circle.radius},
    };
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr Box<L, T> getAabbOf(const Capsule<L, T>& capsule) noexcept {
    return {
        .min = min(capsule.centerLine.pointA, capsule.centerLine.pointB) - Length<L, T>{capsule.radius},
        .max = max(capsule.centerLine.pointA, capsule.centerLine.pointB) + Length<L, T>{capsule.radius},
    };
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr Box<L, T> getAabbOf(const Box<L, T>& box) noexcept {
    return box;
}
 
template <typename T>
[[nodiscard]] constexpr Box<2, T> getAabbOf(const Rectangle<T>& rectangle) noexcept {
    return static_cast<Box<2, T>>(rectangle);
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const Sphere<L, T>& a, const Sphere<L, T>& b) noexcept {
    return distance2(a.center, b.center) < length2(a.radius + b.radius);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Circle<T>& a, const Circle<T>& b) noexcept {
    return intersects(static_cast<Sphere<2, T>>(a), static_cast<Sphere<2, T>>(b));
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const Box<L, T>& a, const Box<L, T>& b) noexcept {
    for (length_t i = 0; i < L; ++i) {
        if (a.min[i] >= b.max[i] || a.max[i] <= b.min[i]) {
            return false;
        }
    }
    return true;
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Rectangle<T>& a, const Rectangle<T>& b) noexcept {
    return intersects(static_cast<Box<2, T>>(a), static_cast<Box<2, T>>(b));
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Circle<T>& a, const Sphere<2, T>& b) noexcept {
    return intersects(static_cast<Sphere<2, T>>(a), b);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Sphere<2, T>& a, const Circle<T>& b) noexcept {
    return intersects(b, a);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Rectangle<T>& a, const Box<2, T>& b) noexcept {
    return intersects(static_cast<Box<2, T>>(a), b);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Box<2, T>& a, const Rectangle<T>& b) noexcept {
    return intersects(b, a);
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const Sphere<L, T>& a, const Box<L, T>& b) noexcept {
    return distance2(a.center, clamp(a.center, b.min, b.max)) < length2(a.radius);
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const Box<L, T>& a, const Sphere<L, T>& b) noexcept {
    return intersects(b, a);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Circle<T>& a, const Box<2, T>& b) noexcept {
    return intersects(static_cast<Sphere<2, T>>(a), b);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Box<2, T>& a, const Circle<T>& b) noexcept {
    return intersects(b, a);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Sphere<2, T>& a, const Rectangle<T>& b) noexcept {
    return intersects(a, static_cast<Box<2, T>>(b));
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Rectangle<T>& a, const Sphere<2, T>& b) noexcept {
    return intersects(b, a);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Circle<T>& a, const Rectangle<T>& b) noexcept {
    return intersects(static_cast<Sphere<2, T>>(a), static_cast<Box<2, T>>(b));
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Rectangle<T>& a, const Circle<T>& b) noexcept {
    return intersects(b, a);
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const Sphere<L, T>& a, const Capsule<L, T>& b) noexcept {
    const T combinedRadiusSquared = length2(a.radius + b.radius);
    const vec<L, T> linePointAToPointB = b.centerLine.pointB - b.centerLine.pointA;
    const vec<L, T> linePointAToSphereCenter = a.center - b.centerLine.pointA;
    const T linePointAToSphereCenterAlongLine = dot(linePointAToSphereCenter, linePointAToPointB);
    if (linePointAToSphereCenterAlongLine <= 0.0f) {
        return length2(linePointAToSphereCenter) < combinedRadiusSquared;
    }
    const vec<L, T> linePointBToSphereCenter = a.center - b.centerLine.pointB;
    const T linePointBToSphereCenterAlongLine = dot(linePointBToSphereCenter, linePointAToPointB);
    if (linePointBToSphereCenterAlongLine >= 0.0f) {
        return length2(linePointBToSphereCenter) < combinedRadiusSquared;
    }
    const vec<L, T> lineToSphereCenterOrthogonal = linePointAToSphereCenter - linePointAToPointB * (linePointAToSphereCenterAlongLine / length2(linePointAToPointB));
    return length2(lineToSphereCenterOrthogonal) < combinedRadiusSquared;
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const Capsule<L, T>& a, const Sphere<L, T>& b) noexcept {
    return intersects(b, a);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Circle<T>& a, const Capsule<2, T>& b) noexcept {
    return intersects(static_cast<Sphere<2, T>>(a), b);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Capsule<2, T>& a, const Circle<T>& b) noexcept {
    return intersects(b, a);
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const Sphere<L, T>& a, const LineSegment<L, T>& b) noexcept {
    return intersects(a, Capsule<L, T>{.centerLine = b, .radius = T{0}});
}
 
template <length_t L, typename T>
[[nodiscard]] constexpr bool intersects(const LineSegment<L, T>& a, const Sphere<L, T>& b) noexcept {
    return intersects(b, a);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const Circle<T>& a, const LineSegment<2, T>& b) noexcept {
    return intersects(static_cast<Sphere<2, T>>(a), b);
}
 
template <typename T>
[[nodiscard]] constexpr bool intersects(const LineSegment<2, T>& a, const Circle<T>& b) noexcept {
    return intersects(b, a);
}
 
template <length_t L, typename T>
constexpr bool Sphere<L, T>::contains(const Point<L, T>& point) const noexcept {
    return distance2(center, point) < length2(radius);
}
 
template <typename T>
constexpr bool Circle<T>::contains(const Point<2, T>& point) const noexcept {
    return static_cast<Sphere<2, T>>(*this).contains(point);
}
 
template <length_t L, typename T>
constexpr bool Capsule<L, T>::contains(const Point<L, T>& point) const noexcept {
    return intersects(*this, Sphere<L, T>{.center = point, .radius = T{0}});
}
 
template <length_t L, typename T>
constexpr bool Box<L, T>::contains(const Point<L, T>& point) const noexcept {
    for (length_t i = 0; i < L; ++i) {
        if (point[i] < min[i] || point[i] >= max[i]) {
            return false;
        }
    }
    return true;
}
 
template <typename T>
constexpr bool Rectangle<T>::contains(const Point<2, T>& point) const noexcept {
    return static_cast<Box<2, T>>(*this).contains(point);
}
 
} // namespace donut
 
#endif