BoundingBox.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_BOUNDING_BOX_HPP
#define CUBBYFLOW_BOUNDING_BOX_HPP
 
#include <Core/Geometry/Ray.hpp>
#include <Core/Matrix/Matrix.hpp>
 
#include <limits>
 
namespace CubbyFlow
{
template <typename T>
struct BoundingBoxRayIntersection
{
    bool isIntersecting = false;
 
    T near = std::numeric_limits<T>::max();
 
    T far = std::numeric_limits<T>::max();
};
 
template <typename T, size_t N>
class BoundingBox
{
 public:
    static_assert(N > 0, "Dimension should be greater than 0");
    static_assert(
        std::is_floating_point<T>::value,
        "BoundingBox only can be instantiated with floating point types");
 
    using VectorType = Vector<T, N>;
    using RayType = Ray<T, N>;
 
    BoundingBox();
 
    BoundingBox(const VectorType& point1, const VectorType& point2);
 
    ~BoundingBox() = default;
 
    BoundingBox(const BoundingBox& other);
 
    BoundingBox(BoundingBox&& other) noexcept;
 
    BoundingBox& operator=(const BoundingBox& other);
 
    BoundingBox& operator=(BoundingBox&& other) noexcept;
 
    [[nodiscard]] T Width() const;
 
    template <typename U = T>
    [[nodiscard]] std::enable_if_t<(N > 1), U> Height() const;
 
    template <typename U = T>
    [[nodiscard]] std::enable_if_t<(N > 2), U> Depth() const;
 
    [[nodiscard]] T Length(size_t axis);
 
    [[nodiscard]] bool Overlaps(const BoundingBox& other) const;
 
    [[nodiscard]] bool Contains(const VectorType& point) const;
 
    [[nodiscard]] bool Intersects(const RayType& ray) const;
 
    [[nodiscard]] BoundingBoxRayIntersection<T> ClosestIntersection(
        const RayType& ray) const;
 
    [[nodiscard]] VectorType MidPoint() const;
 
    [[nodiscard]] T DiagonalLength() const;
 
    [[nodiscard]] T DiagonalLengthSquared() const;
 
    void Reset();
 
    void Merge(const VectorType& point);
 
    void Merge(const BoundingBox& other);
 
    void Expand(T delta);
 
    [[nodiscard]] VectorType Corner(size_t idx) const;
 
    [[nodiscard]] VectorType Clamp(const VectorType& point) const;
 
    [[nodiscard]] bool IsEmpty() const;
 
    template <typename U>
    [[nodiscard]] BoundingBox<U, N> CastTo() const;
 
    VectorType lowerCorner;
 
    VectorType upperCorner;
};
 
template <typename T>
using BoundingBox2 = BoundingBox<T, 2>;
 
template <typename T>
using BoundingBox3 = BoundingBox<T, 3>;
 
using BoundingBox2F = BoundingBox2<float>;
 
using BoundingBox2D = BoundingBox2<double>;
 
using BoundingBox3F = BoundingBox3<float>;
 
using BoundingBox3D = BoundingBox3<double>;
 
using BoundingBoxRayIntersectionF = BoundingBoxRayIntersection<float>;
 
using BoundingBoxRayIntersectionD = BoundingBoxRayIntersection<double>;
}  // namespace CubbyFlow
 
#include <Core/Geometry/BoundingBox-Impl.hpp>
 
#endif