cocos2d-x 框架深入分析（二）—— CCScheduler

Scheduler——调度者、计划者。从字面上我们就可以看出，这个类负责的是程序和数据的调度。在上一篇的主循环分析中，（ cocos2d-x 框架深入分析（一）—— MainLoop ： http://cocos2d.cocoachina.com/bbs/forum.php?mod=viewthread&tid=10881&extra=page%3D1 ）我们可以看到底层循环中：CCDirector::drawScene(void) 方法中，有这样的一句代码：m_pScheduler->update(m_fDeltaTime) ，这句代码中CCScheduler对象调用了成员函数 update方法。

1.     // calculate "global" dt
   
2.     calculateDeltaTime();//计算时间差
   
3. 
   
4.     //tick before glClear: issue #533
   
5.     if (! m_bPaused)    //如果不暂停，就更新数据
   
6.     {
   
7.         m_pScheduler->update(m_fDeltaTime);//调度者对象，是整个框架中，非常重要的东东，他负责者引擎中精灵、动作等的调度
   
8.                                                                                    //而里面所用的数据结构的组织，一定程度决定者引擎的效率。
   
9.     }
   
10. 
    
11.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
12. 
    
13.     /* to avoid flickr, nextScene MUST be here: after tick and before draw.
    
14.      XXX: Which bug is this one. It seems that it can't be reproduced with v0.9 */
    
15.     if (m_pNextScene)
    
16.     {
    
17.         setNextScene();//如果有m_pNextScene对象不为空，就说明需要调用到新的场景中，
    
18.                                            //在其中onEnter()、onEnterTransitionDidFinish()等函数被回调。
    
19.     }
    
20. 
    
21.     kmGLPushMatrix();//opengl:把当前矩阵放到栈中，开始绘图工作
    
22. 
    
23.     // draw the scene
    
24.     if (m_pRunningScene)
    
25.     {
    
26.         m_pRunningScene->visit();//通过访问方法，去绘制场景中包含的每个层和每个层中的每个节点的draw，
    
27.                                                                  //这里面是一个递归的过程,其中transform()方法实现，opengl矩阵的变化，移动，旋转等。
    
28.     }

复制代码

从代码上看，这段代码是在我们绘制图形前调用的。
更新？到底要更新什么？一个方法就可以实现了所有我们需要更新的数据？代者疑问，我们不妨来猜测一下设计者的思路：
1、既然是在绘图前的，那应该是更新游戏场景中的数据，比如：每层的显隐，精灵的坐标，旋转角度、纹理地图坐标、一些动画等等。
2、一个方法就可以实习，我们不妨大胆的猜测里面用上的设计模式和数据组织。如果我们把用调度的对象加入CCScheduler中，让CCScheduler来管理，和调度对象，这样的模式有一点像观察者设计模式（个人理解，不一定对！-。-！），对于观察者模式，我的理解为：有一个被观察者（类似于这个CCScheduler），在类中的内部中有0到多个的观察者接口（比如一个精灵），当被观察者的状态有所变化时，被观察者调用某个通知方法时，就会调用内部的所有的观察者接口的方法，这样就可以实现我们想要的效果。
       好了，我们带着自己的猜想去看看源代码。在进入update方法前，我们先看看这个类维持的是什么数据吧。
       找到...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.h

1.     float m_fTimeScale;
   
2. 
   
3.     //
   
4.     // "updates with priority" stuff
   
5.     //
   
6.         // 权限越小越先被调度
   
7.         // 记录权限小于0的链表CCActionManager就是被装入的第一个节点
   
8.     struct _listEntry *m_pUpdatesNegList;        // list of priority < 0
   
9.         // 记录权限等于0的链表，一般的节点是这个权限
   
10.     struct _listEntry *m_pUpdates0List;            // list priority == 0
    
11.         // 记录权限大于0的链表，最后被调度
    
12.     struct _listEntry *m_pUpdatesPosList;        // list priority > 0
    
13. 
    
14. 
    
15.         // 用于记录需要用Update方法的对象，这里是通过哈希表储存的，目的很明显，就是为了快速查找。
    
