Cocos2dx学习笔记（23）——节点类Node

发表于   |   分类于   |  

Node类是Cocos中极为重要的类，Scene、Layer、Sprite等等都派生自Node类。

本文仅供个人记录和复习，不用于其他用途

版本变化

由于前后版本差距较大，所以这里只简单的讲一下2.x版本，主要还是分析3.x之后的Node类。

节点类的特点

游戏里的对象都是一个节点，拥有以下特点：

  • 是一个容器，可以包含任意多个节点
  • 可以执行一个行为Action
  • 可以执行一个定时的任务回调schedule
  • 拥有坐标变换信息transform，例如position、scale、rotate等

2.x版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
// 设置节点是否可见.
virtual void setVisible(bool visible);
virtual bool isVisible();
 
// 设置节点的尺寸大小.即节点的容器大小.
virtual void setContentSize(const CCSize& contentSize);
virtual const CCSize& getContentSize() const;
 
// 设置节点的坐标(x,y).在OpenGL中的坐标
virtual void setPosition(const CCPoint &position); // 传参为坐标类CCPoint
virtual const CCPoint& getPosition();
virtual void setPosition(float x, float y);
virtual void getPosition(float* x, float* y);
virtual void  setPositionX(float x);
virtual float getPositionX(void);
virtual void  setPositionY(float y);
virtual float getPositionY(void);
 
// 设置节点的锚点.
// 锚点就像一枚图钉,将图片钉在屏幕上.而锚点就是图片的坐标.
// 当然图钉可以钉在图片的左下角,右上角,或者中心都可以.
// 一般由CCNode继承的子类大多锚点都在中心,也有些是在左下角.
virtual void setAnchorPoint(const CCPoint& anchorPoint);
virtual const CCPoint& getAnchorPoint();
virtual const CCPoint& getAnchorPointInPoints();
 
// 设置节点的Z轴.
// 当有多个节点在Z轴显示时,引擎会根据它们Z轴的大小决定绘制顺序,Z轴大的会遮盖Z轴小的
virtual void setZOrder(int zOrder);
virtual int getZOrder();
 
// 设置节点的放缩比例.对X轴或Y轴进行放缩
// 例如一张图片. 放缩它的宽X,和高Y
virtual void setScaleX(float fScaleX);              // 放缩宽X
virtual float getScaleX();
virtual void setScaleY(float fScaleY);              // 放缩高Y
virtual float getScaleY();
virtual void setScale(float scale);                 // 同时放缩X与Y
virtual float getScale();
virtual void setScale(float fScaleX,float fScaleY); // X放缩fScaleX倍,Y放缩fScaleY倍
 
// 设置节点的倾斜角度.与平面的倾斜角度
// 如一张图片. X轴倾斜fSkewX角度,Y轴倾斜fSkewY角度
virtual void setSkewX(float fSkewX);
virtual float getSkewX();
virtual void setSkewY(float fSkewY);
virtual float getSkewY();
 
// 设置节点旋转角度.
virtual void setRotation(float fRotation);
virtual float getRotation();
virtual void setRotationX(float fRotaionX);
virtual float getRotationX();
virtual void setRotationY(float fRotationY);
virtual float getRotationY();
 
 
// 节点相关函数
// addChild , removeChild , setParent , removeFromParent ,
// reorderChild , sortAllChildren , setTag , 
// getCamera , isRunning , cleanup , 
// draw , visit , boundingBox ,
// onEnter , onEnterTransitionDidFinish , onExit
 
// 添加子节点.zOrder默认为0.
// tag为节点编号,可以通过tag获取子节点.
virtual void addChild(CCNode * child);
virtual void addChild(CCNode * child, int zOrder);
virtual void addChild(CCNode* child, int zOrder, int tag);
virtual CCNode * getChildByTag(int tag);
virtual CCArray* getChildren();                    // 获得所有子节点,并以CCArray数组返回
virtual unsigned int getChildrenCount(void) const; // 子节点个数
 
