cocos2d-X 节点（CCLayer.h）API

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

cocos2d-X 节点（CCLayer.h）API

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

Layer 是 Node 的子类，它实现 TouchEventsDelegate 协议.节点的所有功能都有效，加上以下新的特点：它可以接收手机的触摸、它可以接收输入加速度
3.1启用/禁用 触摸事件/传感器事件/小键盘事件
3.2 LayerRGBA、LayerColor、LayerGradient、MultipleLayer 是 Layer 的子类,它们扩展了 layer 拥有layer 的所有功能

///cocos2d-x-3.0alpha0/cocos2dx/layers_scenes_transitions_nodes

#ifndef __CCLAYER_H__
#define __CCLAYER_H__

#include "base_nodes/CCNode.h"
#include "CCProtocols.h"
#include "cocoa/CCArray.h"
#ifdef EMSCRIPTEN
#include "base_nodes/CCGLBufferedNode.h"
#endif // EMSCRIPTEN
#include "physics/CCPhysicsSetting.h"

#include "event_dispatcher/CCEventKeyboard.h"

NS_CC_BEGIN

/**
 * @addtogroup layer
 * @{
 */

class TouchScriptHandlerEntry;

class EventListenerTouch;
class EventListenerKeyboard;
class EventListenerAcceleration;

简要

//
// Layer
//
/** @简要 Layer 是 Node 的子类，它实现 TouchEventsDelegate 协议.

节点的所有功能都有效，加上以下新的特点：
- 它可以接收iPhone触摸
- 它可以接收输入加速度
*/
class CC_DLL Layer : public Node
{
public:    
    /** 创建一个全屏的黑色层*/
    static Layer *create(void);
    /**
     * @js ctor
     */
    Layer();
    /**
     * @js NA
     * @lua NA
     */
    virtual ~Layer();
    virtual bool init();
    
    // 过时的触摸回调函数
    CC_DEPRECATED_ATTRIBUTE virtual bool ccTouchBegan(Touch *pTouch, Event *pEvent) final {CC_UNUSED_PARAM(pTouch); CC_UNUSED_PARAM(pEvent); return false;};
    CC_DEPRECATED_ATTRIBUTE virtual void ccTouchMoved(Touch *pTouch, Event *pEvent) final {CC_UNUSED_PARAM(pTouch); CC_UNUSED_PARAM(pEvent);}
    CC_DEPRECATED_ATTRIBUTE virtual void ccTouchEnded(Touch *pTouch, Event *pEvent) final {CC_UNUSED_PARAM(pTouch); CC_UNUSED_PARAM(pEvent);}
    CC_DEPRECATED_ATTRIBUTE virtual void ccTouchCancelled(Touch *pTouch, Event *pEvent) final {CC_UNUSED_PARAM(pTouch); CC_UNUSED_PARAM(pEvent);}
    
    CC_DEPRECATED_ATTRIBUTE virtual void ccTouchesBegan(Set *pTouches, Event *pEvent) final {CC_UNUSED_PARAM(pTouches); CC_UNUSED_PARAM(pEvent);}
    CC_DEPRECATED_ATTRIBUTE virtual void ccTouchesMoved(Set *pTouches, Event *pEvent) final {CC_UNUSED_PARAM(pTouches); CC_UNUSED_PARAM(pEvent);}
    CC_DEPRECATED_ATTRIBUTE virtual void ccTouchesEnded(Set *pTouches, Event *pEvent) final {CC_UNUSED_PARAM(pTouches); CC_UNUSED_PARAM(pEvent);}
    CC_DEPRECATED_ATTRIBUTE virtual void ccTouchesCancelled(Set *pTouches, Event *pEvent) final {CC_UNUSED_PARAM(pTouches); CC_UNUSED_PARAM(pEvent);}
    
    // 如果回调脚本存在默认就实现来它们
    virtual bool onTouchBegan(Touch *touch, Event *event);
    virtual void onTouchMoved(Touch *touch, Event *event);
    virtual void onTouchEnded(Touch *touch, Event *event);
    virtual void onTouchCancelled(Touch *touch, Event *event);

    // 如果回调脚本存在默认就实现来它们
    virtual void onTouchesBegan(const std::vector<Touch*>& touches, Event *event);
    virtual void onTouchesMoved(const std::vector<Touch*>& touches, Event *event);
    virtual void onTouchesEnded(const std::vector<Touch*>& touches, Event *event);
    virtual void onTouchesCancelled(const std::vector<Touch*>&touches, Event *event);
    
    /** @弃用的API请 onAcceleration */
    CC_DEPRECATED_ATTRIBUTE virtual void didAccelerate(Acceleration* accelerationValue) final {};
    
