VolumeParticleEmitter3.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_EMITTER3_HPP
#define CUBBYFLOW_VOLUME_PARTICLE_EMITTER3_HPP
 
#include <Core/Emitter/ParticleEmitter3.hpp>
#include <Core/Geometry/ImplicitSurface.hpp>
#include <Core/PointGenerator/PointGenerator3.hpp>
 
#include <random>
 
namespace CubbyFlow
{
class VolumeParticleEmitter3 final : public ParticleEmitter3
{
 public:
    class Builder;
 
    VolumeParticleEmitter3(
        ImplicitSurface3Ptr implicitSurface, BoundingBox3D maxRegion,
        double spacing, const Vector3D& initialVel = Vector3D(),
        const Vector3D& linearVel = Vector3D(),
        const Vector3D& angularVel = Vector3D(),
        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 PointGenerator3Ptr& newPointsGen);
 
    [[nodiscard]] const ImplicitSurface3Ptr& GetSurface() const;
 
    void SetSurface(const ImplicitSurface3Ptr& newSurface);
 
    [[nodiscard]] const BoundingBox3D& GetMaxRegion() const;
 
    void SetMaxRegion(const BoundingBox3D& 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]] Vector3D GetInitialVelocity() const;
 
    void SetInitialVelocity(const Vector3D& newInitialVel);
 
    [[nodiscard]] Vector3D GetLinearVelocity() const;
 
    void SetLinearVelocity(const Vector3D& newLinearVel);
 
    [[nodiscard]] Vector3D GetAngularVelocity() const;
 
    void SetAngularVelocity(const Vector3D& newAngularVel);
 
    [[nodiscard]] static Builder GetBuilder();
 
 private:
    void OnUpdate(double currentTimeInSeconds,
                  double timeIntervalInSeconds) override;
 
    void Emit(const ParticleSystemData3Ptr& particles,
              Array1<Vector3D>* newPositions, Array1<Vector3D>* newVelocities);
 
    [[nodiscard]] double Random();
 
    [[nodiscard]] Vector3D VelocityAt(const Vector3D& point) const;
 
    std::mt19937 m_rng;
 
    ImplicitSurface3Ptr m_implicitSurface;
    BoundingBox3D m_maxRegion;
    double m_spacing;
    Vector3D m_initialVel;
    Vector3D m_linearVel;
    Vector3D m_angularVel;
    PointGenerator3Ptr 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 VolumeParticleEmitter3Ptr = std::shared_ptr<VolumeParticleEmitter3>;
 
class VolumeParticleEmitter3::Builder final
{
 public:
    [[nodiscard]] Builder& WithImplicitSurface(
        const ImplicitSurface3Ptr& implicitSurface);
 
    [[nodiscard]] Builder& WithSurface(const Surface3Ptr& surface);
 
    [[nodiscard]] Builder& WithMaxRegion(const BoundingBox3D& maxRegion);
 
    [[nodiscard]] Builder& WithSpacing(double spacing);
 
    [[nodiscard]] Builder& WithInitialVelocity(const Vector3D& initialVel);
 
    [[nodiscard]] Builder& WithLinearVelocity(const Vector3D& linearVel);
 
    [[nodiscard]] Builder& WithAngularVelocity(const Vector3D& 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]] VolumeParticleEmitter3 Build() const;
 
    [[nodiscard]] VolumeParticleEmitter3Ptr MakeShared() const;
 
 private:
    ImplicitSurface3Ptr m_implicitSurface;
    BoundingBox3D m_maxRegion;
    double m_spacing = 0.1;
    Vector3D m_initialVel;
    Vector3D m_linearVel;
    Vector3D m_angularVel;
    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