IAPDemo/Libraries/cocos2d/cocos/rparticle/RParticleSystem.h

//
//  RParticleSystem.h
//  cocos2d_libs
//
//  Created by 徐俊杰 on 2020/4/25.
//

#ifndef RParticleSystem_h
#define RParticleSystem_h

//#include "cocos2d.h"
#include "rparticle/Macros/RParticleMacros.h"
#include "base/CCDirector.h"
#include "rparticle/Modules/ParticleSystemModule.h"
#include "rparticle/ParticleSystemParticle.h"
#include "rparticle/Modules/EmissionModule.h"
#include "rparticle/Modules/InitialModule.h"
#include "rparticle/Modules/ShapeModule.h"
#include "renderer/CCCustomCommand.h"
#include "renderer/CCQuadCommand.h"
#include "renderer/CCMaterial.h"
#include "base/CCRefPtr.h"
#include "2d/IEditorNodeLoadListener.h"

#include "rparticle/Datas/EditorDatas.h"

#if REDREAM_EDITOR
namespace cocos2d {
    class DrawNode3D;
}
#endif

NS_RRP_BEGIN

//注意：传入时间（无），Render，Transform 这3个相关的操作可能会有问题，还需要验证。
//todo ：碰撞

class ParticleSystemRenderer;
class RParticleSystem;
class CollisionModule;
class RotationModule;
class RotationBySpeedModule;
class SubModule;
class SubEmitterModule;
class ExternalForcesModule;
class VelocityModule;
class ForceModule;
class ClampVelocityModule;
class SizeModule;
class ColorModule;
class UVModule;
class SizeBySpeedModule;
class ColorBySpeedModule;

class CC_DLL RParticleSystem : public cocos2d::Node, public cocos2d::TextureProtocol, public IEditorNodeLoadListener
{
public:
    enum
    {
        kParticleBuffer0,
#if UNITY_EDITOR // Double buffered + interpolation
        kParticleBuffer1,
#endif
        kNumParticleBuffers,
    };
    
    template<class TransferFunction> void Transfer (TransferFunction& transfer);
    
    static RParticleSystem* create();
    ~RParticleSystem();
    
    static void SyncJobs();
    static void BeginUpdateAll();
    static void EndUpdateAll();
    static void Emit(RParticleSystem& system, const SubEmitterEmitCommand& command, ParticleSystemEmitMode emitMode);

    inline bool IsActive () const
    {
//        return _bActive;
        //TODO: 应该递归判断父节点
        return this->isVisible();
    }
    
    float GetLengthInSec () const;
    ParticleSystemParticles& GetParticles (int index = -1);
    size_t GetParticleCount () const;

    static size_t EmitFromData (const ParticleSystemReadOnlyState& roState, ParticleSystemEmissionState& emissionState, size_t& numContinuous, const ParticleSystemEmissionData& emissionData, const Vector3f velocity, float fromT, float toT, float dt, float length);
    
    void Stop ();
    bool GetLoop () const;
    
    void Play (bool autoPrewarm = true);
    void Clear (bool updateBounds = true);
    
    void AwakeFromLoadGroup ();
    void PlayGroup ();
    void StopGroup ();
    void ClearGroup ();
    void StopAndClearGroup();

    bool IsPlaying () const;

    void GetNumTiles(int& uvTilesX, int& uvTilesY) const;
    
    void onEnter() override;
    void onExit() override;
    virtual void setVisible(bool visible) override;
    
    void onEditorNodeLoaded() { AwakeFromLoad(); }

    cocos2d::CustomCommand _command;
    cocos2d::QuadCommand _quadCommand;
    virtual void draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t flags) override;
    void onDraw();
    
#if REDREAM_EDITOR
    cocos2d::DrawNode3D* drawNode = nullptr;
    void OnDrawGizmosSelected();
#endif
    
