ParticleSystemSolver2.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_PARTICLE_SYSTEM_SOLVER2_HPP
#define CUBBYFLOW_PARTICLE_SYSTEM_SOLVER2_HPP
 
#include <Core/Animation/PhysicsAnimation.hpp>
#include <Core/Emitter/ParticleEmitter2.hpp>
#include <Core/Field/VectorField.hpp>
#include <Core/Geometry/Collider.hpp>
#include <Core/Matrix/Matrix.hpp>
#include <Core/Particle/ParticleSystemData.hpp>
#include <Core/Utils/Constants.hpp>
 
namespace CubbyFlow
{
class ParticleSystemSolver2 : public PhysicsAnimation
{
 public:
    class Builder;
 
    ParticleSystemSolver2();
 
    ParticleSystemSolver2(double radius, double mass);
 
    ParticleSystemSolver2(const ParticleSystemSolver2&) = delete;
 
    ParticleSystemSolver2(ParticleSystemSolver2&&) noexcept = delete;
 
    ~ParticleSystemSolver2() override = default;
 
    ParticleSystemSolver2& operator=(const ParticleSystemSolver2&) = delete;
 
    ParticleSystemSolver2& operator=(ParticleSystemSolver2&&) noexcept = delete;
 
    [[nodiscard]] double GetDragCoefficient() const;
 
    void SetDragCoefficient(double newDragCoefficient);
 
    [[nodiscard]] double GetRestitutionCoefficient() const;
 
    void SetRestitutionCoefficient(double newRestitutionCoefficient);
 
    [[nodiscard]] const Vector2D& GetGravity() const;
 
    void SetGravity(const Vector2D& newGravity);
 
    [[nodiscard]] const ParticleSystemData2Ptr& GetParticleSystemData() const;
 
    [[nodiscard]] const Collider2Ptr& GetCollider() const;
 
    void SetCollider(const Collider2Ptr& newCollider);
 
    [[nodiscard]] const ParticleEmitter2Ptr& GetEmitter() const;
 
    void SetEmitter(const ParticleEmitter2Ptr& newEmitter);
 
    [[nodiscard]] const VectorField2Ptr& GetWind() const;
 
    void SetWind(const VectorField2Ptr& newWind);
 
    [[nodiscard]] static Builder GetBuilder();
 
 protected:
    void OnInitialize() override;
 
    void OnAdvanceTimeStep(double timeStepInSeconds) override;
 
    virtual void AccumulateForces(double timeStepInSeconds);
 
    virtual void OnBeginAdvanceTimeStep(double timeStepInSeconds);
 
    virtual void OnEndAdvanceTimeStep(double timeStepInSeconds);
 
    void ResolveCollision();
 
    void ResolveCollision(ArrayView1<Vector2D> newPositions,
                          ArrayView1<Vector2D> newVelocities);
 
    void SetParticleSystemData(const ParticleSystemData2Ptr& newParticles);
 
 private:
    void BeginAdvanceTimeStep(double timeStepInSeconds);
 
    void EndAdvanceTimeStep(double timeStepInSeconds);
 
    void AccumulateExternalForces();
 
    void TimeIntegration(double timeStepInSeconds);
 
    void UpdateCollider(double timeStepInSeconds) const;
 
    void UpdateEmitter(double timeStepInSeconds) const;
 
    double m_dragCoefficient = 1e-4;
    double m_restitutionCoefficient = 0.0;
    Vector2D m_gravity = Vector2D{ 0.0, GRAVITY };
 
    ParticleSystemData2Ptr m_particleSystemData;
    ParticleSystemData2::VectorData m_newPositions;
    ParticleSystemData2::VectorData m_newVelocities;
    Collider2Ptr m_collider;
    ParticleEmitter2Ptr m_emitter;
    VectorField2Ptr m_wind;
};
 
using ParticleSystemSolver2Ptr = std::shared_ptr<ParticleSystemSolver2>;
 
template <typename DerivedBuilder>
class ParticleSystemSolverBuilderBase2
{
 public:
    [[nodiscard]] DerivedBuilder& WithRadius(double radius);
 
    [[nodiscard]] DerivedBuilder& WithMass(double mass);
 
 protected:
    double m_radius = 1e-3;
    double m_mass = 1e-3;
};
 
template <typename T>
T& ParticleSystemSolverBuilderBase2<T>::WithRadius(double radius)
{
    m_radius = radius;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& ParticleSystemSolverBuilderBase2<T>::WithMass(double mass)
{
    m_mass = mass;
    return static_cast<T&>(*this);
}
 
class ParticleSystemSolver2::Builder final
    : public ParticleSystemSolverBuilderBase2<Builder>
{
 public:
    [[nodiscard]] ParticleSystemSolver2 Build() const;
 
    [[nodiscard]] ParticleSystemSolver2Ptr MakeShared() const;
};
}  // namespace CubbyFlow
 
#endif