ParticleSystemSolver3.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_SOLVER3_HPP
#define CUBBYFLOW_PARTICLE_SYSTEM_SOLVER3_HPP
 
#include <Core/Animation/PhysicsAnimation.hpp>
#include <Core/Emitter/ParticleEmitter3.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 ParticleSystemSolver3 : public PhysicsAnimation
{
 public:
    class Builder;
 
    ParticleSystemSolver3();
 
    ParticleSystemSolver3(double radius, double mass);
 
    ParticleSystemSolver3(const ParticleSystemSolver3&) = delete;
 
    ParticleSystemSolver3(ParticleSystemSolver3&&) noexcept = delete;
 
    ~ParticleSystemSolver3() override = default;
 
    ParticleSystemSolver3& operator=(const ParticleSystemSolver3&) = delete;
 
    ParticleSystemSolver3& operator=(ParticleSystemSolver3&&) noexcept = delete;
 
    [[nodiscard]] double GetDragCoefficient() const;
 
    void SetDragCoefficient(double newDragCoefficient);
 
    [[nodiscard]] double GetRestitutionCoefficient() const;
 
    void SetRestitutionCoefficient(double newRestitutionCoefficient);
 
    [[nodiscard]] const Vector3D& GetGravity() const;
 
    void SetGravity(const Vector3D& newGravity);
 
    [[nodiscard]] const ParticleSystemData3Ptr& GetParticleSystemData() const;
 
    [[nodiscard]] const Collider3Ptr& GetCollider() const;
 
    void SetCollider(const Collider3Ptr& newCollider);
 
    [[nodiscard]] const ParticleEmitter3Ptr& GetEmitter() const;
 
    void SetEmitter(const ParticleEmitter3Ptr& newEmitter);
 
    [[nodiscard]] const VectorField3Ptr& GetWind() const;
 
    void SetWind(const VectorField3Ptr& 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<Vector3D> newPositions,
                          ArrayView1<Vector3D> newVelocities);
 
    void SetParticleSystemData(const ParticleSystemData3Ptr& 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;
    Vector3D m_gravity = Vector3D{ 0.0, GRAVITY, 0.0 };
 
    ParticleSystemData3Ptr m_particleSystemData;
    ParticleSystemData3::VectorData m_newPositions;
    ParticleSystemData3::VectorData m_newVelocities;
    Collider3Ptr m_collider;
    ParticleEmitter3Ptr m_emitter;
    VectorField3Ptr m_wind;
};
 
using ParticleSystemSolver3Ptr = std::shared_ptr<ParticleSystemSolver3>;
 
template <typename DerivedBuilder>
class ParticleSystemSolverBuilderBase3
{
 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& ParticleSystemSolverBuilderBase3<T>::WithRadius(double radius)
{
    m_radius = radius;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& ParticleSystemSolverBuilderBase3<T>::WithMass(double mass)
{
    m_mass = mass;
    return static_cast<T&>(*this);
}
 
class ParticleSystemSolver3::Builder final
    : public ParticleSystemSolverBuilderBase3<Builder>
{
 public:
    [[nodiscard]] ParticleSystemSolver3 Build() const;
 
    [[nodiscard]] ParticleSystemSolver3Ptr MakeShared() const;
};
}  // namespace CubbyFlow
 
#endif