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设计的强大。