    virtual void onAcceleration(Acceleration* acc, Event* event);

    /** 如果触摸被启用了, 这个方法在 onEnter 里面被调用. 改变 layer 接受触摸事件需要重写这个方法
    ( Default: TouchDispatcher::sharedDispatcher()->addStandardDelegate(this,0); )
    Example:
    void Layer::registerWithTouchDispatcher()
    {
    TouchDispatcher::sharedDispatcher()->addTargetedDelegate(this,INT_MIN+1,true);
    }
    @since v0.8.0
    */
    CC_DEPRECATED_ATTRIBUTE virtual void registerWithTouchDispatcher() final {};

    /** 是否接受触摸事件.
   你可以通过这个属性启用/ 禁用触摸事件。
     只有这个节点的触摸有效，这个方法不会传播到他的 children
    @since v0.8.1
    */
    virtual bool isTouchEnabled() const;
    virtual void setTouchEnabled(bool value);
    
    virtual void setTouchMode(Touch::DispatchMode mode);
    virtual Touch::DispatchMode getTouchMode() const;

    /**触摸事件的 swallowsTouches. 默认是true */
    virtual void setSwallowsTouches(bool swallowsTouches);
    virtual bool isSwallowsTouches() const;

    /** 是否接收加速度传感器事件
    你可以通过这个属性启用/ 禁用加速度传感器事件
    @since v0.8.1
    */
    virtual bool isAccelerometerEnabled() const;
    virtual void setAccelerometerEnabled(bool value);
    virtual void setAccelerometerInterval(double interval);

    /** 是否接收键盘或小键盘事件事件
    你可以通过这个属性启用/ 禁用键盘或小键盘事件事件
    他是 cocos2d-x    新加入的
    */

    virtual bool isKeyboardEnabled() const;
    virtual void setKeyboardEnabled(bool value);
    
    /** 请使用 onKeyPressed 替代. */
    virtual void keyPressed(int keyCode) final {};
    
    /** 请使用 onKeyReleased 替代. */
    virtual void keyReleased(int keyCode) final {};     //释放
    
    virtual void onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event);
    virtual void onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event);

    CC_DEPRECATED_ATTRIBUTE virtual bool isKeypadEnabled() const final { return isKeyboardEnabled(); };
    CC_DEPRECATED_ATTRIBUTE virtual void setKeypadEnabled(bool value) { setKeyboardEnabled(value); };

    /** @弃用的 API 请检查 KeyboardEvent::KeyCode::Menu(KEY_BACKSPACE) 的键码，重写 onKeyReleased 代替. */
    CC_DEPRECATED_ATTRIBUTE virtual void keyBackClicked() final {};
    CC_DEPRECATED_ATTRIBUTE virtual void keyMenuClicked() final {};
    //
    // Overrides
    //
    /**
     * @js NA
     * @lua NA
     */
    virtual void onEnter() override;
    /**
     * @js NA
     * @lua NA
     */
    virtual void onExit() override;
    /**
     * @js NA
     * @lua NA
     */
    virtual void onEnterTransitionDidFinish() override;
    
#ifdef CC_USE_PHYSICS
    virtual void addChild(Node* child) override;
    virtual void addChild(Node* child, int zOrder) override;
    virtual void addChild(Node* child, int zOrder, int tag) override;
#endif // CC_USE_PHYSICS

protected:
    void addTouchListener();
    
    bool _touchEnabled;
    bool _accelerometerEnabled;
    bool _keyboardEnabled;
    EventListenerTouch* _touchListener;
    EventListenerKeyboard* _keyboardListener;
    EventListenerAcceleration* _accelerationListener;
private:
    Touch::DispatchMode _touchMode;
    bool _swallowsTouches;
    
    int executeScriptTouchHandler(EventTouch::EventCode eventType, Touch* touch);
    int executeScriptTouchesHandler(EventTouch::EventCode eventType, const std::vector<Touch*>& touches);
};

LayerRGBA

#ifdef __apple__
#pragma mark -
#pragma mark LayerRGBA
#endif

/** LayerRGBA 是 Layer 的子类，他实现了 RGBAProtocol 协议，使用实心的颜色作为背景
 Layer 的所有属性都有效,再加上一下新的特点，传播到符合 children 的 RGBAProtocol:
 - opacity          //  不透明度
 - RGB colors
 @since 2.1
 */
class CC_DLL LayerRGBA : public Layer, public RGBAProtocol
{
public:
    CREATE_FUNC(LayerRGBA);
    /**
     * @js ctor
     */
    LayerRGBA();
    /**
     * @js NA
     * @lua NA
     */
    virtual ~LayerRGBA();
    