16.         // 这里用的哈希表是在   ...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\support\data_support\uthash.h
    
17.         // uthash.h<span style="font-family: Arial;">头文件中，是用C语言实现的。</span>
    
18.         // _hashUpdateEntry是哈希表项头地址，其中KEY是需要调度的对象的指针。VALUE就是_hashUpdateEntry结构体
    
19.     struct _hashUpdateEntry *m_pHashForUpdates; // hash used to fetch quickly the list entries for pause,delete,etc
    
20. 
    
21.     // Used for "selectors with interval"
    
22.         // 结构同上，只是记录的是 SEL_SCHEDULE类型回调
    
23.     struct _hashSelectorEntry *m_pHashForTimers;
    
24.         // 结构同上，记录当前要调度的目标
    
25.     struct _hashSelectorEntry *m_pCurrentTarget;
    
26. 
    
27.     bool m_bCurrentTargetSalvaged;
    
28.     // If true unschedule will not remove anything from a hash. Elements will only be marked for deletion.
    
29.     bool m_bUpdateHashLocked;
    
30.     CCArray* m_pScriptHandlerEntries;

复制代码

这就是CCScheduler维持的数据。其中包涵3个链表和3个哈希项。由此可以看出，当我们向CCScheduler中添加一个调度对象时（实际也就是scheduleSelector(SEL_SCHEDULE pfnSelector, CCObject *pTarget, float fInterval, bool bPaused) 或者 scheduleUpdateForTarget(CCObject *pTarget, int nPriority, bool bPaused) 等方法）。我们现在看看scheduleUpdateForTarget这个方法，看看是怎么把调度对象加入CCScheduler中的。
进入...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.cpp

1. void CCScheduler::scheduleUpdateForTarget(CCObject *pTarget, int nPriority, bool bPaused)
   
2. {
   
3.         // 申请一个用于记录Update的哈希项空指针
   
4.     tHashUpdateEntry *pHashElement = NULL;
   
5.         // 把KEY=pTarget 放到m_pHashForUpdates哈希链表中查找，找到为pHashElement赋值，没找到依然为空。
   
6.     HASH_FIND_INT(m_pHashForUpdates, &pTarget, pHashElement);
   
7.     if (pHashElement)   // 存在这个值
   
8.     {
   
9. #if COCOS2D_DEBUG >= 1
   
10.         CCAssert(pHashElement->entry->markedForDeletion,"");
    
11. #endif
    
12.         // TODO: check if priority has changed!
    
13.         // 确保被调度对象不被删除，最后返回
    
14.         pHashElement->entry->markedForDeletion = false;
    
15.         return;
    
16.     }
    
17. 
    
18.     // most of the updates are going to be 0, that's way there
    
19.     // is an special list for updates with priority 0
    
20.         // 多数的更新操作的权限值为0。
    
21.     if (nPriority == 0)
    
22.     {
    
23.         appendIn(&m_pUpdates0List, pTarget, bPaused);
    
24.     }
    
25.         // CCActionManager的更新权限是小于0的。
    
26.     else if (nPriority < 0)
    
27.     {
    
28.         priorityIn(&m_pUpdatesNegList, pTarget, nPriority, bPaused);
    
29.     }
    
30.     else
    
31.     {
    
32.         // priority > 0
    
33.         priorityIn(&m_pUpdatesPosList, pTarget, nPriority, bPaused);
    
34.     }
    
35. }

复制代码

从上面的代码可以看出，如果在哈希表中已经存在对应的值就不在插入了，否则就进行插入方法。appendIn和priorityIn的方法实现的原理差不多，只是priorityIn方法在插入时，是按照权限的大小排序插入的。现在我们进入appendIn函数看看。
进入：...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.cpp

1. void CCScheduler::appendIn(_listEntry **ppList, CCObject *pTarget, bool bPaused)
   
