cocos2d-x节点（CCParticleSystem.h)API

本文来自http://blog.csdn.net/runaying ，引用必须注明出处！

cocos2d-x节点（CCParticleSystem.h)API

温馨提醒：为了大家能更好学习，强烈推荐大家看看本人的这篇博客 Cocos2d-X权威指南笔记

粒子系统的基类，重力模式、半径模式     备注：变动 是，每一次 增减/减少 的固定值

///cocos2d-x-3.0alpha0/cocos2dx/particle_nodes
//粒子系统的基类，重力模式、半径模式     备注：变动 是，每一次 增减/减少 的固定值

#ifndef __CCPARTICLE_SYSTEM_H__
#define __CCPARTICLE_SYSTEM_H__

#include "CCProtocols.h"
#include "base_nodes/CCNode.h"
#include "cocoa/CCDictionary.h"
#include "cocoa/CCString.h"

NS_CC_BEGIN

/**
 * @addtogroup particle_nodes
 * @{
 */

class ParticleBatchNode;

/**
包含每个粒子的值的结构
*/
typedef struct sParticle {
    Point     pos;
    Point     startPos;

    Color4F    color;
    Color4F    deltaColor;

    float        size;
    float        deltaSize;

    float        rotation;
    float        deltaRotation;

    float        timeToLive;

    unsigned int    atlasIndex;

    //! Mode A: gravity, direction, radial accel, tangential accel      //重力，方向，径向加速度，切向加速度
    struct {
        Point        dir;
        float        radialAccel;
        float        tangentialAccel;
    } modeA;

    //! Mode B: radius mode
    struct {
        float        angle;
        float        degreesPerSecond;
        float        radius;
        float        deltaRadius;
    } modeB;

}tParticle;

//typedef void (*CC_UPDATE_PARTICLE_IMP)(id, SEL, tParticle*, Point);

class Texture2D;

/** @brief 粒子系统的基类。
一个粒子系统的属性:
- 颗粒的发射率
- 重力模式 (Mode A):
- gravity               //重力
- direction             //方向
- speed +-  variance        //速度 ＋ －变动
- tangential acceleration +- variance       //切向加速度+ - 变动
- radial acceleration +- variance           //径向加速度+ - 变动
- Radius Mode (Mode B):         //半径模式
- startRadius +- variance           //开始半径+- 变动
- endRadius +- variance           //结束半径+- 变动
- rotate +- variance                //环绕 +- 变动
- Properties common to all modes:       //所有模式共同的属性
- life +- life variance         //life 变动
- start spin +- variance        //开始旋转+ - 变动
- end spin +- variance          //结束旋转+ - 变动
- start size +- variance        //初始尺寸+- 变动
- end size +- variance        //结束尺寸+- 变动
- start color +- variance        //初始+- 变动
- end color +- variance        //结束尺寸+- 变动
- life +- variance              //生命值 +- 变动
- blending function             //混合功能
- texture

cocos2d 也支持 Particle Designer 生成 particles (http://particledesigner.71squared.com/).
 Particle Designer 的 'Radius Mode'使用 30 hz 的固定发射率. 在 cocos2d 里面不能保证
cocos2d 中采用了另一种方法，但结果几乎是相同的

 Particle Designer 支持所有 cocos2d 变量，在加上下面一些：
- spinning particles (supported when using ParticleSystemQuad)      //自旋粒子（使用ParticleSystemQuad时支持）
- tangential acceleration (Gravity mode)        //切向加速度（重力模式）
- radial acceleration (Gravity mode)
- radius direction (Radius mode) (Particle Designer supports outwards to inwards direction only)    //半径方向（半径模式）（(Particle Designer 只支持从外向内的方向）

在运行时可以自定义任何上述物品,例如:

@code
emitter.radialAccel = 15;   //发射器的径向加速
emitter.startSpin = 0;      //发射器的开始旋转
@endcode

*/
class CC_DLL ParticleSystem : public Node, public TextureProtocol
{
public:
    enum class Mode
    {
        GRAVITY,
        RADIUS,
    };
    
