VolumeParticleEmitter2.h

Go to the documentation of this file.

/*************************************************************************
> File Name: VolumeParticleEmitter2.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: 2-D volumetric particle emitter.
> Created Time: 2017/06/19
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_VOLUME_PARTICLE_EMITTER2_H
#define CUBBYFLOW_VOLUME_PARTICLE_EMITTER2_H

#include <Core/Emitter/ParticleEmitter2.h>
#include <Core/PointGenerator/PointGenerator2.h>
#include <Core/Surface/ImplicitSurface2.h>

#include <random>

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

        VolumeParticleEmitter2(
            const ImplicitSurface2Ptr& implicitSurface,
            const BoundingBox2D& bounds,
            double spacing,
            const Vector2D& initialVel = Vector2D(),
            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);

        double GetJitter() const;

        void SetJitter(double newJitter);

        bool GetIsOneShot() const;

        void SetIsOneShot(bool newValue);

        bool GetAllowOverlapping() const;

        void SetAllowOverlapping(bool newValue);

        size_t GetMaxNumberOfParticles() const;

        void SetMaxNumberOfParticles(size_t newMaxNumberOfParticles);

        double GetSpacing() const;

        void SetSpacing(double newSpacing);

        Vector2D GetInitialVelocity() const;

        void SetInitialVelocity(const Vector2D& newInitialVel);

        static Builder GetBuilder();

    private:
        std::mt19937 m_rng;

        ImplicitSurface2Ptr m_implicitSurface;
        BoundingBox2D m_bounds;
        double m_spacing;
        Vector2D m_initialVel;
        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;

        void OnUpdate(double currentTimeInSeconds, double timeIntervalInSeconds) override;

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

        double Random();
    };

    using VolumeParticleEmitter2Ptr = std::shared_ptr<VolumeParticleEmitter2>;
    
    class VolumeParticleEmitter2::Builder final
    {
    public:
        Builder& WithImplicitSurface(const ImplicitSurface2Ptr& implicitSurface);

        Builder& WithSurface(const Surface2Ptr& surface);

        Builder& WithMaxRegion(const BoundingBox2D& bounds);

        Builder& WithSpacing(double spacing);

        Builder& WithInitialVelocity(const Vector2D& initialVel);

        Builder& WithMaxNumberOfParticles(size_t maxNumberOfParticles);

        Builder& WithJitter(double jitter);

        Builder& WithIsOneShot(bool isOneShot);

        Builder& WithAllowOverlapping(bool allowOverlapping);

        Builder& WithRandomSeed(uint32_t seed);

        VolumeParticleEmitter2 Build() const;

        VolumeParticleEmitter2Ptr MakeShared() const;

    private:
        ImplicitSurface2Ptr m_implicitSurface;
        bool m_isBoundSet = false;
        BoundingBox2D m_bounds;
        double m_spacing = 0.1;
        Vector2D m_initialVel{ 0, 0 };
        size_t m_maxNumberOfParticles = std::numeric_limits<size_t>::max();
        double m_jitter = 0.0;
        bool m_isOneShot = true;
        bool m_allowOverlapping = false;
        uint32_t m_seed = 0;
    };
}

#endif