2. {
   
3.         //申请一个链表节点
   
4.     tListEntry *pListElement = (tListEntry *)malloc(sizeof(*pListElement));
   
5. 
   
6.     pListElement->target = pTarget;
   
7.     pListElement->paused = bPaused;
   
8.     pListElement->markedForDeletion = false;
   
9.         //把链表节点插入链表中。DL_APPEND这个方法是在utlist.h文件中，用C语言写的一个链表
   
10.     DL_APPEND(*ppList, pListElement);
    
11. 
    
12.     // update hash entry for quicker access
    
13.         // 申请一个哈希项，用于更新操作，可以快速查找。
    
14.     tHashUpdateEntry *pHashElement = (tHashUpdateEntry *)calloc(sizeof(*pHashElement), 1);
    
15.     pHashElement->target = pTarget;
    
16.     pTarget->retain();
    
17.     pHashElement->list = ppList;
    
18.     pHashElement->entry = pListElement;
    
19.         // 把KEY为target，VALUE为pHashElement，插入哈希表中
    
20.     HASH_ADD_INT(m_pHashForUpdates, target, pHashElement);
    
21. }

复制代码

这个方法就是简单的插入数据。具体的每个字段的含义，下次讲到 CCScheduler用到的数据结构时，具体讲。。。
下面我们看看最重要的 update方法：...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.cpp

1. // main loop
   
2. void CCScheduler::update(float dt)
   