    /** @typedef PositionType
     粒子位置的可能类型
     */
    enum class PositionType
    {
        /** 附着于世界的 Living particles 受发射器重新定位影响. */
        FREE,
        
        /** 附着于世界的 Living particles  遵循发射器的重新定位。
         使用情况: 在 sprite 上附加发射器，你希望发射器跟随 sprite.
         */
        RELATIVE,
        
        /** Living particles 附着于发射器，和跟随它一起转换. */
        GROUPED,
    };
    
    //* @enum
    enum {
        /** 粒子发射器永远 lives */
        DURATION_INFINITY = -1,
        
        /** 粒子的初始尺寸，等于结束尺寸 */
        START_SIZE_EQUAL_TO_END_SIZE = -1,
        
        /** 粒子的起始半径等于结束半径 */
        START_RADIUS_EQUAL_TO_END_RADIUS = -1,
    };
    
    /** 从一个plist文件创建并初始化一个粒子系统，这个plist文件可以手动创建或者使用  Particle Designer 创建:
    http://particledesigner.71squared.com/
    @since v2.0
    */
    static ParticleSystem * create(const char *plistFile);

    //! 使用 固定数量的颗粒 建立一个系统
    static ParticleSystem* createWithTotalParticles(unsigned int numberOfParticles);
    /**
     * @js ctor
     */
    ParticleSystem();
    /**
     * @js NA
     * @lua NA
     */
    virtual ~ParticleSystem();

    /** 初始化一个 ParticleSystem*/
    bool init();
    /** 从一个plist文件创建并初始化一个粒子系统，这个plist文件可以手动创建或者使用  Particle Designer 创建:
    http://particledesigner.71squared.com/
    @since v0.99.3
    */
    bool initWithFile(const char *plistFile);

    /** 使用 Dictionary 初始化一个 QuadParticleSystem .
    @since v0.99.3
    */
    bool initWithDictionary(Dictionary *dictionary);
    
    /** 使用 NSDictionary，需要加载的 png 文件路径 初始化一个 particle system
     @since v2.1
     */
    bool initWithDictionary(Dictionary *dictionary, const char *dirname);

    //! 使用 固定数量的颗粒 初始化一个系统
    virtual bool initWithTotalParticles(unsigned int numberOfParticles);

    //! 添加粒子到发射器
    bool addParticle();
    //! 初始化粒子
    void initParticle(tParticle* particle);
    //! 停止发射粒子。运行的粒子将继续运行，直到他们死了
    void stopSystem();
    //! 杀死所有 living 粒子。
    void resetSystem();
    //! whether or not the system is full       //系统是否充满
    bool isFull();

    //! 应该由子类重写
    virtual void updateQuadWithParticle(tParticle* particle, const Point& newPosition);
    //! 应该由子类重写
    virtual void postStep();

    virtual void updateWithNoTime(void);

    virtual bool isAutoRemoveOnFinish() const;
    virtual void setAutoRemoveOnFinish(bool var);

    // mode A
    virtual const Point& getGravity();
    virtual void setGravity(const Point& g);
    virtual float getSpeed() const;
    virtual void setSpeed(float speed);
    virtual float getSpeedVar() const;
    virtual void setSpeedVar(float speed);
    virtual float getTangentialAccel() const;
    virtual void setTangentialAccel(float t);
    virtual float getTangentialAccelVar() const;
    virtual void setTangentialAccelVar(float t);
    virtual float getRadialAccel() const;
    virtual void setRadialAccel(float t);
    virtual float getRadialAccelVar() const;
    virtual void setRadialAccelVar(float t);
    virtual bool getRotationIsDir() const;
    virtual void setRotationIsDir(bool t);
    // mode B
    virtual float getStartRadius() const;
    virtual void setStartRadius(float startRadius);
    virtual float getStartRadiusVar() const;
    virtual void setStartRadiusVar(float startRadiusVar);
    virtual float getEndRadius() const;
    virtual void setEndRadius(float endRadius);
    virtual float getEndRadiusVar() const;
    virtual void setEndRadiusVar(float endRadiusVar);
    virtual float getRotatePerSecond() const;
    virtual void setRotatePerSecond(float degrees);
    virtual float getRotatePerSecondVar() const;
    virtual void setRotatePerSecondVar(float degrees);