private:
    static void Update0 (RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, float dt, bool fixedTimeStep);
    static void Update1 (RParticleSystem& system, ParticleSystemParticles& ps, float dt, bool fixedTimeStep, bool useProcedural, int rayBudget = 0);
    static void Update2 (RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, bool fixedTimeStep);
    static void Update1Incremental(RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, ParticleSystemParticles& ps, size_t fromIndex, float dt, bool useProcedural);
    static void UpdateProcedural(RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, ParticleSystemParticles& ps);
    static void UpdateBounds(const RParticleSystem& system, const ParticleSystemParticles& ps, ParticleSystemState& state);
    static void UpdateModulesPreSimulationIncremental (const RParticleSystem& system, const ParticleSystemReadOnlyState& roState, const ParticleSystemState& state, ParticleSystemParticles& ps, const size_t fromIndex, const size_t toIndex, float dt);
    static void UpdateModulesIncremental (const RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, ParticleSystemParticles& ps, size_t fromIndex, float dt);
    static void SimulateParticles (const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, ParticleSystemParticles& ps, const size_t fromIndex, float dt);
    static void UpdateModulesPostSimulationIncremental (const RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, ParticleSystemParticles& ps, const size_t fromIndex, float dt);
    
    static void UpdateModulesNonIncremental (const RParticleSystem& system, const ParticleSystemParticles& ps, ParticleSystemParticlesTempData& psTemp, int fromIndex, int toIndex);
    
    static size_t EmitFromModules (const RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemEmissionState& emissionState, size_t& numContinuous, const Vector3f velocity, float fromT, float toT, float dt);
    
    static void StartModules (RParticleSystem& system, const ParticleSystemReadOnlyState& roState, ParticleSystemState& state, const ParticleSystemEmissionState& emissionState, Vector3f initialVelocity, const Matrix4x4f& matrix, ParticleSystemParticles& ps, size_t fromIndex, float dt, float t, size_t numContinuous, float frameOffset);
    
    static void StartParticles(RParticleSystem& system, ParticleSystemParticles& ps, const float prevT, const float t, const float dt, const size_t numContinuous, size_t amountOfParticlesToEmit, float frameOffset);
    
    static void StartParticlesProcedural(RParticleSystem& system, ParticleSystemParticles& ps, const float prevT, const float t, const float dt, const size_t numContinuous, size_t amountOfParticlesToEmit, float frameOffset);
    
    static void AddStagingBuffer(RParticleSystem& system);
    static int SetupSubEmitters(RParticleSystem& shuriken, ParticleSystemState& state);
    
    static bool CheckSupportsProcedural(const RParticleSystem& system);
    
    static void PlaybackSubEmitterCommandBuffer(const RParticleSystem& shuriken, ParticleSystemState& state, bool fixedTimeStep);
    
    bool GetIsDistanceEmitter() const;
    size_t AddNewParticles(ParticleSystemParticles& particles, size_t newParticles) const;
    size_t LimitParticleCount(size_t requestSize) const;
    void KeepUpdating();
    
    void SetUsesAxisOfRotation();
    
    void Cull();
private:
    RParticleSystem();
    bool init() override;
    void AwakeFromLoad();
    RParticleSystem* FindGroupRoot();
    void AwakeFromLoadTree();
    void PlayTree();
    void StopTree();
    void ClearTree();
    void StopAndClearTree();
    //void WalkTree(std::function<void(RParticleSystem*)> func);
    
    void AddToManager();
    void RemoveFromManager();
    void SetUsesRotationalSpeed();
    void SetUsesEmitAccumulator(int numAccumulators);
    
    /** initializes the texture with a rectangle measured Points */
    void initTexCoordsWithRect(const cocos2d::Rect& rect, bool isrotaed, const cocos2d::Vec2& offset, const cocos2d::Vec2& originalSize);
    void setTextureInternal(cocos2d::Texture2D* spriteFrame);
    void setTextureWithRect(cocos2d::Texture2D* texture, const cocos2d::Rect& rect, bool isRotated, const cocos2d::Vec2& offset, const cocos2d::Vec2 &originalSize);

    void TransferMinMaxCurveToData(const MinMaxCurve& curve, MinMaxCurveData &data) const;
    void TransferMinMaxCurveFromData(MinMaxCurve& curve, const MinMaxCurveData &data);
    void TransferMinMaxGradientToData(const MinMaxGradient& gradient, MinMaxGradientData &data) const;
    void TransferMinMaxGradientFromData(MinMaxGradient& gradient, const MinMaxGradientData &data);
    void TransferEmissionToData(const ParticleSystemEmissionData& emission, EmissionData &data) const;
    void TransferEmissionFromData(ParticleSystemEmissionData& emission, const EmissionData& data);

