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