particle_system_solver3.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_PARTICLE_SYSTEM_SOLVER3_H_
#define INCLUDE_JET_PARTICLE_SYSTEM_SOLVER3_H_
 
#include <jet/collider3.h>
#include <jet/constants.h>
#include <jet/vector_field3.h>
#include <jet/particle_emitter3.h>
#include <jet/particle_system_data3.h>
#include <jet/physics_animation.h>
 
namespace jet {
 
class ParticleSystemSolver3 : public PhysicsAnimation {
 public:
    class Builder;
 
    ParticleSystemSolver3();
 
    ParticleSystemSolver3(
        double radius,
        double mass);
 
    virtual ~ParticleSystemSolver3();
 
    double dragCoefficient() const;
 
    void setDragCoefficient(double newDragCoefficient);
 
    double restitutionCoefficient() const;
 
    void setRestitutionCoefficient(double newRestitutionCoefficient);
 
    const Vector3D& gravity() const;
 
    void setGravity(const Vector3D& newGravity);
 
    const ParticleSystemData3Ptr& particleSystemData() const;
 
    const Collider3Ptr& collider() const;
 
    void setCollider(const Collider3Ptr& newCollider);
 
    const ParticleEmitter3Ptr& emitter() const;
 
    void setEmitter(const ParticleEmitter3Ptr& newEmitter);
 
    const VectorField3Ptr& wind() const;
 
    void setWind(const VectorField3Ptr& newWind);
 
    static Builder builder();
 
 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(
        ArrayAccessor1<Vector3D> newPositions,
        ArrayAccessor1<Vector3D> newVelocities);
 
    void setParticleSystemData(const ParticleSystemData3Ptr& newParticles);
 
 private:
    double _dragCoefficient = 1e-4;
    double _restitutionCoefficient = 0.0;
    Vector3D _gravity = Vector3D(0.0, kGravity, 0.0);
 
    ParticleSystemData3Ptr _particleSystemData;
    ParticleSystemData3::VectorData _newPositions;
    ParticleSystemData3::VectorData _newVelocities;
    Collider3Ptr _collider;
    ParticleEmitter3Ptr _emitter;
    VectorField3Ptr _wind;
 
    void beginAdvanceTimeStep(double timeStepInSeconds);
 
    void endAdvanceTimeStep(double timeStepInSeconds);
 
    void accumulateExternalForces();
 
    void timeIntegration(double timeStepInSeconds);
 
    void updateCollider(double timeStepInSeconds);
 
    void updateEmitter(double timeStepInSeconds);
};
 
typedef std::shared_ptr<ParticleSystemSolver3> ParticleSystemSolver3Ptr;
 
 
template <typename DerivedBuilder>
class ParticleSystemSolverBuilderBase3 {
 public:
    DerivedBuilder& withRadius(double radius);
 
    DerivedBuilder& withMass(double mass);
 
 protected:
    double _radius = 1e-3;
    double _mass = 1e-3;
};
 
template <typename T>
T& ParticleSystemSolverBuilderBase3<T>::withRadius(double radius) {
    _radius = radius;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& ParticleSystemSolverBuilderBase3<T>::withMass(double mass) {
    _mass = mass;
    return static_cast<T&>(*this);
}
 
class ParticleSystemSolver3::Builder final
    : public ParticleSystemSolverBuilderBase3<ParticleSystemSolver3::Builder> {
 public:
    ParticleSystemSolver3 build() const;
 
    ParticleSystemSolver3Ptr makeShared() const;
};
 
}  // namespace jet
 
#endif  // INCLUDE_JET_PARTICLE_SYSTEM_SOLVER3_H_