public:
    const ColorModule* GetColorModule() const { return m_ColorModule; }
    const ColorBySpeedModule* GetColorBySpeedModule() const { return m_ColorBySpeedModule; }
    const SizeModule* GetSizeModule() const { return m_SizeModule; }
    const SizeBySpeedModule* GetSizeBySpeedModule() const { return m_SizeBySpeedModule; }

    // Getters Setters for Editor
    // m_ReadOnlyState
    void setLengthInSec(float value) { m_ReadOnlyState->lengthInSec = value; }
    float getLengthInSec() const { return m_ReadOnlyState->lengthInSec; }
    void setStartDelay(float value) { m_ReadOnlyState->startDelay = value; }
    float getStartDelay() const { return m_ReadOnlyState->startDelay; }
    void setSpeed(float value) { m_ReadOnlyState->speed = value; }
    float getSpeed() const { return m_ReadOnlyState->speed; }
    void setRandomSeed(UInt32 value) { m_ReadOnlyState->randomSeed = value; }
    UInt32 getRandomSeed() const { return m_ReadOnlyState->randomSeed; }
    void setLooping(bool value) { m_ReadOnlyState->looping = value; }
    bool getLooping() const { return m_ReadOnlyState->looping; }
    void setPrewarm(bool value) { m_ReadOnlyState->prewarm = value; }
    bool getPrewarm() const { return m_ReadOnlyState->prewarm; }
    void setScalingMode(int value) { m_ReadOnlyState->scalingMode = value; }
    int getScalingMode() const { return m_ReadOnlyState->scalingMode; }
    void setPlayOnAwake(bool value) { m_ReadOnlyState->playOnAwake = value; }
    bool getPlayOnAwake() const { return m_ReadOnlyState->playOnAwake; }
    void setUseLocalSpace(bool value) { m_ReadOnlyState->useLocalSpace = value; }
    bool getUseLocalSpace() const { return m_ReadOnlyState->useLocalSpace; }

    // m_InitialModule
