cocos2d-x整体框架源码分析以及启动过程原理（win32）

来源：互联网发布：fx3u编程手册编辑：程序博客网时间：2024/05/22 17:34

原文地址：http://blog.csdn.net/jinble03/article/details/20006407

引言：如果你想深入了解cocos2d-x的整个框架和运行流程，如果你想知道整个启动过程的细节，如果你想知道自己写的代码是在什么时候和在哪里被调用的，下面可以为你解答其中奥秘。

对象：适合刚刚入门了cocos2d-x的初学者，编写并运行过简单的demo，并且想仔细探究其中的原理机制。

1、程序入口main.cpp

[cpp] view plaincopy
int APIENTRY _tWinMain(HINSTANCE hInstance,  
                       HINSTANCE hPrevInstance,  
                       LPTSTR    lpCmdLine,  
                       int       nCmdShow)  
{  
    ...  
    // create the application instance  
    AppDelegate app;//看这里  
    ...  
    return CCApplication::sharedApplication()->run();//看这里  
}  

以上两行是关键代码

（1）代码AppDelegate app;调用了AppDelegate的构造函数，而它的父类是CCApplication，所以CCApplication的构造函数也被调用了

[cpp] view plaincopy
CCApplication::CCApplication()  
: m_hInstance(NULL)  
, m_hAccelTable(NULL)  
{  
    m_hInstance    = GetModuleHandle(NULL);  
    m_nAnimationInterval.QuadPart = 0;  
    CC_ASSERT(! sm_pSharedApplication);  
    sm_pSharedApplication = this;  
}  

这里完成了AppDelegate和CCApplication之间的联系，由于AppDelegate是CCApplication的子类，故CCApplication里面的静态单例指针指的便是AppDelegate的实例。之后调用CCApplication::sharedApplication()的相关操作是基于AppDelegate的实现。

（2）代码CCApplication::sharedApplication()->run();调用了下面的代码

[cpp] view plaincopy
int CCApplication::run()  
{  
    ...  
    // Initialize instance and cocos2d.  
    if (!applicationDidFinishLaunching())  
    {  
        return 0;  
    }  
    ..  
    while (1)  
    {  
        if (! PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))  
        {  
            // Get current time tick.  
            QueryPerformanceCounter(&nNow);  
  
            // If it's the time to draw next frame, draw it, else sleep a while.  
            if (nNow.QuadPart - nLast.QuadPart > m_nAnimationInterval.QuadPart)  
            {  
                nLast.QuadPart = nNow.QuadPart;  
                CCDirector::sharedDirector()->mainLoop();//看这里  
            }  
            else  
            {  
                Sleep(0);  
            }  
            continue;  
        }  
  
        if (WM_QUIT == msg.message)  
        {  
            // Quit message loop.  
            break;  
        }  
  
        // Deal with windows message.  
        if (! m_hAccelTable || ! TranslateAccelerator(msg.hwnd, m_hAccelTable, &msg))  
        {  
            TranslateMessage(&msg);  
            DispatchMessage(&msg);  
        }  
    }  
  
    return (int) msg.wParam;  
}  

在这里，run()函数里面是一个while死循环，不过里面有判断条件 if (WM_QUIT == msg.message)可以跳出循环，终止程序。循环里面每隔一段时间m_nAnimationInterval就调用CCDirector::sharedDirector()->mainLoop()，完成游戏的刷新。

（3）下面来看看mainLoop()都干了啥事：

[cpp] view plaincopy
void CCDisplayLinkDirector::mainLoop(void)  
{  
    if (m_bPurgeDirecotorInNextLoop)  
    {  
        m_bPurgeDirecotorInNextLoop = false;  
        purgeDirector();  
    }  
    else if (! m_bInvalid)  
     {  
         drawScene();//看这里  
       
         // release the objects  
         CCPoolManager::sharedPoolManager()->pop(); //看这里         
     }  
}  