// 删除子节点.
virtual void removeChild(CCNode* child);
virtual void removeChild(CCNode* child, bool cleanup);
virtual void removeChildByTag(int tag);
virtual void removeChildByTag(int tag, bool cleanup);
virtual void removeAllChildren();                        // 删除所有节点
virtual void removeAllChildrenWithCleanup(bool cleanup); // cleanup为true则删除子节点的所有动作
 
// 设置父节点.
virtual void setParent(CCNode* parent);
virtual CCNode* getParent();
 
// 从父节点中移除该节点.
// Cleanup为true则删除当前节点的所有动作及回调函数.
virtual void removeFromParent();
virtual void removeFromParentAndCleanup(bool cleanup);
 
// 重新设定节点的zOrder
virtual void reorderChild(CCNode * child, int zOrder);
// 重新排序所有子节点
virtual void sortAllChildren();
 
// 设置节点的tag编号
virtual void setTag(int nTag);
virtual int getTag() const;
 
// 获取节点的CCCamera摄像机
virtual CCCamera* getCamera();
// 判断节点是否在运行
virtual bool isRunning();
// 停止所有运行的动作和回调函数
virtual void cleanup(void);
 
// 绘制节点.
// draw里有好多绘制方法.如直线,曲线,矩形,圆等
virtual void draw(void);
// 递归访问所有子节点,并重新绘制
virtual void visit(void);
 
// 返回节点的矩形边界框
CCRect boundingBox(void);
 
// 节点开始进入舞台时调用.即创建时调用.
virtual void onEnter();
// 节点进入舞台后调用.即创建完后调用.
virtual void onEnterTransitionDidFinish();
// 节点离开舞台时调用.即移除时调用
virtual void onExit();
 
 
// Action动作相关
// runAction , stopAction , getActionByTag , numberOfRunningActions
 
// 执行动作
CCAction* runAction(CCAction* action);
 
// 暂停动作
void stopAllActions(void);
void stopAction(CCAction* action);
void stopActionByTag(int tag);
 
CCAction* getActionByTag(int tag);         // 根据tag标记获取动作
unsigned int numberOfRunningActions(void); // 获取正在运行的动作数量
 
 
// 定时器相关函数
// scheduleUpdate , schedule , update
 
// 开启默认定时器.刷新次数为60次/秒.即每秒60帧.
// 与update(float delta)回调函数相对应.
// 给予定时器优先级priority.其中priority越小,优先级越高
void scheduleUpdate(void);
void scheduleUpdateWithPriority(int priority);
void unscheduleUpdate(void);      // 取消默认定时器
virtual void update(float delta); // update为scheduleUpdate定时器的回调函数.
 
// 设置自定义定时器.默认为每秒60帧.
// interval  :   每隔interval秒,执行一次.
// repeat    :   重复次数.
// delay     :   延迟时间,即创建定时器delay后开始执行.
void schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay);
void schedule(SEL_SCHEDULE selector, float interval);
void scheduleOnce(SEL_SCHEDULE selector, float delay); // 只执行一次,delay秒后执行
void schedule(SEL_SCHEDULE selector);                  // 默认为每秒60帧
void unschedule(SEL_SCHEDULE selector);                // 取消定时器
 
void unscheduleAllSelectors(void);                     // 取消所有定时器
void pauseSchedulerAndActions(void);                   // 暂停所有定时器和动作
void resumeSchedulerAndActions(void);                  // 恢复所有定时器和动作

3.x版本

Node类是绝大部分类的父类，例如Scene、Laye、Sprite等都是继承了Node类。Node类的基本特点上面已经讲过了。

节点属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/**
 * 位置Position
 *     设置节点的坐标(x,y).在OpenGL中的坐标
 *     增加3D坐标
 *     增加标准化坐标设置
 */
    virtual void setPosition(const Vec2 &position); //Vec2坐标
    virtual void setPosition(float x, float y);     //(x,y),比Vec2更有效率
    virtual void setPositionX(float x);
    virtual void setPositionY(float y);
    virtual const Vec2& getPosition() const;
    virtual void  getPosition(float* x, float* y) const;
    virtual float getPositionX(void) const;
    virtual float getPositionY(void) const;
     
