RigidBodyCollider.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_RIGID_BODY_COLLIDER_HPP
#define CUBBYFLOW_RIGID_BODY_COLLIDER_HPP
 
#include <Core/Geometry/Collider.hpp>
 
#include <utility>
 
namespace CubbyFlow
{
template <size_t N>
class AngularVelocity
{
    // Do nothing
};
 
template <>
class AngularVelocity<2>
{
 public:
    AngularVelocity() = default;
 
    AngularVelocity(double _value) : value(_value)
    {
        // Do nothing
    }
 
    [[nodiscard]] Vector2D Cross(const Vector2D& r) const
    {
        return value * Vector2D{ -r.y, r.x };
    }
 
    double value = 0.0;
};
 
template <>
class AngularVelocity<3>
{
 public:
    AngularVelocity() = default;
 
    AngularVelocity(std::initializer_list<double> lst) : value(lst)
    {
        // Do nothing
    }
 
    AngularVelocity(Vector3D _value) : value(std::move(_value))
    {
        // Do nothing
    }
 
    [[nodiscard]] Vector3D Cross(const Vector3D& r) const
    {
        return value.Cross(r);
    }
 
    Vector3D value;
};
 
using AngularVelocity2 = AngularVelocity<2>;
 
using AngularVelocity3 = AngularVelocity<3>;
 
template <size_t N>
class RigidBodyCollider final : public Collider<N>
{
 public:
    class Builder;
 
    using Collider<N>::GetSurface;
    using Collider<N>::SetSurface;
 
    explicit RigidBodyCollider(const std::shared_ptr<Surface<N>>& surface);
 
    RigidBodyCollider(const std::shared_ptr<Surface<N>>& surface,
                      const Vector<double, N>& _linearVelocity,
                      const AngularVelocity<N>& _angularVelocity);
 
    [[nodiscard]] Vector<double, N> VelocityAt(
        const Vector<double, N>& point) const override;
 
    static Builder GetBuilder();
 
    Vector<double, N> linearVelocity;
 
    AngularVelocity<N> angularVelocity;
};
 
using RigidBodyCollider2 = RigidBodyCollider<2>;
 
using RigidBodyCollider3 = RigidBodyCollider<3>;
 
using RigidBodyCollider2Ptr = std::shared_ptr<RigidBodyCollider2>;
 
using RigidBodyCollider3Ptr = std::shared_ptr<RigidBodyCollider3>;
 
template <size_t N>
class RigidBodyCollider<N>::Builder final
{
 public:
    Builder& WithSurface(const std::shared_ptr<Surface<N>>& surface);
 
    Builder& WithLinearVelocity(const Vector<double, N>& _linearVelocity);
 
    Builder& WithAngularVelocity(const AngularVelocity<N>& _angularVelocity);
 
    RigidBodyCollider Build() const;
 
    std::shared_ptr<RigidBodyCollider<N>> MakeShared() const;
 
 private:
    std::shared_ptr<Surface<N>> m_surface;
    Vector<double, N> m_linearVelocity;
    AngularVelocity<N> m_angularVelocity;
};
}  // namespace CubbyFlow
 
#endif