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