//增加3D坐标
    virtual void setPosition3D(const Vec3& position); //Vec3坐标
    virtual Vec3 getPosition3D() const;
    virtual void setPositionZ(float positionZ);
    virtual float getPositionZ() const;
     
//增加标准化坐标设置
    //Node的位置像素会根据它的父节点的尺寸大小计算
    //Size s = getParent()->getContentSize();
    //_position = pos * s;
    virtual void setNormalizedPosition(const Vec2 &position);
    virtual const Vec2& getNormalizedPosition() const;
 
 
/**
 * 放缩Scale
 *     设置节点的放缩比例. 对XYZ轴进行放缩
 *     例如一张图片. 放缩它的宽X,高Y,深Z
 */
    virtual void setScaleX(float scaleX);              //放缩宽X
    virtual void setScaleY(float scaleY);              //放缩高Y
    virtual void setScaleZ(float scaleZ);              //放缩深Z
    virtual void setScale(float scaleX, float scaleY); //X放缩fScaleX倍,Y放缩fScaleY倍
    virtual void setScale(float scale);                //XYZ同时放缩scale倍
    virtual float getScaleX() const;
    virtual float getScaleY() const;
    virtual float getScaleZ() const;
    virtual float getScale()  const;                   //当x,y放缩因子相同时，得到该节点的缩放因子
 
 
/**
 * 旋转Rotation
 *     设置节点的旋转角度. 负顺,正逆时针旋转
 *     增加3D旋转
 */
    virtual void setRotation(float rotation);
    virtual float getRotation() const;
 
//增加3D旋转
    virtual void setRotation3D(const Vec3& rotation); 
    virtual Vec3 getRotation3D() const;
 
 
/**
 * 倾斜Skew
 *     设置XY轴的倾斜角度
 *     setRotationalSkew()  模拟Flash的倾斜功能
 *     setSkew()            使用真正的倾斜功能
 */
    virtual void setSkewX(float skewX); //水平旋转倾斜.负顺时针变形
    virtual void setSkewY(float skewY); //垂直旋转倾斜
    virtual void setRotationSkewX(float rotationX);
    virtual void setRotationSkewY(float rotationY);
    virtual float getSkewX() const;
    virtual float getSkewY() const;
    virtual float getRotationSkewX() const;
    virtual float getRotationSkewY() const;
 
 
/**
 * 锚点AnchorPoint
 *     锚点就像一枚图钉,将图片钉在屏幕上.而锚点就是图片的坐标.
 *     当然图钉可以钉在图片的左下角,右上角,或者中心都可以.
 *     (0,0)表示左下角，(1,1)表示右上角
 *     默认的锚点是(0.5,0.5)，即节点的正中心
 */
    virtual void setAnchorPoint(const Vec2& anchorPoint); //标准化的锚点
    virtual const Vec2& getAnchorPoint() const;           //标准化的锚点
    virtual const Vec2& getAnchorPointInPoints() const;   //返回绝对像素的锚点,即屏幕坐标
 
//是否忽略锚点的设置
    //若忽略锚点设置,锚点永远为(0,0)
    //默认值是false, 但是在Layer和Scene中是true
    //这是一个内部方法，仅仅被Layer和Scene使用，不要自行调用！
    virtual void ignoreAnchorPointForPosition(bool ignore);
    virtual bool isIgnoreAnchorPointForPosition() const;
 
 
/**
 * 内容大小ContentSize
 *     contentSize依然是相同的，无论节点是缩放或者旋转 
 *     所有的节点都有大小，图层和场景有相同的屏幕大小
 */
    virtual void setContentSize(const Size& contentSize);
    virtual const Size& getContentSize() const;
 