//    void setInitialModuleEnabled(bool value) { m_InitialModule.SetEnabled(value); }
//    bool getInitialModuleEnabled() const { return m_InitialModule.GetEnabled(); }
    void setInitialModuleLifetime(const MinMaxCurveData& value) {
        TransferMinMaxCurveFromData(m_InitialModule.GetLifeTimeCurve(), value);
    }
    MinMaxCurveData getInitialModuleLifetime() const {
        MinMaxCurveData data;
        TransferMinMaxCurveToData(m_InitialModule.GetLifeTimeCurve(), data);
        return data;
    }
    void setInitialModuleSpeed(const MinMaxCurveData& value) {
        TransferMinMaxCurveFromData(m_InitialModule.GetSpeedCurve(), value);
    }
    MinMaxCurveData getInitialModuleSpeed() const {
        MinMaxCurveData data;
        TransferMinMaxCurveToData(m_InitialModule.GetSpeedCurve(), data);
        return data;
    }
    void setInitialModuleColor(const MinMaxGradientData& value) {
        TransferMinMaxGradientFromData(m_InitialModule.GetColor(), value);
    }
    MinMaxGradientData getInitialModuleColor() const {
        MinMaxGradientData data;
        TransferMinMaxGradientToData(m_InitialModule.GetColor(), data);
        return data;
    }
    void setInitialModuleSize(const MinMaxCurveData& value) {
        TransferMinMaxCurveFromData(m_InitialModule.GetSizeCurve(), value);
    }
    MinMaxCurveData getInitialModuleSize() const {
        MinMaxCurveData data;
        TransferMinMaxCurveToData(m_InitialModule.GetSizeCurve(), data);
        return data;
    }
    void setInitialModuleRotation(const MinMaxCurveData& value) {
        TransferMinMaxCurveFromData(m_InitialModule.GetRotationCurve(), value);
    }
    MinMaxCurveData getInitialModuleRotation() const {
        MinMaxCurveData data;
        TransferMinMaxCurveToData(m_InitialModule.GetRotationCurve(), data);
        return data;
    }
    void setInitialModuleGravityModifier(float value) { m_InitialModule.SetGravityModifier(value); }
    float getInitialModuleGravityModifier() const { return m_InitialModule.GetGravityModifier(); }
    void setInitialModuleInheritVelocity(float value) { m_InitialModule.SetInheritVelocity(value); }
    float getInitialModuleInheritVelocity() const { return m_InitialModule.GetInheritVelocity(); }
    void setInitialModuleMaxNumParticles(int value) { m_InitialModule.SetMaxNumParticles(value); }
    int getInitialModuleMaxNumParticles() const { return m_InitialModule.GetMaxNumParticles(); }

    // m_EmissionModule
    void setEmissionModuleEnabled(bool value) { m_EmissionModule.SetEnabled(value); }
    bool getEmissionModuleEnabled() const { return m_EmissionModule.GetEnabled(); }
    void setEmissionModuleType(int value) { m_EmissionModule.GetEmissionData().type = value; }
    int getEmissionModuleType() const { return m_EmissionModule.GetEmissionData().type; }
    void setEmissionModuleRate(const MinMaxCurveData& value) {
        TransferMinMaxCurveFromData(m_EmissionModule.GetEmissionData().rate, value);
    }
    MinMaxCurveData getEmissionModuleRate() const {
        MinMaxCurveData data;
        TransferMinMaxCurveToData(m_EmissionModule.GetEmissionData().rate, data);
        return data;
    }
    /*
    void setEmissionModuleBurstTime0(float value) { m_EmissionModule.GetEmissionData().burstTime[0] = value; }
    float getEmissionModuleBurstTime0() const { return m_EmissionModule.GetEmissionData().burstTime[0]; }
    void setEmissionModuleBurstTime1(float value) { m_EmissionModule.GetEmissionData().burstTime[1] = value; }
    float getEmissionModuleBurstTime1() const { return m_EmissionModule.GetEmissionData().burstTime[1]; }
    void setEmissionModuleBurstTime2(float value) { m_EmissionModule.GetEmissionData().burstTime[2] = value; }
    float getEmissionModuleBurstTime2() const { return m_EmissionModule.GetEmissionData().burstTime[2]; }
    void setEmissionModuleBurstTime3(float value) { m_EmissionModule.GetEmissionData().burstTime[3] = value; }
    float getEmissionModuleBurstTime3() const { return m_EmissionModule.GetEmissionData().burstTime[3]; }
    void setEmissionModuleBurstParticleCount0(UInt16 value) { m_EmissionModule.GetEmissionData().burstParticleCount[0] = value; }
    UInt16 getEmissionModuleBurstParticleCount0() const { return m_EmissionModule.GetEmissionData().burstParticleCount[0]; }
    void setEmissionModuleBurstParticleCount1(UInt16 value) { m_EmissionModule.GetEmissionData().burstParticleCount[1] = value; }
    UInt16 getEmissionModuleBurstParticleCount1() const { return m_EmissionModule.GetEmissionData().burstParticleCount[1]; }
    void setEmissionModuleBurstParticleCount2(UInt16 value) { m_EmissionModule.GetEmissionData().burstParticleCount[2] = value; }
    UInt16 getEmissionModuleBurstParticleCount2() const { return m_EmissionModule.GetEmissionData().burstParticleCount[2]; }
    void setEmissionModuleBurstParticleCount3(UInt16 value) { m_EmissionModule.GetEmissionData().burstParticleCount[3] = value; }
    UInt16 getEmissionModuleBurstParticleCount3() const { return m_EmissionModule.GetEmissionData().burstParticleCount[3]; }
    void setEmissionModuleBurstCount(UInt8 value) { m_EmissionModule.GetEmissionData().burstCount = value; }
    UInt8 getEmissionModuleBurstCount() const { return m_EmissionModule.GetEmissionData().burstCount; }
     */
    void setEmissionModuleBurstData(const EmissionData& value);
    EmissionData getEmissionModuleBurstData() const {
        EmissionData data;
        TransferEmissionToData(m_EmissionModule.GetEmissionData(), data);
        return data;
    }

    // m_ShapeModule
    void setShapeModuleEnabled(bool value) { m_ShapeModule.SetEnabled(value); }
    bool getShapeModuleEnabled() const { return m_ShapeModule.GetEnabled(); }
    void setShapeModuleType(int value) { m_ShapeModule.SetType(value); }
    int getShapeModuleType() const { return m_ShapeModule.GetType(); }
    void setShapeModuleRadius(float value) { m_ShapeModule.SetRadius(value); }
    float getShapeModuleRadius() const { return m_ShapeModule.GetRadius(); }
    void setShapeModuleRadiusThickness(float value) { m_ShapeModule.SetRadiusThickness(value); }
    float getShapeModuleRadiusThickness() const { return m_ShapeModule.GetRadiusThickness(); }
    void setShapeModuleAngle(float value) { m_ShapeModule.SetAngle(value); }
    float getShapeModuleAngle() const { return m_ShapeModule.GetAngle(); }
    void setShapeModuleLength(float value) { m_ShapeModule.SetLength(value); }
    float getShapeModuleLength() const { return m_ShapeModule.GetLength(); }
    void setShapeModuleArc(float value) { m_ShapeModule.SetArc(value); }
    float getShapeModuleArc() const { return m_ShapeModule.GetArc(); }
    void setShapeModuleBurstSpread(bool value) { m_ShapeModule.SetBurstSpread(value); }
    bool getShapeModuleBurstSpread() const { return m_ShapeModule.GetBurstSpread(); }
    void setShapeModuleSpreadSpaceThickness(float value) { m_ShapeModule.SetSpreadSpaceThickness(value); }
    float getShapeModuleSpreadSpaceThickness() const { return m_ShapeModule.GetSpreadSpaceThickness(); }
    void setShapeModuleBoxX(float value) { m_ShapeModule.SetBoxX(value); }
    float getShapeModuleBoxX() const { return m_ShapeModule.GetBoxX(); }
    void setShapeModuleBoxY(float value) { m_ShapeModule.SetBoxY(value); }
    float getShapeModuleBoxY() const { return m_ShapeModule.GetBoxY(); }
    void setShapeModuleBoxZ(float value) { m_ShapeModule.SetBoxZ(value); }
    float getShapeModuleBoxZ() const { return m_ShapeModule.GetBoxZ(); }
    void setShapeModuleRandomDirection(bool value) { m_ShapeModule.SetRandomDirection(value); }
    bool getShapeModuleRandomDirection() const { return m_ShapeModule.GetRandomDirection(); }

    // m_RotationModule
    void setRotationModuleEnabled(bool value);
    bool getRotationModuleEnabled() const;
    void setRotationModuleRate(const MinMaxCurveData& value);
    MinMaxCurveData getRotationModuleRate() const;

    // m_CollisionModule
    

    // m_SubModule
    /*
    void setSubModuleEnabled(bool value);
    bool getSubModuleEnabled() const;
    void setSubModuleEmittersBirthID0(int value);
    int getSubModuleEmittersBirthID0() const;
    void setSubModuleEmittersBirthID1(int value);
    int getSubModuleEmittersBirthID1() const;
    void setSubModuleEmittersCollisionID0(int value);
    int getSubModuleEmittersCollisionID0() const;
    void setSubModuleEmittersCollisionID1(int value);
    int getSubModuleEmittersCollisionID1() const;
    void setSubModuleEmittersDeathID0(int value);
    int getSubModuleEmittersDeathID0() const;
    void setSubModuleEmittersDeathID1(int value);
    int getSubModuleEmittersDeathID1() const;
     */
    
    // m_SubEmitterModule
    void setSubEmitterModuleEnabled(bool value);
    bool getSubEmitterModuleEnabled() const;
    void setSubEmitterModuleSubEmitterType(int value);
    int getSubEmitterModuleSubEmitterType() const;
    bool getSubEmitterModuleInheritColor() const;
    void setSubEmitterModuleInheritColor(bool value);
    bool getSubEmitterModuleInheritSize() const;
    void setSubEmitterModuleInheritSize(bool value);
    bool getSubEmitterModuleInheritRotation() const;
    void setSubEmitterModuleInheritRotation(bool value);
    bool getSubEmitterModuleInheritLifetime() const;
    void setSubEmitterModuleInheritLifetime(bool value);
    bool getSubEmitterModuleInheritDuration() const;
    void setSubEmitterModuleInheritDuration(bool value);

    // m_ExternalForcesModule
    void setExternalForcesModuleEnabled(bool value);
    bool getExternalForcesModuleEnabled() const;
    void setExternalForcesModuleMultiplier(float value);
    float getExternalForcesModuleMultiplier() const;

    // m_RotationBySpeedModule
    void setRotationBySpeedModuleEnabled(bool value);
    bool getRotationBySpeedModuleEnabled() const;
    void setRotationBySpeedModuleCurve(const MinMaxCurveData& value);
    MinMaxCurveData getRotationBySpeedModuleCurve() const;
    void setRotationBySpeedModuleRange(const Vector2f& value);
    const Vector2f& getRotationBySpeedModuleRange() const;

    // m_VelocityModule
    void setVelocityModuleEnabled(bool value);
    bool getVelocityModuleEnabled() const;
    void setVelocityModuleXCurve(const MinMaxCurveData& value);
    MinMaxCurveData getVelocityModuleXCurve() const;
    void setVelocityModuleYCurve(const MinMaxCurveData& value);
    MinMaxCurveData getVelocityModuleYCurve() const;
    void setVelocityModuleZCurve(const MinMaxCurveData& value);
    MinMaxCurveData getVelocityModuleZCurve() const;
    void setVelocityModuleInWorldSpace(bool value);
    bool getVelocityModuleInWorldSpace() const;

    // m_ForceModule
    void setForceModuleEnabled(bool value);
    bool getForceModuleEnabled() const;
    void setForceModuleXCurve(const MinMaxCurveData& value);
    MinMaxCurveData getForceModuleXCurve() const;
    void setForceModuleYCurve(const MinMaxCurveData& value);
    MinMaxCurveData getForceModuleYCurve() const;
    void setForceModuleZCurve(const MinMaxCurveData& value);
    MinMaxCurveData getForceModuleZCurve() const;
    void setForceModuleInWorldSpace(bool value);
    bool getForceModuleInWorldSpace() const;
    void setForceModuleRandomizePerFrame(bool value);
    bool getForceModuleRandomizePerFrame() const;

    // m_ClampVelocityModule
    void setClampVelocityModuleEnabled(bool value);
    bool getClampVelocityModuleEnabled() const;
    void setClampVelocityModuleXCurve(const MinMaxCurveData& value);
    MinMaxCurveData getClampVelocityModuleXCurve() const;
    void setClampVelocityModuleYCurve(const MinMaxCurveData& value);
    MinMaxCurveData getClampVelocityModuleYCurve() const;
    void setClampVelocityModuleZCurve(const MinMaxCurveData& value);
    MinMaxCurveData getClampVelocityModuleZCurve() const;
    void setClampVelocityModuleMagnitude(const MinMaxCurveData& value);
    MinMaxCurveData getClampVelocityModuleMagnitude() const;
    void setClampVelocityModuleDrag(const MinMaxCurveData& value);
    MinMaxCurveData getClampVelocityModuleDrag() const;
    void setClampVelocityModuleInWorldSpace(bool value);
    bool getClampVelocityModuleInWorldSpace() const;
    void setClampVelocityModuleSeparateAxis(bool value);
    bool getClampVelocityModuleSeparateAxis() const;
    void setClampVelocityModuleMultiplyDragByParticleSize(bool value);
    bool getClampVelocityModuleMultiplyDragByParticleSize() const;
    void setClampVelocityModuleMultiplyDragByParticleVelocity(bool value);
    bool getClampVelocityModuleMultiplyDragByParticleVelocity() const;
    void setClampVelocityModuleDampen(float value);
    float getClampVelocityModuleDampen() const;

    // m_SizeModule
    void setSizeModuleEnabled(bool value);
    bool getSizeModuleEnabled() const;
    void setSizeModuleCurve(const MinMaxCurveData& value);
    MinMaxCurveData getSizeModuleCurve() const;

    // m_ColorModule
    void setColorModuleEnabled(bool value);
    bool getColorModuleEnabled() const;
    void setColorModuleGradient(const MinMaxGradientData& value);
    MinMaxGradientData getColorModuleGradient() const;

    // m_UVModule
    void setUVModuleEnabled(bool value);
    bool getUVModuleEnabled() const;
    void setUVModuleCurve(const MinMaxCurveData& value);
    MinMaxCurveData getUVModuleCurve() const;
    void setUVModuleTilesX(int value);
    int getUVModuleTilesX() const;
    void setUVModuleTilesY(int value);
    int getUVModuleTilesY() const;
    void setUVModuleAnimationType(int value);
    int getUVModuleAnimationType() const;
    void setUVModuleRowIndex(int value);
    int getUVModuleRowIndex() const;
    void setUVModuleCycles(float value);
    float getUVModuleCycles() const;
    void setUVModuleRandomRow(bool value);
    bool getUVModuleRandomRow() const;
    void setUVModuleMode(int value);
    int getUVModuleMode() const;
    void setUVModuleFrameNamePrefix(const std::string& value);
    const std::string& getUVModuleFrameNamePrefix() const;
    void setUVModuleFrameStartIndex(int value);
    int getUVModuleFrameStartIndex() const;
    void setUVModuleFrameEndIndex(int value);
    int getUVModuleFrameEndIndex() const;
    void setUVModuleFrameCount(int value);
    int getUVModuleFrameCount() const;

    // m_SizeBySpeedModule
    void setSizeBySpeedModuleEnabled(bool value);
    bool getSizeBySpeedModuleEnabled() const;
    void setSizeBySpeedModuleCurve(const MinMaxCurveData& value);
    MinMaxCurveData getSizeBySpeedModuleCurve() const;
    void setSizeBySpeedModuleRange(const Vector2f& value);
    const Vector2f& getSizeBySpeedModuleRange() const;

    // m_ColorBySpeedModule
    void setColorBySpeedModuleEnabled(bool value);
    bool getColorBySpeedModuleEnabled() const;
    void setColorBySpeedModuleGradient(const MinMaxGradientData& value);
    MinMaxGradientData getColorBySpeedModuleGradient() const;
    void setColorBySpeedModuleRange(const Vector2f& value);
    const Vector2f& getColorBySpeedModuleRange() const;

    // m_renderer
    void setRendererOrthographic(bool orthographic);
    bool getRendererOrthographic() const;
    void setRendererScale(float value);
    float getRendererScale() const;
    void setRendererRenderMode(int value);
    int getRendererRenderMode() const;
    void setRendererSortMode(int value);
    int getRendererSortMode() const;
    void setRendererMaxParticleSize(float value);
    float getRendererMaxParticleSize() const;
    void setRendererCameraVelocityScale(float value);
    float getRendererCameraVelocityScale() const;
    void setRendererVelocityScale(float value);
    float getRendererVelocityScale() const;
    void setRendererLengthScale(float value);
    float getRendererLengthScale() const;
    void setRendererSortingFudge(float value);
    float getRendererSortingFudge() const;
    void setRendererNormalDirection(float value);
    float getRendererNormalDirection() const;

    // Material, Texture, Blend
    void setUseMaterialFile(bool useMaterialFile) { _useMaterialFile = useMaterialFile; }
    bool getUseMaterialFile() const { return _useMaterialFile; }
    
    void setBlendFunc(const cocos2d::BlendFunc &blendFunc) override;
    const cocos2d::BlendFunc& getBlendFunc() const override { return _blendFunc; }
    
    void setDisplayFrame(cocos2d::SpriteFrame *spriteFrame);
    virtual void setTexture(cocos2d::Texture2D *texture) override;
    virtual cocos2d::Texture2D* getTexture() const override { return _texture; }
    virtual void updateBlendFunc();
    
    // m_Material
    void setMaterial(cocos2d::Material* material) {
        m_Material = material;
        if (_useMaterialFile && material) {
            _isSpriteFrame = false;
            //initTexCoordsWithRect(cocos2d::Rect(0, 0, 1, 1), false, Vector2f::ZERO, Vector2f::ONE);
            _vertexInfo = RRP_PARTICLEQUAD_VERTEX_INFO(RRP_PARTICLEQUAD_BORDER(), cocos2d::Tex2F(0, 1), cocos2d::Tex2F(1, 1), cocos2d::Tex2F(0, 0), cocos2d::Tex2F(1, 0));
        }
    }
    void setMaterialFile(const std::string& materialFile) {
        _materialFile = materialFile;
        auto mat = cocos2d::Material::createWithFilename(_materialFile);
        setMaterial(mat);
    }
    const std::string& getMaterialFile() const {
        return _materialFile;
    }
    
    void allocMemory(int particleCount);
    
