PointParticleEmitter2.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_POINT_PARTICLE_EMITTER2_HPP
#define CUBBYFLOW_POINT_PARTICLE_EMITTER2_HPP
 
#include <Core/Emitter/ParticleEmitter2.hpp>
 
#include <random>
 
namespace CubbyFlow
{
class PointParticleEmitter2 final : public ParticleEmitter2
{
 public:
    class Builder;
 
    PointParticleEmitter2(
        const Vector2D& origin, const Vector2D& direction, double speed,
        double spreadAngleInDegrees, size_t maxNumOfNewParticlesPerSec = 1,
        size_t maxNumOfParticles = std::numeric_limits<size_t>::max(),
        uint32_t seed = 0);
 
    [[nodiscard]] size_t GetMaxNumberOfNewParticlesPerSecond() const;
 
    void SetMaxNumberOfNewParticlesPerSecond(size_t rate);
 
    [[nodiscard]] size_t GetMaxNumberOfParticles() const;
 
    void SetMaxNumberOfParticles(size_t maxNumberOfParticles);
 
    static Builder GetBuilder();
 
 private:
    void OnUpdate(double currentTimeInSeconds,
                  double timeIntervalInSeconds) override;
 
    void Emit(Array1<Vector2D>* newPositions, Array1<Vector2D>* newVelocities,
              size_t maxNewNumberOfParticles);
 
    [[nodiscard]] double Random();
 
    std::mt19937 m_rng;
 
    double m_firstFrameTimeInSeconds = 0.0;
    size_t m_numberOfEmittedParticles = 0;
 
    size_t m_maxNumberOfNewParticlesPerSecond;
    size_t m_maxNumberOfParticles;
 
    Vector2D m_origin;
    Vector2D m_direction;
    double m_speed;
    double m_spreadAngleInRadians;
};
 
using PointParticleEmitter2Ptr = std::shared_ptr<PointParticleEmitter2>;
 
class PointParticleEmitter2::Builder final
{
 public:
    [[nodiscard]] Builder& WithOrigin(const Vector2D& origin);
 
    [[nodiscard]] Builder& WithDirection(const Vector2D& direction);
 
    [[nodiscard]] Builder& WithSpeed(double speed);
 
    [[nodiscard]] Builder& WithSpreadAngleInDegrees(
        double spreadAngleInDegrees);
 
    [[nodiscard]] Builder& WithMaxNumberOfNewParticlesPerSecond(
        size_t maxNumOfNewParticlesPerSec);
 
    [[nodiscard]] Builder& WithMaxNumberOfParticles(
        size_t maxNumberOfParticles);
 
    [[nodiscard]] Builder& WithRandomSeed(uint32_t seed);
 
    [[nodiscard]] PointParticleEmitter2 Build() const;
 
    [[nodiscard]] PointParticleEmitter2Ptr MakeShared() const;
 
 private:
    size_t m_maxNumberOfNewParticlesPerSecond = 1;
    size_t m_maxNumberOfParticles = std::numeric_limits<size_t>::max();
    Vector2D m_origin{ 0, 0 };
    Vector2D m_direction{ 0, 1 };
    double m_speed = 1.0;
    double m_spreadAngleInDegrees = 90.0;
    uint32_t m_seed = 0;
};
}  // namespace CubbyFlow
 
#endif