    virtual void setScale(float s);
    virtual void setRotation(float newRotation);
    virtual void setScaleX(float newScaleX);
    virtual void setScaleY(float newScaleY);

    virtual bool isActive() const;
    virtual bool isBlendAdditive() const;
    virtual void setBlendAdditive(bool value);

    virtual ParticleBatchNode* getBatchNode() const;
    virtual void setBatchNode(ParticleBatchNode* batchNode);
    
    // 批处理 array 系统的索引
    inline int getAtlasIndex() const { return _atlasIndex; };
    inline void setAtlasIndex(int index) { _atlasIndex = index; };

    /** 当前时刻被模拟的粒子数量 */
    inline unsigned int getParticleCount() const { return _particleCount; };
    
    /** 发射器将运行多少秒. -1 意味着 'forever' */
    inline float getDuration() const { return _duration; };
    inline void setDuration(float duration) { _duration = duration; };
    
    /** sourcePosition of the emitter（发射源的位置） */
    inline const Point& getSourcePosition() const { return _sourcePosition; };
    inline void setSourcePosition(const Point& pos) { _sourcePosition = pos; };
    
    /** 发射器位置的变动量 */
    inline const Point& getPosVar() const { return _posVar; };
    inline void setPosVar(const Point& pos) { _posVar = pos; };

    /** life, 每个粒子的 life 变动量 */
    inline float getLife() const { return _life; };
    inline void setLife(float life) { _life = life; };

    /** 每个粒子的 life 变动量 */
    inline float getLifeVar() const { return _lifeVar; };
    inline void setLifeVar(float lifeVar) { _lifeVar = lifeVar; };

    /** angle ，每个粒子的角度变化量 */
    inline float getAngle() const { return _angle; };
    inline void setAngle(float angle) { _angle = angle; };

    /** 每个粒子的角度变化量 */
    inline float getAngleVar() const { return _angleVar; };
    inline void setAngleVar(float angleVar) { _angleVar = angleVar; };
    
    /** 不同类型的发射模式之间的切换:
     - kParticleModeGravity: uses gravity, speed, radial and tangential acceleration
     - kParticleModeRadius: uses radius movement + rotation
     */
    inline Mode getEmitterMode() const { return _emitterMode; };
    inline void setEmitterMode(Mode mode) { _emitterMode = mode; };
    
    /** 每个粒子的初始化时的尺寸（以像素为单位） */
    inline float getStartSize() const { return _startSize; };
    inline void setStartSize(float startSize) { _startSize = startSize; };

    /** 每个粒子的尺寸变化量（以像素为单位） */
    inline float getStartSizeVar() const { return _startSizeVar; };
    inline void setStartSizeVar(float sizeVar) { _startSizeVar = sizeVar; };

    /** 每个粒子的结束时的尺寸（以像素为单位） */
    inline float getEndSize() const { return _endSize; };
    inline void setEndSize(float endSize) { _endSize = endSize; };

    /** 结束时每个粒子的尺寸变化量（以像素为单位） */
    inline float getEndSizeVar() const { return _endSizeVar; };
    inline void setEndSizeVar(float sizeVar) { _endSizeVar = sizeVar; };

    /** 每个粒子开始颜色 */
    inline const Color4F& getStartColor() const { return _startColor; };
    inline void setStartColor(const Color4F& color) { _startColor = color; };

    /** 每个粒子开始颜色的变动量 */
    inline const Color4F& getStartColorVar() const { return _startColorVar; };
    inline void setStartColorVar(const Color4F& color) { _startColorVar = color; };

