VolumeParticleEmitter3.h

Go to the documentation of this file.

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

#include <Core/Emitter/ParticleEmitter3.h>
#include <Core/PointGenerator/PointGenerator3.h>
#include <Core/Surface/ImplicitSurface3.h>

#include <random>

namespace CubbyFlow
{
    class VolumeParticleEmitter3 final : public ParticleEmitter3
    {
    public:
        class Builder;

        VolumeParticleEmitter3(
            const ImplicitSurface3Ptr& implicitSurface,
            const BoundingBox3D& bounds,
            double spacing,
            const Vector3D& initialVel = 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);

        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);

        Vector3D GetInitialVelocity() const;

        void SetInitialVelocity(const Vector3D& newInitialVel);

        static Builder GetBuilder();

    private:
        std::mt19937 m_rng;

        ImplicitSurface3Ptr m_implicitSurface;
        BoundingBox3D m_bounds;
        double m_spacing;
        Vector3D m_initialVel;
        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;

        void OnUpdate(double currentTimeInSeconds, double timeIntervalInSeconds) override;

        void Emit(const ParticleSystemData3Ptr& particles,
            Array1<Vector3D>* newPositions, Array1<Vector3D>* newVelocities);

        double Random();
    };

    using VolumeParticleEmitter3Ptr = std::shared_ptr<VolumeParticleEmitter3>;

    class VolumeParticleEmitter3::Builder final
    {
    public:
        Builder& WithImplicitSurface(const ImplicitSurface3Ptr& implicitSurface);

        Builder& WithSurface(const Surface3Ptr& surface);

        Builder& WithMaxRegion(const BoundingBox3D& bounds);

        Builder& WithSpacing(double spacing);

        Builder& WithInitialVelocity(const Vector3D& initialVel);

        Builder& WithMaxNumberOfParticles(size_t maxNumberOfParticles);

        Builder& WithJitter(double jitter);

        Builder& WithIsOneShot(bool isOneShot);

        Builder& WithAllowOverlapping(bool allowOverlapping);

        Builder& WithRandomSeed(uint32_t seed);

        VolumeParticleEmitter3 Build() const;

        VolumeParticleEmitter3Ptr MakeShared() const;

    private:
        ImplicitSurface3Ptr m_implicitSurface;
        bool m_isBoundSet = false;
        BoundingBox3D m_bounds;
        double m_spacing = 0.1;
        Vector3D m_initialVel{ 0, 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