首先解释一下为什么显示的是CCDisplayLinkDirector::mainLoop，而不是 CCDirector ::mainLoop，答案就在CCDirector.h头文件里面

[cpp] view plaincopy
class CC_DLL CCDirector : public CCObject, public TypeInfo  
｛  
        .......  
        virtual void mainLoop(void) = 0;//看这里  
        .......  
}  
class CCDisplayLinkDirector : public CCDirector  
{  
       ..........  
}  

在CCDirector类里面，mainLoop是纯虚函数，而CCDisplayLinkDirector是CCDirector的子类。

重新回到mainLoop函数的实现，我们发现drawScene()和CCPoolManager::sharedPoolManager()->pop()是其主要内容，也就是重绘和释放自动内存池管理器里面暂时存储的对象，这个和cocos2d-x的自动内存管理机制有关，所有静态创建对象函数::create()都采用了自动托管机制，比如：

[cpp] view plaincopy
CCSprite* CCSprite::create(const char *pszFileName)  
{  
    CCSprite *pobSprite = new CCSprite();  
    if (pobSprite && pobSprite->initWithFile(pszFileName))  
    {  
        pobSprite->autorelease();//看这里  
        return pobSprite;  
    }  
    CC_SAFE_DELETE(pobSprite);  
    return NULL;  
}  

其中autorelease()函数实现如下

[cpp] view plaincopy
CCObject* CCObject::autorelease(void)  
{  
    CCPoolManager::sharedPoolManager()->addObject(this);  
    return this;  
}  

由此可以看到自动内存管理对象在每帧绘制结束后都会被CCPoolManager::sharedPoolManager()->pop()释放，除非我们在create()对象后使用了retain()，retain()也很简单，实现如下

[cpp] view plaincopy
void CCObject::retain(void)  
{  
    CCAssert(m_uReference > 0, "reference count should greater than 0");  
  
    ++m_uReference;//看这里  
}  

就是把对象的引用计数-1，这又对应于对象的release()函数

[cpp] view plaincopy
void CCObject::release(void)  
{  
    CCAssert(m_uReference > 0, "reference count should greater than 0");  
    --m_uReference;//看这里  
  
    if (m_uReference == 0)//看这里  
    {  
        delete this;  
    }  
}  

可以看到，对象只有当其引用计数m_uReference=0时，才会真正被删除。

（4）下面看看drawScene()重绘函数负责什么，看完你就全明白了整个框架了

[cpp] view plaincopy
// Draw the Scene  
void CCDirector::drawScene(void)  
{  
    ..............  
    //tick before glClear: issue #533  
    if (! m_bPaused)  
    {  
        m_pScheduler->update(m_fDeltaTime);//看这里  
    }  
    .....................  
    // draw the scene  
    if (m_pRunningScene)  
    {  
        m_pRunningScene->visit();  
    }  
    .....................  
    // swap buffers  
    if (m_pobOpenGLView)  
    {  
        m_pobOpenGLView->swapBuffers();  
    }  
    ................  
}  

大家看到 m_pScheduler->update(m_fDeltaTime)会不会想到我们经常在HelloWorldScene.h写的void update(float dt)，两者有什么关系呢？

首先回忆一下，我们在HelloWorldScene.h里面是怎样调用到update函数的

this->schedule(schedule_selector( HelloWorld::update));（这只是调用方式的一种）

看看schedule函数的实现

[cpp] view plaincopy
void CCNode::schedule(SEL_SCHEDULE selector)  
{  
    this->schedule(selector, 0.0f, kCCRepeatForever, 0.0f);  
}  
void CCNode::schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay)  
{  
    CCAssert( selector, "Argument must be non-nil");  
    CCAssert( interval >=0, "Argument must be positive");  
  
    m_pScheduler->scheduleSelector(selector, this, interval , repeat, delay, !m_bRunning);//看这里  
}  
class CC_DLL CCNode : public CCObject  
{     .........  
      CCScheduler *m_pScheduler;  //看这里  
      .......  
}  