    /** end color，结束时每个粒子的颜色变化量 */
    inline const Color4F& getEndColor() const { return _endColor; };
    inline void setEndColor(const Color4F& color) { _endColor = color; };

    /** 结束时每个粒子的颜色变化量 */
    inline const Color4F& getEndColorVar() const { return _endColorVar; };
    inline void setEndColorVar(const Color4F& color) { _endColorVar = color; };

    //* 每个粒子的初始角度
    inline float getStartSpin() const { return _startSpin; };
    inline void setStartSpin(float spin) { _startSpin = spin; };

    //* 每个粒子的初始角度
    inline float getStartSpinVar() const { return _startSpinVar; };
    inline void setStartSpinVar(float pinVar) { _startSpinVar = pinVar; };

    //* 每个粒子的初始角度
    inline float getEndSpin() const { return _endSpin; };
    inline void setEndSpin(float endSpin) { _endSpin = endSpin; };

    //* 每个粒子的初始角度
    inline float getEndSpinVar() const { return _endSpinVar; };
    inline void setEndSpinVar(float endSpinVar) { _endSpinVar = endSpinVar; };

    /** 粒子的发射率 */
    inline float getEmissionRate() const { return _emissionRate; };
    inline void setEmissionRate(float rate) { _emissionRate = rate; };

    /** 系统的最大粒子 */
    virtual int getTotalParticles() const;
    virtual void setTotalParticles(int totalParticles);

    /** 使用alpha值修改颜色 */
    inline void setOpacityModifyRGB(bool opacityModifyRGB) { _opacityModifyRGB = opacityModifyRGB; };
    inline bool isOpacityModifyRGB() const { return _opacityModifyRGB; };
    CC_DEPRECATED_ATTRIBUTE inline bool getOpacityModifyRGB() const { return isOpacityModifyRGB(); }
    
    /** 粒子的运动类型：自由或分组
     @since v0.8
     */
    inline PositionType getPositionType() const { return _positionType; };
    inline void setPositionType(PositionType type) { _positionType = type; };
    
    // Overrides
    virtual void update(float dt) override;
    virtual Texture2D* getTexture() const override;
    virtual void setTexture(Texture2D *texture) override;
    /**
    *@code
    *当这个函数绑定到 js or lua,输入参数会改变
    *In js: var setBlendFunc(var src, var dst)
    *In lua: local setBlendFunc(local src, local dst)
    *@endcode
    */
    virtual void setBlendFunc(const BlendFunc &blendFunc) override;
    /**
    * @js NA
    * @lua NA
    */
    virtual const BlendFunc &getBlendFunc() const override;
protected:
    virtual void updateBlendFunc();

protected:
    /** 添加时是否使用混合功能.
     如果启用，下列混合功能将使用
     @code
     source blend function = GL_SRC_ALPHA;
     dest blend function = GL_ONE;
     @endcode
     */
    bool _isBlendAdditive;

    /** 没有 颗粒离开时，节点是否被自动删除
     By default it is false.
     @since v0.8
     */
    bool _isAutoRemoveOnFinish;

    std::string _plistFile;
    //! 从系统开始到现在所经历的时间
    float _elapsed;

    // Different modes
    //! Mode A:Gravity + Tangential Accel + Radial Accel
    struct {
        /** 重力值。仅适用于 'Gravity' 模式. */
        Point gravity;
        /** 每个粒子的速度。仅适用于 'Gravity' 模式.  */
        float speed;
        /** 每个粒子的速度变动. 仅适用于 'Gravity' 模式. */
        float speedVar;
        /** 每个粒子的切向加速度. 仅适用于 'Gravity' 模式. */
        float tangentialAccel;
        /** 每个粒子的切向加速度变动. 仅适用于 'Gravity' 模式. */
        float tangentialAccelVar;
        /** 每个粒子的径向加速度. 仅适用于 'Gravity' 模式. */
        float radialAccel;
        /** 每个粒子的径向加速度变动. 仅适用于 'Gravity' 模式. */
        float radialAccelVar;
        /** 设置每个粒子的旋转方向，仅适用于 'Gravity' 模式. */
        bool rotationIsDir;
    } modeA;

