imstkRenderParticleEmitter.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkMath.h"
#include "imstkAnimationModel.h"
#include "imstkColor.h"

namespace imstk
{
struct RenderParticle;
class StopWatch;

struct RenderParticleKeyFrame
{
    float m_time  = 0;
    Color m_color = Color::White;
    Vec3f m_acceleration = Vec3f(0, 0, 0);
    float m_rotationalAcceleration = 0;
    float m_scale = 1.0f;
};

class RenderParticleEmitter : public AnimationModel
{
public:
    enum class Shape
    {
        Cube
    };

    enum class Mode
    {
        Continuous, 
        Burst       
    };

    explicit RenderParticleEmitter(std::shared_ptr<Geometry> geometry,
                                   const float               time = 3000.0f,
                                   Mode                      mode = Mode::Continuous);

    virtual void setGeometry(std::shared_ptr<Geometry> renderParticles);

    RenderParticleEmitter::Mode getEmitterMode() const;

    void setEmitterSize(const float size);

    void setInitialVelocityRange(const Vec3f minDirection,
                                 const Vec3f maxDirection,
                                 const float minSpeed,
                                 const float maxSpeed,
                                 const float minRotationSpeed,
                                 const float maxRotationSpeed);

    bool addKeyFrame(RenderParticleKeyFrame keyFrame);

    RenderParticleKeyFrame* getStartKeyFrame();
    RenderParticleKeyFrame* getEndKeyFrame();

    std::vector<RenderParticleKeyFrame>& getKeyFrames();

    virtual void reset();

    virtual void update();

protected:
    void initializeParticles();

    void interpolateColor(Color&       destination,
                          const Color& sourceA,
                          const Color& sourceB,
                          const float  alpha);

    void emitParticle(std::unique_ptr<RenderParticle>& particle);

    float getRandomNormalizedFloat();

    std::vector<RenderParticleKeyFrame> m_keyFrames; 

    RenderParticleEmitter::Mode m_mode
        = RenderParticleEmitter::Mode::Continuous;
    RenderParticleEmitter::Shape m_shape
        = RenderParticleEmitter::Shape::Cube;

    Vec3f m_minDirection;
    Vec3f m_maxDirection;
    float m_minSpeed;
    float m_maxSpeed;
    float m_minRotationSpeed;
    float m_maxRotationSpeed;

    float m_time; 
    float m_emitTime;

    std::unique_ptr<StopWatch> m_stopWatch;

    double m_lastUpdateTime = 0.0;
    bool   m_started = false;

    float m_emitterSize = 1.0f;

    const int c_maxNumKeyFrames = 16; 

    std::shared_ptr<Geometry> m_animationGeometry = nullptr;
    std::vector<std::unique_ptr<RenderParticle>>* m_particles;
};
} // imstk