再对比一下刚才drawScene()重绘函数

[cpp] view plaincopy
// Draw the Scene  
void CCDirector::drawScene(void)  
{  
    ..............  
    //tick before glClear: issue #533  
    if (! m_bPaused)  
    {  
        m_pScheduler->update(m_fDeltaTime);//看这里  
    }  
    .....................  
}  
class CC_DLL CCDirector : public CCObject, public TypeInfo  
{       ...............  
        CC_PROPERTY(CCScheduler*, m_pScheduler, Scheduler);//看这里  
        ..............  
}  
#define CC_PROPERTY(varType, varName, funName)\//看这里  
protected: varType varName;\  
public: virtual varType get##funName(void);\  
public: virtual void set##funName(varType var);  

我们发现CCNode和CCDirector类都申明了CCScheduler *m_pScheduler，都不是同一个滴。

且慢，不一定哦，看看CCNode的构造函数先

[cpp] view plaincopy
CCNode::CCNode(void)  
: ...........  
{  
    CCDirector *director = CCDirector::sharedDirector();  
    ...............  
    m_pScheduler = director->getScheduler();//看这里  
    ................  
}  

原来CCNode里面的m_pScheduler引用了CCDirector的m_pScheduler，感受到穷追不舍的魅力了吧。

再回到之前的问题：

CCDirector::drawScene里面的m_pScheduler->update(m_fDeltaTime)和我们经常在HelloWorldScene.h写的void update(float dt)，两者有什么关系呢？

由上面代码可见，this->schedule(schedule_selector( HelloWorld::update))实际上会把schedule_selector( HelloWorld::update)保存到CCNode里面的m_pScheduler，也就是CCDirector里面的m_pScheduler，那么CCDirector::drawScene里面的m_pScheduler->update(m_fDeltaTime)里面的代码应该就和HelloWorld::update()有关吧。继续看看呗。

[cpp] view plaincopy
// main loop  
void CCScheduler::update(float dt)  
{  
    ................  
    // Iterate over all the custom selectors  
    for (tHashTimerEntry *elt = m_pHashForTimers; elt != NULL; )  
    {  
        m_pCurrentTarget = elt;  
        m_bCurrentTargetSalvaged = false;  
  
        if (! m_pCurrentTarget->paused)  
        {  
            // The 'timers' array may change while inside this loop  
            for (elt->timerIndex = 0; elt->timerIndex < elt->timers->num; ++(elt->timerIndex))  
            {  
                elt->currentTimer = (CCTimer*)(elt->timers->arr[elt->timerIndex]);  
                elt->currentTimerSalvaged = false;  
                elt->currentTimer->update(dt);//看这里  
                 ......................  
            }  
        }  
         ..................  
    }  
    ...............  
}  

重点看elt->currentTimer->update(dt);

elt->currentTimer是CCTimer类，看看里面的update函数是神马情况先

[cpp] view plaincopy
void CCTimer::update(float dt)  
{  
    if (m_fElapsed == -1)  
    {  
       ....................  
    }  
    else  
    {  
        if (m_bRunForever && !m_bUseDelay)  
        {//standard timer usage  
            ...................  
            if (m_fElapsed >= m_fInterval)  
            {  
                if (m_pTarget && m_pfnSelector)  
                {  
                    (m_pTarget->*m_pfnSelector)(m_fElapsed);//看这里  
                }  
                ...................  
            }  
        }      
        else  
        {//advanced usage  
            ...............  
            if (m_bUseDelay)  
            {  
                if( m_fElapsed >= m_fDelay )  
                {  
                    if (m_pTarget && m_pfnSelector)  
                    {  
                        (m_pTarget->*m_pfnSelector)(m_fElapsed);//看这里  
                    }  
                    ...............  
                }  
            }  
            else  
            {  
                if (m_fElapsed >= m_fInterval)  
                {  
                    if (m_pTarget && m_pfnSelector)  
                    {  
                        (m_pTarget->*m_pfnSelector)(m_fElapsed);//看这里  
                    }  
                    .......................  
                }  
            }  
            ..............  
        }  
    }  
}  