/**
 * 可见性Visible
 */
    virtual void setVisible(bool visible);
    virtual bool isVisible() const;
//

节点操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/**
 * 标记与名字 Tag and Name
 *     setTag  : 给节点设置一个编号
 *     setName : 给节点设置一个名字
 */
    virtual void setTag(int tag);
    virtual void setName(const std::string& name);
    virtual int getTag() const;
    virtual std::string getName() const;
 
 
/**
 * 自定义数据UserData/Object
 *     setUserData   : 设置一个用户自定义的数据. 可以为一个数据块, 结构体或者一个对象.
 *     setUserObject : 设置一个用户自定义的对象. 和userData类似, 但它是一个对象而不是void*
 */
    virtual void setUserData(void *userData);
    virtual void setUserObject(Ref *userObject);
    virtual void* getUserData();
    virtual Ref* getUserObject();
 
 
/**
 * 设置父节点Parent
 *     setParent , removeFromParent
 */
    virtual void setParent(Node* parent);
    virtual Node* getParent();
    virtual void removeFromParent();
    virtual void removeFromParentAndCleanup(bool cleanup); //true则删除该节点的所有动作及回调函数.
 
 
/**
 * 管理子节点Child
 *     addChild , 
 *     getChildBy** , getChildren       , getChildrenCount
 *     removeChild  , removeAllChildren
 *     reorderChild , sortAllChildren
 */
    //添加子节点
    //localZOrder   Z轴顺序为了绘画的优先权
    //tag           节点编号,可通过tag获取子节点
    //name        节点名字,可通过name获取子节点
    virtual void addChild(Node * child);
    virtual void addChild(Node * child, int localZOrder);
    virtual void addChild(Node* child, int localZOrder, int tag);
    virtual void addChild(Node* child, int localZOrder, const std::string &name);
 
    //获取子节点
    virtual Node* getChildByTag(int tag) const;
    virtual Node* getChildByName(const std::string& name) const;
    virtual Vector<Node*>& getChildren();     //获得所有子节点,并以Vector数组返回
    virtual ssize_t getChildrenCount() const; //子节点总数
 
    //删除子节点
    virtual void removeChild(Node* child, bool cleanup = true);
    virtual void removeChildByTag(int tag, bool cleanup = true);
    virtual void removeChildByName(const std::string &name, bool cleanup = true);
    virtual void removeAllChildren();                        //删除所有节点
    virtual void removeAllChildrenWithCleanup(bool cleanup); //cleanup为true则删除子节点的所有动作
 
    //重排子节点
    //重新排序一个子节点，设定一个新的z轴的值
    //child         它必须是已经添加的
    //localZOrder   Z轴顺序为了绘画优先级
    virtual void reorderChild(Node * child, int localZOrder);
    virtual void sortAllChildren(); //重新排序所有子节点
 
 
/**
 * 其他操作管理
 */
    virtual void onEnter();                    //节点开始进入舞台时调用.即创建时调用.
    virtual void onEnterTransitionDidFinish(); //节点进入舞台后调用.即创建完后调用.
    virtual void onExit();                     //节点离开舞台时调用.即移除时调用
    virtual void onExitTransitionDidStart();   //节点离开舞台前调用.
 
    //绘制节点
    virtual void draw() final;
    //递归访问所有子节点,并重新绘制  
    virtual void visit() final;
 
    //返回包含Node(节点)的Scene(场景). 
    //若不属于任何的场景,它将返回nullptr
    virtual Scene* getScene() const;
     
    //返回节点在父节点坐标中的矩形边界框
    virtual Rect getBoundingBox() const;
     
    //暂停所有的活动着的动作和调度器
    virtual void cleanup();