    virtual bool init();

    //
    // Overrides
    //
    virtual GLubyte getOpacity() const override;
    virtual GLubyte getDisplayedOpacity() const override;
    virtual void setOpacity(GLubyte opacity) override;
    virtual void updateDisplayedOpacity(GLubyte parentOpacity) override;
    virtual bool isCascadeOpacityEnabled() const override;
    virtual void setCascadeOpacityEnabled(bool cascadeOpacityEnabled) override;
    
    virtual const Color3B& getColor() const override;
    virtual const Color3B& getDisplayedColor() const override;
    virtual void setColor(const Color3B& color) override;
    virtual void updateDisplayedColor(const Color3B& parentColor) override;
    virtual bool isCascadeColorEnabled() const override;
    virtual void setCascadeColorEnabled(bool cascadeColorEnabled) override;
    
    virtual void setOpacityModifyRGB(bool bValue) override {CC_UNUSED_PARAM(bValue);}
    virtual bool isOpacityModifyRGB() const override { return false; }
protected:
	GLubyte		_displayedOpacity, _realOpacity;
	Color3B	    _displayedColor, _realColor;
	bool		_cascadeOpacityEnabled, _cascadeColorEnabled;
};

LayerColor

//
// LayerColor
//
/** @brief LayerColor 是 Layer的子类它实现了 RGBAProtocol 协议.

Layer 的所有属性都有效,再加上一下新的特点:
- opacity           //不透明度
- RGB colors
*/
class CC_DLL LayerColor : public LayerRGBA, public BlendProtocol
#ifdef EMSCRIPTEN
, public GLBufferedNode
#endif // EMSCRIPTEN
{
public:
    /** 创建一个全屏的黑色层 */
    static LayerColor* create();
    /** 根据指定的颜色创建一个 layer, width 和 height 都是以点为单位的 */
    static LayerColor * create(const Color4B& color, GLfloat width, GLfloat height);
    /** 根据指定的颜色创建一个 layer, width 和 height 是窗口的尺寸. */
    static LayerColor * create(const Color4B& color);
    /**
     * @js ctor
     */
    LayerColor();
    /**
     * @js NA
     * @lua NA
     */
    virtual ~LayerColor();

    virtual bool init();
    /** 根据指定的颜色初始化一个 layer, width 和 height 都是以点为单位的
     * @js init
     * @lua init
     */
    bool initWithColor(const Color4B& color, GLfloat width, GLfloat height);
    /** 根据指定的颜色初始化一个 layer, width 和 height 是窗口的尺寸. 
     * @js init
     * @lua init
     */
    bool initWithColor(const Color4B& color);

    /** 改变宽度点数*/
    void changeWidth(GLfloat w);
    /** 改变高度点数*/
    void changeHeight(GLfloat h);
    /** 改变宽、高点数
    @since v0.8
    */
    void changeWidthAndHeight(GLfloat w ,GLfloat h);

    //
    // Overrides
    //
    virtual void draw() override;
    virtual void setColor(const Color3B &color) override;
    virtual void setOpacity(GLubyte opacity) override;
    virtual void setContentSize(const Size & var) override;
    /** BlendFunction 符合 BlendProtocol 协议 */
    /**
    * @js NA
    * @lua NA
    */
    virtual const BlendFunc& getBlendFunc() const override;
    /**
    *@code
    *当这个功能绑定到 js 或者 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;

protected:
    virtual void updateColor();

    BlendFunc _blendFunc;
    Vertex2F _squareVertices[4];
    Color4F  _squareColors[4];
};

LayerGradient

//
// LayerGradient        梯度 Layer
//
/** @brief LayerGradient 是 LayerColor 的子类用来绘制整个背景的渐变

LayerColor 的所有功能都有效，加上以下新的特点：:
- direction                 //方向
- final color
- interpolation mode        //插补模式

 StartColor 和 endColor ，之间的沿给定载体（在原点开始，结束在总站）之间的颜色插值。如果没有提供载体，它默认为（0，-1） - 淡入淡出从上到下。 
 如果'compressedInterpolation'被禁用，你将不会看到起点或结束颜色的 non-cardinal ;但是一个平滑渐变将仍然在两个端点之间显示
如果'compressedInterpolation'启用（默认模式），你会看到的开始和结束的颜色渐变.

@since v0.99.5
*/
class CC_DLL LayerGradient : public LayerColor
{
public:
    /** 创建一个全屏的黑色层 */
    static LayerGradient* create();

    /** 使用开始和结束之间的颜色渐变，创建一个全屏幕的 Layer*/
    static LayerGradient* create(const Color4B& start, const Color4B& end);

    /** 在 v 方向上，使用开始和结束之间的颜色渐变，创建一个全屏幕的 Layer. */
    static LayerGradient* create(const Color4B& start, const Color4B& end, const Point& v);

    virtual bool init();
    /** 使用开始和结束之间的颜色渐变，初始化一个 Layer. 
     * @js init
     * @lua init
     */
    bool initWithColor(const Color4B& start, const Color4B& end);

    /** 在 v 方向上，使用开始和结束之间的颜色渐变，初始化一个 Layer. 
     * @js init
     * @lua init
     */
    bool initWithColor(const Color4B& start, const Color4B& end, const Point& v);
    
    /** 是否在 规范/非规范 的载体上压缩插值，以便显示所有颜色的梯度
     Default: true
     */
    void setCompressedInterpolation(bool bCompressedInterpolation);
    bool isCompressedInterpolation() const;

    /** Sets 渐变梯度的开始颜色 */
    void setStartColor( const Color3B& startColor );
    /** Returns 渐变梯度的开始颜色 */
    const Color3B& getStartColor() const;

    /** Sets 渐变梯度的结束颜色*/
    void setEndColor( const Color3B& endColor );
    /** Returns 渐变梯度的结束颜色 */
    const Color3B& getEndColor() const;

    /** set 颜色梯度的开始不透明度 */
    void setStartOpacity( GLubyte startOpacity );
    /** Returns 颜色梯度的开始不透明度 */
    GLubyte getStartOpacity() const;

    /** set 颜色梯度的结束不透明度 */
    void setEndOpacity( GLubyte endOpacity );
    /** Returns 颜色梯度的结束不透明度 */
    GLubyte getEndOpacity() const;

    /** 设置将用于梯度的方向矢量。
        默认值是垂直方向（0，-1）。
     */
    void setVector(const Point& alongVector);
    /** Returns 梯度的方向矢量 */
    const Point& getVector() const;

protected:
    virtual void updateColor() override;

    Color3B _startColor;
    Color3B _endColor;
    GLubyte _startOpacity;
    GLubyte _endOpacity;
    Point   _alongVector;
    bool    _compressedInterpolation;
};

MultipleLayer简要

/** @brief MultipleLayer 是一个有复用它的 children 能力的 Layer.
Features:       //特点
- 支持一个或多个 children
- 同一时间只有一个孩子将被激活
*/
class CC_DLL LayerMultiplex : public Layer
{
public:
    /** 创建和初始化LayerMultiplex对象
     * @js NA
     * @lua NA
     */
    static LayerMultiplex* create();

    /** 使用一个 layers 数组，创建一个LayerMultiplex
     @since v2.1
     * @js NA
     */
    static LayerMultiplex* createWithArray(Array* arrayOfLayers);

    /** 使用一个或读个 layer 的可变参数列表，创建一个LayerMultiplex
     * @code
     * 当这个功能绑定到 js 或者 lua,参数将改变.
     * In js:var create(...)
     * In lua:local create(...)
     * @endcode
     */
    static LayerMultiplex * create(Layer* layer, ... );

    /**
     * lua 脚本不能初始化数目不详变量
     * 所以在 lua 使用这个添加这些功能
     * @js NA
     * @lua NA
     */
    static LayerMultiplex * createWithLayer(Layer* layer);
    /**
     * @js ctor         //js的构造函数
     */
    LayerMultiplex();
    /**
     * @js NA
     * @lua NA
     */
    virtual ~LayerMultiplex();

    virtual bool init();
    /** 使用可变参数列表与一个或多个 layer 初始化MultiplexLayer 
     * @js NA
     * @lua NA
     */
    bool initWithLayers(Layer* layer, va_list params);

    /** 使用一个 layers 数组初始化一个 MultiplexLayer
     @since v2.1
     */
    bool initWithArray(Array* arrayOfLayers);

    void addLayer(Layer* layer);

    /** 使用索引 n 切换到某个 layer
     当前（旧的）layer 将使用 'cleanup=true' 从它们的 parent 里面移除 The current (old) layer will be removed from it's parent with 'cleanup=true'.
     */
    void switchTo(int n);
    /** 释放当前 layer ; 使用索引 n 切换到某个 layer.
    The current (old) layer will be removed from it's parent with 'cleanup=true'.
    */
    void switchToAndReleaseMe(int n);

protected:
    unsigned int _enabledLayer;
    Array*     _layers;
};


// end of layer group
/// @}

NS_CC_END

#endif // __CCLAYER_H__