VolumeParticleEmitter2.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_VOLUME_PARTICLE_EMITTER2_HPP
#define CUBBYFLOW_VOLUME_PARTICLE_EMITTER2_HPP

#include <Core/Emitter/ParticleEmitter2.hpp>
#include <Core/Geometry/ImplicitSurface.hpp>
#include <Core/PointGenerator/PointGenerator2.hpp>

#include <random>

namespace CubbyFlow
{
class VolumeParticleEmitter2 final : public ParticleEmitter2
{
 public:
    class Builder;

    VolumeParticleEmitter2(
        ImplicitSurface2Ptr implicitSurface, BoundingBox2D maxRegion,
        double spacing, const Vector2D& initialVel = Vector2D(),
        const Vector2D& linearVel = Vector2D(), double angularVel = 0.0,
        size_t maxNumberOfParticles = std::numeric_limits<size_t>::max(),
        double jitter = 0.0, bool isOneShot = true,
        bool allowOverlapping = false, uint32_t seed = 0);

    void SetPointGenerator(const PointGenerator2Ptr& newPointsGen);

    [[nodiscard]] const ImplicitSurface2Ptr& GetSurface() const;

    void SetSurface(const ImplicitSurface2Ptr& newSurface);

    [[nodiscard]] const BoundingBox2D& GetMaxRegion() const;

    void SetMaxRegion(const BoundingBox2D& newMaxRegion);

    [[nodiscard]] double GetJitter() const;

    void SetJitter(double newJitter);

    [[nodiscard]] bool GetIsOneShot() const;

    void SetIsOneShot(bool newValue);

    [[nodiscard]] bool GetAllowOverlapping() const;

    void SetAllowOverlapping(bool newValue);

    [[nodiscard]] size_t GetMaxNumberOfParticles() const;

    void SetMaxNumberOfParticles(size_t newMaxNumberOfParticles);

    [[nodiscard]] double GetSpacing() const;

    void SetSpacing(double newSpacing);

    [[nodiscard]] Vector2D GetInitialVelocity() const;

    void SetInitialVelocity(const Vector2D& newInitialVel);

    [[nodiscard]] Vector2D GetLinearVelocity() const;

    void SetLinearVelocity(const Vector2D& newLinearVel);

    [[nodiscard]] double GetAngularVelocity() const;

    void SetAngularVelocity(double newAngularVel);

    [[nodiscard]] static Builder GetBuilder();

 private:
    void OnUpdate(double currentTimeInSeconds,
                  double timeIntervalInSeconds) override;

    void Emit(const ParticleSystemData2Ptr& particles,
              Array1<Vector2D>* newPositions, Array1<Vector2D>* newVelocities);

    [[nodiscard]] double Random();

    [[nodiscard]] Vector2D VelocityAt(const Vector2D& point) const;

    std::mt19937 m_rng;

    ImplicitSurface2Ptr m_implicitSurface;
    BoundingBox2D m_maxRegion;
    double m_spacing;
    Vector2D m_initialVel;
    Vector2D m_linearVel;
    double m_angularVel = 0.0;
    PointGenerator2Ptr m_pointsGen;

    size_t m_maxNumberOfParticles = std::numeric_limits<size_t>::max();
    size_t m_numberOfEmittedParticles = 0;

    double m_jitter = 0.0;
    bool m_isOneShot = true;
    bool m_allowOverlapping = false;
};

using VolumeParticleEmitter2Ptr = std::shared_ptr<VolumeParticleEmitter2>;

class VolumeParticleEmitter2::Builder final
{
 public:
    [[nodiscard]] Builder& WithImplicitSurface(
        const ImplicitSurface2Ptr& implicitSurface);

    [[nodiscard]] Builder& WithSurface(const Surface2Ptr& surface);

    [[nodiscard]] Builder& WithMaxRegion(const BoundingBox2D& maxRegion);

    [[nodiscard]] Builder& WithSpacing(double spacing);

    [[nodiscard]] Builder& WithInitialVelocity(const Vector2D& initialVel);

    [[nodiscard]] Builder& WithLinearVelocity(const Vector2D& linearVel);

    [[nodiscard]] Builder& WithAngularVelocity(double angularVel);

    [[nodiscard]] Builder& WithMaxNumberOfParticles(
        size_t maxNumberOfParticles);

    [[nodiscard]] Builder& WithJitter(double jitter);

    [[nodiscard]] Builder& WithIsOneShot(bool isOneShot);

    [[nodiscard]] Builder& WithAllowOverlapping(bool allowOverlapping);

    [[nodiscard]] Builder& WithRandomSeed(uint32_t seed);

    [[nodiscard]] VolumeParticleEmitter2 Build() const;

    [[nodiscard]] VolumeParticleEmitter2Ptr MakeShared() const;

 private:
    ImplicitSurface2Ptr m_implicitSurface;
    BoundingBox2D m_maxRegion;
    double m_spacing = 0.1;
    Vector2D m_initialVel;
    Vector2D m_linearVel;
    double m_angularVel = 0.0;
    size_t m_maxNumberOfParticles = std::numeric_limits<size_t>::max();
    double m_jitter = 0.0;
    uint32_t m_seed = 0;
    bool m_isBoundSet = false;
    bool m_isOneShot = true;
    bool m_allowOverlapping = false;
};
}  // namespace CubbyFlow

#endif