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