3. {
   
4.     m_bUpdateHashLocked = true;
   
5. 
   
6.     if (m_fTimeScale != 1.0f)
   
7.     {
   
8.         dt *= m_fTimeScale;
   
9.     }
   
10. 
    
11.     // Iterate over all the Updates' selectors
    
12.     tListEntry *pEntry, *pTmp;
    
13. 
    
14.         // 遍历每个权限小于0的链表，并调用他们的update方法
    
15.     // updates with priority < 0
    
16.     DL_FOREACH_SAFE(m_pUpdatesNegList, pEntry, pTmp)
    
17.     {
    
18.                 // 不是暂定和删除状态就update
    
19.         if ((! pEntry->paused) && (! pEntry->markedForDeletion))//如果不是暂停和删除标志
    
20.         {
    
21.             pEntry->target->update(dt);
    
22.         }
    
23.     }
    
24. 
    
25.         // 遍历每个权限等于0的链表，并调用他们的update方法
    
26.     // updates with priority == 0
    
27.     DL_FOREACH_SAFE(m_pUpdates0List, pEntry, pTmp)
    
28.     {
    
29.                 // 不是暂定和删除状态就update
    
30.         if ((! pEntry->paused) && (! pEntry->markedForDeletion))
    
31.         {
    
32.             pEntry->target->update(dt);
    
33.         }
    
34.     }
    
35. 
    
36.         // 遍历每个权限大于0的链表，并调用他们的update方法
    
37.     // updates with priority > 0
    
38.     DL_FOREACH_SAFE(m_pUpdatesPosList, pEntry, pTmp)
    
39.     {
    
40.                 // 不是暂定和删除状态就update
    
41.         if ((! pEntry->paused) && (! pEntry->markedForDeletion))
    
42.         {
    
43.             pEntry->target->update(dt);
    
44.         }
    
45.     }
    
46. 
    
47.         // 遍历更新所有的定制的选择器，注意这里遍历的实际是哈希表，这是一个比较特殊的哈希表，在下次讲数据结构时会说
    
48.     // Iterate over all the custom selectors
    
49.     for (tHashTimerEntry *elt = m_pHashForTimers; elt != NULL; )
    
50.     {
    
51.         m_pCurrentTarget = elt;
    
52.         m_bCurrentTargetSalvaged = false;
    
53. 
    
54.         if (! m_pCurrentTarget->paused)
    
55.         {
    
56.                         // 一个周期回调
    
57.             // The 'timers' array may change while inside this loop
    
58.             for (elt->timerIndex = 0; elt->timerIndex < elt->timers->num; ++(elt->timerIndex))
    
59.             {
    
60.                                 // 当前索引的Timer
    
61.                 elt->currentTimer = (CCTimer*)(elt->timers->arr[elt->timerIndex]);
    
62.                 elt->currentTimerSalvaged = false;
    
63. 
    
64.                 elt->currentTimer->update(dt);
    
65. 
    
66.                                 // 如果update方法调用后currentTimerSalvaged被改为true就取消当前Timer
    
67.                 if (elt->currentTimerSalvaged)
    
68.                 {
    
69.                     // The currentTimer told the remove itself. To prevent the timer from
    
70.                     // accidentally deallocating itself before finishing its step, we retained
    
71.                     // it. Now that step is done, it's safe to release it.
    
72.                     elt->currentTimer->release();
    
73.                 }
    
74. 
    
75.                 elt->currentTimer = NULL;
    
76.             }
    
77.         }
    
78. 
    
79.         // elt, at this moment, is still valid
    
80.         // so it is safe to ask this here (issue #490)
    
81.                 // 哈希表的下一个位置
    
82.         elt = (tHashTimerEntry *)elt->hh.next;
    
83. 
    
84.         // only delete currentTarget if no actions were scheduled during the cycle (issue #481)
    
85.                 // 当前目标对象没有动作需要调度就把他从哈希表中移除
    
86.         if (m_bCurrentTargetSalvaged && m_pCurrentTarget->timers->num == 0)
    
87.         {
    
88.             removeHashElement(m_pCurrentTarget);
    
89.         }
    
90.     }
    
91. 
    
92.     // Iterate over all the script callbacks
    
93.     if (m_pScriptHandlerEntries)
    
94.     {
    
95.         for (int i = m_pScriptHandlerEntries->count() - 1; i >= 0; i--)
    
96.         {
    
97.             CCSchedulerScriptHandlerEntry* pEntry = static_cast<CCSchedulerScriptHandlerEntry*>(m_pScriptHandlerEntries->objectAtIndex(i));
    
98.             if (pEntry->isMarkedForDeletion())
    
99.             {
    
100.                 m_pScriptHandlerEntries->removeObjectAtIndex(i);
     
101.             }
     
102.             else if (!pEntry->isPaused())
     
103.             {
     
104.                 pEntry->getTimer()->update(dt);
     
105.             }
     
106.         }
     
107.     }
     
108. 
     
109.     // delete all updates that are marked for deletion
     
110.     // updates with priority < 0
     
111.         // 依据权限把当前被设置为删除状态的目标对象，从哈希表中移除
     
112.     DL_FOREACH_SAFE(m_pUpdatesNegList, pEntry, pTmp)
     
113.     {
     
114.         if (pEntry->markedForDeletion)
     
115.         {
     
116.             this->removeUpdateFromHash(pEntry);
     
117.         }
     
118.     }
     
119. 
     
120.     // updates with priority == 0
     
121.     DL_FOREACH_SAFE(m_pUpdates0List, pEntry, pTmp)
     
122.     {
     
123.         if (pEntry->markedForDeletion)
     
124.         {
     
125.             this->removeUpdateFromHash(pEntry);
     
126.         }
     
127.     }
     
128. 
     
129.     // updates with priority > 0
     
130.     DL_FOREACH_SAFE(m_pUpdatesPosList, pEntry, pTmp)
     
131.     {
     
132.         if (pEntry->markedForDeletion)
     
133.         {
     
134.             this->removeUpdateFromHash(pEntry);
     
135.         }
     
136.     }
     
137. 
     
138.     m_bUpdateHashLocked = false;
     
139. 
     
140.     m_pCurrentTarget = NULL;
     
141. }

复制代码

现在我们基本都知道了引擎是怎么通过CCScheduler更新所有node的数据的了，其中引起注意的是Update方法是CCObject的虚函数。所以只要是继承CCObject实现Update方法的类，注册进CCScheduler中，我们就可以在Update方法中每帧更新自己的数据。甚至我们还可以注册自己的回调函数。可见CCScheduler设计的强大。
       好了，这次写到这里吧。下次记录下CCScheduler中的数据结构的组织，看这个有什么用呢？游戏最要紧的一点就是帧数。而CCScheduler又是引擎一个非常重要的调度中心，它的数据组织是很重要的。了解它，可以方便我们写出更高效的代码，或者尝试去优化引擎不好的地方。花了3节课，终于写完。。。