Collider.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_COLLIDER_HPP
#define CUBBYFLOW_COLLIDER_HPP

#include <Core/Geometry/Surface.hpp>

#include <functional>

namespace CubbyFlow
{
template <size_t N>
class Collider
{
 public:
    using OnBeginUpdateCallback =
        std::function<void(Collider*, double, double)>;

    Collider() = default;

    virtual ~Collider() = default;

    Collider(const Collider& other) = default;

    Collider(Collider&& other) noexcept = default;

    Collider& operator=(const Collider& other) = default;

    Collider& operator=(Collider&& other) noexcept = default;

    [[nodiscard]] virtual Vector<double, N> VelocityAt(
        const Vector<double, N>& point) const = 0;

    void ResolveCollision(double radius, double restitutionCoefficient,
                          Vector<double, N>* position,
                          Vector<double, N>* velocity);

    [[nodiscard]] double GetFrictionCoefficient() const;

    void SetFrictionCoefficient(double newFrictionCoefficient);

    [[nodiscard]] const std::shared_ptr<Surface<N>>& GetSurface() const;

    void Update(double currentTimeInSeconds, double timeIntervalInSeconds);

    void SetOnBeginUpdateCallback(const OnBeginUpdateCallback& callback);

 protected:
    struct ColliderQueryResult final
    {
        double distance = 0.0;
        Vector<double, N> point;
        Vector<double, N> normal;
        Vector<double, N> velocity;
    };

    void SetSurface(const std::shared_ptr<Surface<N>>& newSurface);

    void GetClosestPoint(const std::shared_ptr<Surface<N>>& surface,
                         const Vector<double, N>& queryPoint,
                         ColliderQueryResult* result) const;

    [[nodiscard]] bool IsPenetrating(const ColliderQueryResult& colliderPoint,
                                     const Vector<double, N>& position,
                                     double radius);

 private:
    std::shared_ptr<Surface<N>> m_surface;
    double m_frictionCoefficient = 0.0;
    OnBeginUpdateCallback m_onUpdateCallback;
};

using Collider2 = Collider<2>;

using Collider3 = Collider<3>;

using Collider2Ptr = std::shared_ptr<Collider2>;

using Collider3Ptr = std::shared_ptr<Collider3>;
}  // namespace CubbyFlow

#endif