cocos2d-x节点（CCParticleSystem.h)API

cocos2d-x节点（CCParticleSystem.h)API

///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__