动作相关Action

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 动作管理Action
 *     setActionManager
 *     runAction , stopAction , getActionByTag , getNumberOfRunningActions
 */
    //设置被所有动作使用的ActionManager对象
    //如果你设置了一个新的ActionManager, 那么之前创建的动作将会被删除
    virtual void setActionManager(ActionManager* actionManager);
    virtual ActionManager* getActionManager();
 
    Action* runAction(Action* action);          //执行一个动作
    Action* getActionByTag(int tag);            //获取动作, 根据tag标记
    void stopAllActions();                      //暂停动作
    void stopAction(Action* action);            //暂停动作
    void stopActionByTag(int tag);              //暂停动作
    ssize_t getNumberOfRunningActions() const;  //获取正在运行的动作数量

定时器相关schedule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * 定时器管理schedule
 *     setScheduler
 *     scheduleUpdate : 默认定时器
 *     schedule       : 自定义定时器
 *     scheduleOnce   : 一次性定时器
 */
    //设置一个调度器对象，来调度所有的“update”和定时器
    //如果你设置了一个新的调度器，那么之前创建的timers/update将会被删除。
    virtual void setScheduler(Scheduler* scheduler);
    virtual Scheduler* getScheduler(); //得到调度器对象
 
    //开启默认定时器.刷新次数为60次/秒.即每秒60帧.
    //与update(float delta)回调函数相对应.
    //给予定时器优先级priority.其中priority越小,优先级越高
    void scheduleUpdate(void);
    void scheduleUpdateWithPriority(int priority);
    void unscheduleUpdate(void);      //取消默认定时器
    virtual void update(float delta); //update为scheduleUpdate定时器的回调函数.
 
    //设置自定义定时器.默认为每秒60帧.
    //interval  :   每隔interval秒,执行一次.
    //repeat    :   重复次数.
    //delay     :   延迟时间,即创建定时器delay后开始执行.
    void schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay);
    void schedule(SEL_SCHEDULE selector, float interval);
    void schedule(SEL_SCHEDULE selector);                  //默认为每秒60帧
    void scheduleOnce(SEL_SCHEDULE selector, float delay); //只执行一次,delay秒后执行
 
    void unschedule(SEL_SCHEDULE selector);                //取消一个自定义定时器
    void unscheduleAllSelectors(void);                     //取消所有定时器
    void resume(void);                                     //恢复所有定时器和动作
    void pause(void);                                      //暂停所有定时器和动作

整合NodeRGBA类

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 整合NodeRGBA类
 *     setOpacity : 透明度
 *     setColor   : 颜色
 */
    virtual GLubyte getOpacity() const;
    virtual GLubyte getDisplayedOpacity() const;
    virtual void setOpacity(GLubyte opacity);
 
    virtual const Color3B& getColor() const;
    virtual const Color3B& getDisplayedColor() const;
    virtual void setColor(const Color3B& color);

enumerateChildren

用于枚举某个Node节点的子节点，并让名字符合name通配符的子节点执行callback()函数。且callback()函数返回类型应该为一个bool值，并且返回为true时，结束查找。

1
virtual void enumerateChildren(const std::string &name, std::function<bool(Node* node)> callback) const;

使用举例：

1
2
3
4
5
6
7
8
9
10
11
//搜索语法选项
'//' : 递归访问所有子节点,   只能放在搜索串的开头位置
'..' : 搜索移至node的父节点, 只能放在某个字符串的结束位置
'/'  : 搜索移至node的子节点, 可以放在任何位置,除了搜索串的开头位置
  
//代码举例
enumerateChildren("//MyName", ...)     : 递归访问Node的所有子节点。查找匹配 "MyName" 的子节点
enumerateChildren("[[:alnum:]]+", ...) : 在Node的儿子节点中查找。  所有项
enumerateChildren("A[[:digit:]]", ...) : 在Node的儿子节点中查找。  名字为 "A0","A1",...,"A9" 的子节点
enumerateChildren("Abby/Normal", ...)  : 在Node的孙子节点中查找。  其节点为"Normal"，且父节点为"Abby"
enumerateChildren("//Abby/Normal", ...): 递归访问Node的所有子节点。其节点为"Normal"，且父节点为"Abby"