你可能还不知道(m_pTarget->*m_pfnSelector)(m_fElapsed);这个什么意思，没事，重新看看HelloWorldScene.h调用update函数时的代码：

this->schedule(schedule_selector( HelloWorld::update));

下面是schedule的实现（上面已提过）

[cpp] view plaincopy
void CCNode::schedule(SEL_SCHEDULE selector)  
{  
    this->schedule(selector, 0.0f, kCCRepeatForever, 0.0f);  
}  
void CCNode::schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay)  
{  
    CCAssert( selector, "Argument must be non-nil");  
    CCAssert( interval >=0, "Argument must be positive");  
  
    m_pScheduler->scheduleSelector(selector, this, interval , repeat, delay, !m_bRunning);//看这里  
}  

最后一步，就是看m_pScheduler->scheduleSelector(selector, this, interval , repeat, delay, !m_bRunning)和(m_pTarget->*m_pfnSelector)(m_fElapsed)有什么关系，其中selector是函数指针，指向HelloWorld::update，不懂的可以看schedule_selector的定义。

下面是scheduleSelector函数的实现

[cpp] view plaincopy
void CCScheduler::scheduleSelector(SEL_SCHEDULE pfnSelector, CCObject *pTarget, float fInterval, unsigned int repeat, float delay, bool bPaused)  
{  
    ................  
    tHashTimerEntry *pElement = NULL;  
    HASH_FIND_INT(m_pHashForTimers, &pTarget, pElement);  
    if (! pElement)  
    {  
        ...........................  
    }  
    else  
    {  
        CCAssert(pElement->paused == bPaused, "");  
    }  
  
    if (pElement->timers == NULL)  
    {  
        pElement->timers = ccArrayNew(10);  
    }  
    else   
    {  
       ....................  
    }  
  
    CCTimer *pTimer = new CCTimer();  
    pTimer->initWithTarget(pTarget, pfnSelector, fInterval, repeat, delay);//看这里  
    ccArrayAppendObject(pElement->timers, pTimer);  
    pTimer->release();      
}  

重点看pTimer->initWithTarget(pTarget, pfnSelector, fInterval, repeat, delay)，其中pTarget就是CCNode（对应HelloWorld类）对象本身，而pfnSelector就是刚才说的函数指针，指向HelloWorld::update，下面是initWithTarget的函数实现

[cpp] view plaincopy
bool CCTimer::initWithTarget(CCObject *pTarget, SEL_SCHEDULE pfnSelector, float fSeconds, unsigned int nRepeat, float fDelay)  
{  
    m_pTarget = pTarget;  
    m_pfnSelector = pfnSelector;  
    .....................  
    return true;  
}  

由此，我们解决刚才提出的问题：

看看m_pScheduler->scheduleSelector(selector, this, interval , repeat, delay, !m_bRunning)和(m_pTarget->*m_pfnSelector)(m_fElapsed)有什么关系，其中selector是函数指针，指向HelloWorld::update。

答案就在上面，再次啰嗦说明一下，pTarget就是CCNode（对应HelloWorld类）对象本身，而pfnSelector就是刚才说的函数指针，指向HelloWorld::update，也就是说，HelloWorld类定义的void update(float dt)被调用了，而且是在整个主循环里面CCDirector::sharedDirector()->mainLoop()。

（5）结束语：

整个cocos2d-x的框架源码就是这样，具体一些细节还未涉及，但我们已经理解程序一开始从main函数，然后怎么样一步步调用到我们自己是HelloWorld.h里面自己定义实现的函数，特别是update函数，同时也了解了cocos2d-x的一些内存管理机制和回调机制，也在这个框架代码里面，还有整个框架是怎么实现帧数控制的。

用《一代宗师》里面的一句话来概括这次框架源码研读之旅吧——”念念不忘，必有回响“。

0 0