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