volume_particle_emitter3.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_EMITTER3_H_
#define INCLUDE_JET_VOLUME_PARTICLE_EMITTER3_H_
 
#include <jet/bounding_box3.h>
#include <jet/implicit_surface3.h>
#include <jet/particle_emitter3.h>
#include <jet/point_generator3.h>
 
#include <limits>
#include <memory>
#include <random>
 
namespace jet {
 
class VolumeParticleEmitter3 final : public ParticleEmitter3 {
 public:
    class Builder;
 
    VolumeParticleEmitter3(
        const ImplicitSurface3Ptr& implicitSurface,
        const BoundingBox3D& maxRegion,
        double spacing,
        const Vector3D& initialVel = Vector3D(),
        const Vector3D& linearVel = Vector3D(),
        const Vector3D& angularVel = Vector3D(),
        size_t maxNumberOfParticles = kMaxSize,
        double jitter = 0.0,
        bool isOneShot = true,
        bool allowOverlapping = false,
        uint32_t seed = 0);
 
    void setPointGenerator(const PointGenerator3Ptr& newPointsGen);
 
    const ImplicitSurface3Ptr& surface() const;
 
    void setSurface(const ImplicitSurface3Ptr& newSurface);
 
    const BoundingBox3D& maxRegion() const;
 
    void setMaxRegion(const BoundingBox3D& 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);
 
    Vector3D initialVelocity() const;
 
    void setInitialVelocity(const Vector3D& newInitialVel);
 
    Vector3D linearVelocity() const;
 
    void setLinearVelocity(const Vector3D& newLinearVel);
 
    Vector3D angularVelocity() const;
 
    void setAngularVelocity(const Vector3D& newAngularVel);
 
    static Builder builder();
 
 private:
    std::mt19937 _rng;
 
    ImplicitSurface3Ptr _implicitSurface;
    BoundingBox3D _bounds;
    double _spacing;
    Vector3D _initialVel;
    Vector3D _linearVel;
    Vector3D _angularVel;
    PointGenerator3Ptr _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 ParticleSystemData3Ptr& particles,
        Array1<Vector3D>* newPositions,
        Array1<Vector3D>* newVelocities);
 
    double random();
 
    Vector3D velocityAt(const Vector3D& point) const;
};
 
typedef std::shared_ptr<VolumeParticleEmitter3> VolumeParticleEmitter3Ptr;
 
 
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& withLinearVelocity(const Vector3D& linearVel);
 
    Builder& withAngularVelocity(const Vector3D& angularVel);
 
    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 _implicitSurface;
    bool _isBoundSet = false;
    BoundingBox3D _bounds;
    double _spacing = 0.1;
    Vector3D _initialVel;
    Vector3D _linearVel;
    Vector3D _angularVel;
    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_EMITTER3_H_