    //! Mode B: circular movement (gravity, radial accel 、 tangential accel 不要在这个模型里面使用)
    struct {
        /** 粒子的起始半径. 仅适用于 'Radius' 模式. */
        float startRadius;
        /** 粒子的起始半径变动.  仅适用于 'Radius' 模式. */
        float startRadiusVar;
        /** 结束时的粒子半径.  仅适用于 'Radius' 模式. */
        float endRadius;
        /** 结束时粒子半径变动.  仅适用于 'Radius' 模式. */
        float endRadiusVar;
        /** 源位置周围的粒子每秒旋转角度.  仅适用于 'Radius' 模式. */
        float rotatePerSecond;
        /** 每秒的旋转变动. 仅适用于 'Radius' 模式. */
        float rotatePerSecondVar;
    } modeB;

    //! 粒子 Array 
    tParticle *_particles;

    // 色彩调节
    //    BOOL colorModulate;

    //!每秒可发出多少粒子
    float _emitCounter;

    //!  particle idx
    int _particleIdx;

    // Optimization             //优化
    //CC_UPDATE_PARTICLE_IMP    updateParticleImp;
    //SEL                        updateParticleSel;

    /** the SpriteBatchNode 呈现 Sprite 是弱引用 */
    ParticleBatchNode* _batchNode;

    // 在批处理 array 里面的索引
    int _atlasIndex;

    //true 如果 缩放/旋转
    bool _transformSystemDirty;
    // 分配的粒子数
    int _allocatedParticles;

    /** 是否激活了发射器 */
    bool _isActive;
    
    /** 当前时刻被模拟的颗粒数量 */
    int _particleCount;
    /** 发射器将运行多久 -1 意味着 'forever' */
    float _duration;
    /** 发射源的位置*/
    Point _sourcePosition;
    /** 发射器的位置变动量 */
    Point _posVar;
    /** life,每个粒子的 life 变动量 */
    float _life;
    /** 每个粒子的 life 变动量 */
    float _lifeVar;
    /** angle ,每个粒子的角度变化量 */
    float _angle;
    /** 每个粒子的角度变化量 */
    float _angleVar;

    /** 不同类型的发射模式之间切换:
     - kParticleModeGravity: uses gravity, speed, radial and tangential acceleration
     - kParticleModeRadius: uses radius movement + rotation
     */
    Mode _emitterMode;

    /** 每个粒子的初始化尺寸（以像素为单位） */
    float _startSize;
    /** 每个粒子的尺寸变化量 */
    float _startSizeVar;
    /** 每个粒子的结束时的尺寸（以像素为单位） */
    float _endSize;
    /** 每个粒子的尺寸变化量*/
    float _endSizeVar;
    /** 每个粒子开始颜色 */
    Color4F _startColor;
    /** 每个粒子开始颜色的变动量 */
    Color4F _startColorVar;
    /** end color ,结束时每个粒子的颜色变化量 */
    Color4F _endColor;
    /** 结束时每个粒子的颜色变化量 */
    Color4F _endColorVar;
    //* 每个粒子的初始角度
    float _startSpin;
    //* 每个粒子的初始角度
    float _startSpinVar;
    //* 每个粒子的初始角度
    float _endSpin;
    //* 每个粒子的初始角度
    float _endSpinVar;
    /** 粒子的发射率 */
    float _emissionRate;
    /** 系统的最大粒子 */
    int _totalParticles;
    /** 符合 CocosNodeTexture 协议 */
    Texture2D* _texture;
    /** 符合 CocosNodeTexture 协议 */
    BlendFunc _blendFunc;
    /** 使用alpha值修改颜色 */
    bool _opacityModifyRGB;

    /** 粒子的运动类型：自由或分组
     @since v0.8
     */
    PositionType _positionType;
};

// end of particle_nodes group
/// @}

NS_CC_END

#endif //__CCPARTICLE_SYSTEM_H__