volume_particle_emitter2.h

Go to the documentation of this file.

// Copyright (c) 2019 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_VOLUME_PARTICLE_EMITTER2_H_
#define INCLUDE_JET_VOLUME_PARTICLE_EMITTER2_H_
 
#include <jet/constants.h>
#include <jet/bounding_box2.h>
#include <jet/implicit_surface2.h>
#include <jet/particle_emitter2.h>
#include <jet/point_generator2.h>
 
#include <limits>
#include <memory>
#include <random>
 
namespace jet {
 
class VolumeParticleEmitter2 final : public ParticleEmitter2 {
 public:
    class Builder;
 
    VolumeParticleEmitter2(
        const ImplicitSurface2Ptr& implicitSurface,
        const BoundingBox2D& maxRegion,
        double spacing,
        const Vector2D& initialVel = Vector2D(),
        const Vector2D& linearVel = Vector2D(),
        double angularVel = 0.0,
        size_t maxNumberOfParticles = kMaxSize,
        double jitter = 0.0,
        bool isOneShot = true,
        bool allowOverlapping = false,
        uint32_t seed = 0);
 
    void setPointGenerator(const PointGenerator2Ptr& newPointsGen);
 
    const ImplicitSurface2Ptr& surface() const;
 
    void setSurface(const ImplicitSurface2Ptr& newSurface);
 
    const BoundingBox2D& maxRegion() const;
 
    void setMaxRegion(const BoundingBox2D& newBox);
 
    double jitter() const;
 
    void setJitter(double newJitter);
 
    bool isOneShot() const;
 
    void setIsOneShot(bool newValue);
 
    bool allowOverlapping() const;
 
    void setAllowOverlapping(bool newValue);
 
    size_t maxNumberOfParticles() const;
 
    void setMaxNumberOfParticles(size_t newMaxNumberOfParticles);
 
    double spacing() const;
 
    void setSpacing(double newSpacing);
 
    Vector2D initialVelocity() const;
 
    void setInitialVelocity(const Vector2D& newInitialVel);
 
    Vector2D linearVelocity() const;
 
    void setLinearVelocity(const Vector2D& newLinearVel);
 
    double angularVelocity() const;
 
    void setAngularVelocity(double newAngularVel);
 
    static Builder builder();
 
 private:
    std::mt19937 _rng;
 
    ImplicitSurface2Ptr _implicitSurface;
    BoundingBox2D _bounds;
    double _spacing;
    Vector2D _initialVel;
    Vector2D _linearVel;
    double _angularVel = 0.0;
    PointGenerator2Ptr _pointsGen;
 
    size_t _maxNumberOfParticles = kMaxSize;
    size_t _numberOfEmittedParticles = 0;
 
    double _jitter = 0.0;
    bool _isOneShot = true;
    bool _allowOverlapping = false;
 
    void onUpdate(
        double currentTimeInSeconds,
        double timeIntervalInSeconds) override;
 
    void emit(
        const ParticleSystemData2Ptr& particles,
        Array1<Vector2D>* newPositions,
        Array1<Vector2D>* newVelocities);
 
    double random();
 
    Vector2D velocityAt(const Vector2D& point) const;
};
 
typedef std::shared_ptr<VolumeParticleEmitter2> VolumeParticleEmitter2Ptr;
 
 
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& withLinearVelocity(const Vector2D& linearVel);
 
    Builder& withAngularVelocity(double angularVel);
 
    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 _implicitSurface;
    bool _isBoundSet = false;
    BoundingBox2D _bounds;
    double _spacing = 0.1;
    Vector2D _initialVel;
    Vector2D _linearVel;
    double _angularVel = 0.0;
    size_t _maxNumberOfParticles = kMaxSize;
    double _jitter = 0.0;
    bool _isOneShot = true;
    bool _allowOverlapping = false;
    uint32_t _seed = 0;
};
 
}  // namespace jet
 
#endif  // INCLUDE_JET_VOLUME_PARTICLE_EMITTER2_H_