private:
    int m_EmittersIndex;
    ParticleSystemParticles             m_ParticlesStaging; // staging buffer for emitting into the emitter
    ParticleSystemParticles             m_Particles[kNumParticleBuffers];
    ParticleSystemReadOnlyState*        m_ReadOnlyState;
    ParticleSystemState*                m_State;
    
    InitialModule                       m_InitialModule;
    EmissionModule                      m_EmissionModule;
    ShapeModule                         m_ShapeModule;
    
    RotationModule*                     m_RotationModule;
    CollisionModule*                    m_CollisionModule;
    SubModule*                          m_SubModule;
    SubEmitterModule*                   m_SubEmitterModule;
    ExternalForcesModule*               m_ExternalForcesModule;
    
    RotationBySpeedModule*              m_RotationBySpeedModule;
    
    // Dependent on energy value
    VelocityModule*                     m_VelocityModule;
    ForceModule*                        m_ForceModule;
    // Depends on velocity and modifies velocity
    ClampVelocityModule*                m_ClampVelocityModule;
    
    
    // Dependent on energy value
    SizeModule*                         m_SizeModule;
    ColorModule*                        m_ColorModule;
    UVModule*                           m_UVModule;
    
    // Dependent on velocity value
    SizeBySpeedModule*                  m_SizeBySpeedModule;
    ColorBySpeedModule*                 m_ColorBySpeedModule;
    
    ParticleSystemRenderer*             m_renderer;

    bool _useMaterialFile;
    cocos2d::BlendFunc _blendFunc;
    cocos2d::RefPtr<cocos2d::Texture2D> _texture;
    cocos2d::RefPtr<cocos2d::Material>  m_Material;
    std::string _materialFile;

    cocos2d::V3F_C4B_T2F_Quad* _quads;        // quads to be rendered
    int _quadCount;
    bool _opacityModifyRGB;
    RRP_PARTICLEQUAD_VERTEX_INFO _vertexInfo;
    bool _isSpriteFrame;

public:
    virtual void update(float dt) override;
    
    friend class ParticleSystemRenderer;
};

NS_RRP_END

#endif /* RParticleSystem_h */