cocos2d-x游戏引擎核心之九——跨平台

时间  2020-07-10
标签 cocos2d cocos 游戏 引擎 核心 之九 跨平台 栏目 Cocos2d-x 繁體版
原文   原文链接

1、cocos2d-x跨平台html

cocos2d-x究竟是怎样实现跨平台的呢？这里以Win32和Android为例。html5

1. 跨平台项目目录结构java

先看一下一个项目建立后的目录结构吧！这仍是以HelloCpp为例。python

从左边目录能够看到，Classes和Resource已经平台无关了，而Classes中包含了AppDelegate类，所以咱们能够认为AppDelegate是与平台最接近的类，在它以上就要区分平台了。linux

2. Win32下的实现android

在前一篇就介绍了Win32怎么开始cocos2dx，Win32平台下main.cpp就是程序入口：c++

int APIENTRY _tWinMain(HINSTANCE hInstance,  
                       HINSTANCE hPrevInstance,  
                       LPTSTR    lpCmdLine,  
                       int       nCmdShow)  
{  
    UNREFERENCED_PARAMETER(hPrevInstance);  
    UNREFERENCED_PARAMETER(lpCmdLine);  
  
    // create the application instance  
    AppDelegate app;//建立应用实例  
    CCEGLView* eglView = CCEGLView::sharedOpenGLView();  
    eglView->setViewName("HelloCpp");  
    eglView->setFrameSize(2048, 1536);  
    eglView->setFrameZoomFactor(0.4f);  
    return CCApplication::sharedApplication()->run();//运行程序  
}

Win32下的实现比较简单，就是正常的建立实例，运行就能够了。编程

3.Android下的实现浏览器

3.1.cocos2d-x程序入口网络

咱们先看一下Android下cocos2d-x程序入口点在哪，咱们知道Android是采用Java编写的，而cocos2d-x是c++编写的，因此若是要在Java中调用c++代码，那就须要采用JNI技术，看起来好像高端大气上档次，其实程序就是函数调用，也就是输入→处理→输出，因此JNI实际上简单抽象出来就这么回事：

java输入→Jni→c++输入→c++处理（API实现）→c++输出→Jni→java输出

在\proj.android\jni\hellocpp文件夹下能够找到main.cpp，这就是cocos2d-x的入口：

jint JNI_OnLoad(JavaVM *vm, void *reserved)  
{  
    JniHelper::setJavaVM(vm);  
  
    return JNI_VERSION_1_4;  
}  
  
void Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit(JNIEnv*  env, jobject thiz, jint w, jint h)  
{  
    if (!CCDirector::sharedDirector()->getOpenGLView())  
    {  
        CCEGLView *view = CCEGLView::sharedOpenGLView();  
        view->setFrameSize(w, h);  
  
        AppDelegate *pAppDelegate = new AppDelegate();  
        CCApplication::sharedApplication()->run();  
    }  
    else  
    {  
        ccGLInvalidateStateCache();  
        CCShaderCache::sharedShaderCache()->reloadDefaultShaders();  
        ccDrawInit();  
        CCTextureCache::reloadAllTextures();  
        CCNotificationCenter::sharedNotificationCenter()->postNotification(EVENT_COME_TO_FOREGROUND, NULL);  
        CCDirector::sharedDirector()->setGLDefaultValues();   
    }  
}

里面包含了2个函数，JNI_OnLoad和Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit。咱们看一下功能而先无论它在哪里被调用。

（1）JNI_OnLoad，这个函数主要是用来告诉Android VM当前使用的是什么版本是Jni，若是不提供此函数，则默认使用Jni1.1版本。

（2）Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit，这个函数很明显就是运行一个cocos2d-x的应用实例了，这和Win32是同样的，固然它多了一个openGlView的检测。一旦调用了它那么cocos2d-x游戏启动。

接下来再看看它们是在哪里被调用的。

在Android.mk文件内容以下：

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := hellocpp_shared

LOCAL_MODULE_FILENAME := libhellocpp

LOCAL_SRC_FILES := hellocpp/main.cpp \
                   ../../Classes/AppDelegate.cpp \
                   ../../Classes/HelloWorldScene.cpp

LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../Classes

LOCAL_WHOLE_STATIC_LIBRARIES := cocos2dx_static

include $(BUILD_SHARED_LIBRARY)

$(call import-module,cocos2dx)

3.2 JNI_OnLoad的调用

在proj.android\src\org\cocos2dx\hellocpp目录下，能够看到Android的入口Activity，也就是HelloCpp，它继承自Cocos2dxActivity。

public class HelloCpp extends Cocos2dxActivity{  
    protected void onCreate(Bundle savedInstanceState){  
        super.onCreate(savedInstanceState);  
    }  
      
    static {  
         System.loadLibrary("hellocpp");  
    }  
}

很简单的代码，由于功能都被封装到Cocos2dxActivity中了，因此OnCreate中调用了父类的OnCreate就把功能都实现了，而system.LoadLibrary就是载入编译出来的.so文件，此时就会执行JNI_OnLoad。

3.3 Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit的调用

那最重要的Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit是在哪调用呢？这就比较麻烦了，先大体了解一下Cocos2dxActivity作了一些什么事。

直接进入Cocos2dxActivity的OnCreate函数，它调用了一个init初始化函数：

public void init() {  
        // 设置布局，是一个FrameLayout  
        ViewGroup.LayoutParams framelayout_params =  
        new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,  
                                       ViewGroup.LayoutParams.FILL_PARENT);  
        FrameLayout framelayout = new FrameLayout(this);  
        framelayout.setLayoutParams(framelayout_params);  
  
        // 设置Cocos2dxEditText布局，这一个跟GLSurfaceView兼容的edittext  
        ViewGroup.LayoutParams edittext_layout_params =  
        new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,  
                                   ViewGroup.LayoutParams.WRAP_CONTENT);  
        Cocos2dxEditText edittext = new Cocos2dxEditText(this);  
        edittext.setLayoutParams(edittext_layout_params);  
  
        // 添加到framelaout  
　　　　 framelayout.addView(edittext);

　　　　 // 建立Cocos2dxGLSurfaceView  
        this.mGLSurfaceView = this.onCreateView();  
  
        // 添加到framelaout  
        framelayout.addView(this.mGLSurfaceView);  

　　　　 // Switch to supported OpenGL (ARGB888) mode on emulator  
        if (isAndroidEmulator())  
           this.mGLSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);  
  
        //设置Cocos2dxRenderer和Cocos2dxEditText  
        this.mGLSurfaceView.setCocos2dxRenderer(new Cocos2dxRenderer());  
        this.mGLSurfaceView.setCocos2dxEditText(edittext);  
  
        // 设置framelayout做为内容视图  
    　　 setContentView(framelayout);  
    }

在这里Cocos2dxActivity作的就是建立Cocos2dxGLSurfaceView，并设置了Cocos2dxRenderer和Cocos2dxEditText，而后添加到FramLayout。具体的各部分实现这里就不贴代码了，画了个图：

2、 AppDelegate 析造函数没有被调用

　　怎么样使用 Cocos2d-x 快速开发游戏，方法很简单，你能够看看其自带的例程，或者从网上搜索教程，运行起第一个 Scene HelloWorldScene，而后在HelloWorldScene 里面写相关逻辑代码，添加咱们的层、精灵等 ~ 咱们并不必定须要知道 Cocos2d-x 是如何运行或者在各类平台之上运行，也不用知道 Cocos2d-x 的游戏是如何运行起来的，它又是如何渲染界面的 ~~~

　　咱们只用知道 Cocos2d-x 的程序是由 AppDelegate 的方法 applicationDidFinishLaunching 开始，在其中作些必要的初始化，并建立运行第一个 CCScene 便可，正如咱们第一次使用各类编程语言写 Hello World! 的程序同样，如 Python 打印：

print(‘Hello World!’)

咱们能够不用关心其是怎么实现的，咱们只要知道这样就能打印一句话就够了，这就是封装所带来的好处 。Cocos2d-x 自带的例程已经足够丰富，可是有些问题并非看看例子，调用其方法就能明白的事情，在这里遇到了以下问题：

// AppDelegate.cpp 文件

AppDelegate::AppDelegate()
{
    CCLog("AppDelegate()");     // AppDelegate 构造函数打印
}

AppDelegate::~AppDelegate()
{
    CCLog("AppDelegate().~()");     // AppDelegate 析构函数打印
}

// 程序入口
bool AppDelegate::applicationDidFinishLaunching()
{
    // initialize director
    CCDirector *pDirector = CCDirector::sharedDirector();
    pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());

    // 初始化，资源适配，屏幕适配，运行第一个场景等代码
    ...
    ...
    ...

    return true;
}

void AppDelegate::applicationDidEnterBackground()
{
    CCDirector::sharedDirector()->pause();
}

void AppDelegate::applicationWillEnterForeground()
{
    CCDirector::sharedDirector()->resume();
}

　　此时我并不知道程序运行时，什么时候调用 AppDelegate 的构造函数，析构函数和程序入口函数，咱们只要知道，程序在这里调用了其构造函数，而后进入入口函数执行其过程，最后再调用其析构函数便可。然而事与愿违，在实际执行的过程当中，发现程序只调用其构造函数和入口函数，而直到程序结束运行，都没有调用其析构函数。要验证此说法很简单，只要如上在析构函数中调用打印日志即可验证。

　　发生这样的状况，让我在构造函数建立[资源]，而且在析构函数中释放[资源] 的想法不能完成！！！ 咱们知道它是从哪里开始运行，但殊不知道它在哪里结束！疑问，惟有疑问！

两个入口

程序入口的概念是相对的，AppDelegate 做为跨平台程序入口，在这之上作了另外一层的封装，封装了不一样平台的不一样实现，好比咱们一般认为一个程序是由 main 函数开始运行，那咱们就去找寻，咱们看到了在 proj.linux 目录下存在 main.cpp 文件，这就是咱们要看的内容，以下：

#include "main.h"
#include "../Classes/AppDelegate.h"
#include "cocos2d.h"


#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string>

USING_NS_CC;

// 500 is enough?
#define MAXPATHLEN 500

int main(int argc, char **argv)
{
    // get application path
    int length;
    char fullpath[MAXPATHLEN];
    length = readlink("/proc/self/exe", fullpath, sizeof(fullpath));
    fullpath[length] = '\0';

    std::string resourcePath = fullpath;
    resourcePath = resourcePath.substr(0, resourcePath.find_last_of("/"));
    resourcePath += "/../../../Resources/";

    // create the application instance
    AppDelegate app;
    CCApplication::sharedApplication()->setResourceRootPath(resourcePath.c_str());
    CCEGLView* eglView = CCEGLView::sharedOpenGLView();
    eglView->setFrameSize(720, 480);
　　 // eglView->setFrameSize(480, 320);

    return CCApplication::sharedApplication()->run();
}

在这里咱们看见了程序的真正入口，包含一个 main 函数，今后进入，执行 cocos2d-x 程序。咱们看到 main 就知道其是入口函数，那么没有 main 函数就没有入口了吗？显然不是，以 Android 平台启动 cocos2d-x 程序为例。咱们找到 Android 平台与上面等价的入口点，proj.android/jni/hellocpp/main.cpp：

#include "cocos2d.h"
#include "AppDelegate.h"
#include "platform/android/jni/JniHelper.h"
#include <jni.h>
#include <android/log.h>

#define  LOG_TAG    "main"
#define  LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)

using namespace cocos2d;

extern "C"
{

jint JNI_OnLoad(JavaVM *vm, void *reserved)
{
    JniHelper::setJavaVM(vm);

    return JNI_VERSION_1_4;
}

void Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit(JNIEnv*  env, jobject thiz, jint w, jint h)
{
    if (!CCDirector::sharedDirector()->getOpenGLView())
    {
        CCEGLView *view = CCEGLView::sharedOpenGLView();
        view->setFrameSize(w, h);

        AppDelegate *pAppDelegate = new AppDelegate();
        CCApplication::sharedApplication()->run();
    }
    else
    {
        ccDrawInit();
        ccGLInvalidateStateCache();

        CCShaderCache::sharedShaderCache()->reloadDefaultShaders();
        CCTextureCache::reloadAllTextures();
        CCNotificationCenter::sharedNotificationCenter()->postNotification(EVNET_COME_TO_FOREGROUND, NULL);
        CCDirector::sharedDirector()->setGLDefaultValues(); 
    }
}

　　咱们并无看到所谓的 main 函数，这是因为不一样的平台封装因此有着不一样的实现，在 Android 平台，默认是使用 Java 开发，可使用 Java 经过 Jni 调用 C++ 程序，而这里也正式如此。咱们暂且只需知道，由 Android 启动一个应用，经过各类峰回路转，最终执行到了 Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit 函数，由此，便开始了咱们 cocos2d-x Android 平台的程序入口处。对于跨平台的 cocos2d-x 来讲，除非必要，不然可没必要深究其理，好比想要使用 Android 平台固有的特性等，那就须要更多的了解 Jni 使用方法，以及 Android 操做系统的更多细节。

因此说程序的入口是相对的，正如博文开始的 print(‘Hello World’) 同样，不一样的语言，不一样平台总有着不一样的实现。

这里咱们参考了两个不一样平台的实现， Linux 和 Android 平台 cocos2d-x 程序入口 main.cpp的实现，那么其它平台呢，如 iOS ,Win32 等 ~~~ 异曲同工，其它平台程序的入口必然包含着其它平台的不一样封装实现 ，知道有等价在此两平台的程序入口便可。而经过这两个平台也足够解决咱们的疑问，程序的开始与结束 ~

问题的推测

咱们就从 Linux 和 Android 这两个平台的入口函数开始，看看 cocos2d-x 的执行流程到底为什么？何以发生只执行了 AppDelegate 的构造函数，而没有析构函数。在查看 cocos2d-x 程序代码时，咱们只关注必要的内容，何谓必要，只要能解决咱们此时的疑问便可！在两个平台的入口函数，咱们看到以下内容：

// Linux 平台关键代码
int main(int argc, char **argv)
{
    // 初始化等内容
    ...
    ...
    // 建立 app 变量
 AppDelegate app;  
    ...
    ...
    // 执行 核心 run() 方法
    return CCApplication::sharedApplication()->run();
}

// Android 平台关键代码
void Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit(JNIEnv*  env, jobject thiz, jint w, jint h)
{
    if (!CCDirector::sharedDirector()->getOpenGLView())
    {
        CCEGLView *view = CCEGLView::sharedOpenGLView();
        view->setFrameSize(w, h);

        // 建立 AppDelegate 对象
        AppDelegate *pAppDelegate = new AppDelegate();
        // 执行 核心 run() 方法
        CCApplication::sharedApplication()->run();
    }
    else
    {
        ...
        ...
    }
}

　　不一样的平台，却实现相同操做，建立 AppDelegate 变量和执行 run 方法。下面将以 Linux 平台为例，来讲明程序是如何开始与结束的，由于 Linux 的内部实现要简单一点，而 Android 平台的实现稍显麻烦，Jni 之间来回调用，对咱们理解 cocos2d-x 的执行流程反而有所 阻碍，何况 cocos2d-x 自己就是跨平台的程序。没必要拘泥于特有平台的专有特性。

程序的流程 （这里以 Linux 的实现为主，其它平台举一反三便可）

AppDelegate 与 CCApplication关系

　　咱们从 main.cpp 中 CCApplication::sharedApplication()->run(); 这一句看起，这一句标志着， cocos2d-x 程序正式开始运行，一点点开始分析，咱们定位到 sharedApplication() 方法的实现，这里只给出必要的代码，具体看一本身直接看源码：

// [cocos2dx-path]/cocos2dx/platform/linux/CCApplication.cpp
...
// 此变量为定义了一个 CCApplication 的静态变量，也及时本身类型自己，实现单例模式
CCApplication * CCApplication::sm_pSharedApplication = 0;
...
// 构造函数，将所建立的 对象直接付给其静态变量
CCApplication::CCApplication()
{
    // 断言在此决定着此构造函数只能运行一次
    CC_ASSERT(! sm_pSharedApplication);
    sm_pSharedApplication = this;
}

CCApplication::~CCApplication()
{
    CC_ASSERT(this == sm_pSharedApplication);
    sm_pSharedApplication = NULL;
    m_nAnimationInterval = 1.0f/60.0f*1000.0f;
}

// run 方法，整个 cocos2d-x 的主循环在这里开始
int CCApplication::run()
{
    // 首次启动调用初始化函数
    if (! applicationDidFinishLaunching())
    {
        return 0;
    }

    // 游戏主循环，这里 Linux 的实现相比其它平台的实现，简单明了
    for (;;) {
        long iLastTime = getCurrentMillSecond();
        // 在循环以内调用每一帧的逻辑，组织而且控制 cocos2d-x 之中各个组件
        CCDirector::sharedDirector()->mainLoop();
        long iCurTime = getCurrentMillSecond();
        // 这里的几个时间变量，能够控制每一帧所运行的 最小 时间，从而控制游戏的帧率
        if (iCurTime-iLastTime<m_nAnimationInterval){
            usleep((m_nAnimationInterval - iCurTime+iLastTime)*1000);
        }

    }
    // 注意，这里的 for 循环，并无退出循环条件，这也决定着 run() 方法永远也不会返回
    return -1;
}

// 方法直接返回了静态对象，而且作了断言，也既是在调用此方法以前，
// 必须事先建立一个 CCApplication 的对象，以保证其静态变量可以初始化，不然返回空
CCApplication* CCApplication::sharedApplication()
{
    CC_ASSERT(sm_pSharedApplication);
    return sm_pSharedApplication;
}

　　从上面的内容能够看出，从 sharedApplication() 方法，到 run() 方法，在这以前，咱们须要调用到它(CCApplication)的构造函数，不然不能运行，这就是为何在 CCApplication::sharedApplication()->run(); 以前，咱们首先使用了 AppDelegate app; 建立 AppDelegate 变量的缘由！ 嗯 ！！ AppDelegate 和 CCAppliation 是什么关系? 由 AppDelegate 的定义咱们能够知道，它是 CCApplication 的子类，在建立子类对象的时候，调用其构造函数的同时，父类构造函数也会执行，而后就将 AppDelegate 的对象赋给了 CCApplication 的静态变量，而在 AppDelegate 之中咱们实现了 applicationDidFinishLaunching 方法，因此在 CCApplication 中 run 方法的开始处调用的就是 AppDelegate 之中的实现。而咱们在此方法中咱们初始化了一些变量，建立了第一个 CCScene 场景等，以后的控制权，便全权交给了 CCDirector::sharedDirector()->mainLoop(); 方法了。

（这里的实现机制，不作详细说明，简单说来：applicationDidFinishLaunching 是由 CCApplicationProtocol 定义，CCApplication 继承， AppDelegate 实现的 ~）

比较重要的所在，for 循环并无循环退出条件，因此 run 方法永远不会返回。那么是怎么结束的呢?

从 CCApplication 到 CCDirector

cocos2d-x 程序已经运行起来了，咱们继续下一步，mainLoop 函数：

// [cocos2dx-path]/cocos2dx/CCDirector.cpp
...
// 定义静态变量，实现单例模式
static CCDisplayLinkDirector *s_SharedDirector = NULL;
...
// 返回 CCDirector 实例
CCDirector* CCDirector::sharedDirector(void)
{
    // 判断静态变量，以保证只有一个实例
    if (!s_SharedDirector)
    {
        s_SharedDirector = new CCDisplayLinkDirector();
        s_SharedDirector->init();
    }
    // CCDisplayLinkDirector 为 CCDirector 的子类，这里返回了其子类
    return s_SharedDirector;
}

// mainLoop 方法的具体实现
void CCDisplayLinkDirector::mainLoop(void)
{
    // 此变量是咱们须要关注，而且跟踪的，由于它决定着程序的结束时机
   if (m_bPurgeDirecotorInNextLoop)
   {
       m_bPurgeDirecotorInNextLoop = false;
       // 运行到此，说明程序的运行，已经没有逻辑代码须要处理了
       purgeDirector();
   }
   else if (! m_bInvalid)
    {
        // 屏幕绘制，并作一些相应的逻辑处理，其内部处理，这里暂且不作过多探讨
        drawScene();

        // 这里实现了 cocos2d-x CCObject 对象的内存管理机制，对此有兴趣者，能够深刻下去
        CCPoolManager::sharedPoolManager()->pop();
    }
}

// 弹出场景 CCScene
void CCDirector::popScene(void)
{
    CCAssert(m_pRunningScene != NULL, "running scene should not null");

    m_pobScenesStack->removeLastObject();
    unsigned int c = m_pobScenesStack->count();

    if (c == 0)
    {
        // 若是没有场景，调用 end() 方法
        end();
    }
    else
    {
        m_bSendCleanupToScene = true;
        m_pNextScene = (CCScene*)m_pobScenesStack->objectAtIndex(c - 1);
    }
}

void CCDirector::end()
{
    // 在 end 方法中，设置了变量为 true，这所致的结果，在 mainLoop 函数中，达成了运行 purgeDirector 方法的条件
    m_bPurgeDirecotorInNextLoop = true;
}

// 此方法作些收尾清理的工做
void CCDirector::purgeDirector()
{
    ...
    if (m_pRunningScene)
    {
        m_pRunningScene->onExit();
        m_pRunningScene->cleanup();
        m_pRunningScene->release();
    }
    // 作一些清理的工做
   ...
    // OpenGL view

    // ###此句代码关键###
    m_pobOpenGLView->end();
    m_pobOpenGLView = NULL;

    // delete CCDirector
    release();
}

// 设置 openglview
void CCDirector::setOpenGLView(CCEGLView *pobOpenGLView)
{
    CCAssert(pobOpenGLView, "opengl view should not be null");

    if (m_pobOpenGLView != pobOpenGLView)
    {
        // EAGLView is not a CCObject
        delete m_pobOpenGLView; // [openGLView_ release]
        // 为当前 CCDirector m_pobOpenGLView  赋值
        m_pobOpenGLView = pobOpenGLView;

        // set size
        m_obWinSizeInPoints = m_pobOpenGLView->getDesignResolutionSize();

        createStatsLabel();

        if (m_pobOpenGLView)
        {
            setGLDefaultValues();
        }

        CHECK_GL_ERROR_DEBUG();

        m_pobOpenGLView->setTouchDelegate(m_pTouchDispatcher);
        m_pTouchDispatcher->setDispatchEvents(true);
    }
}

　　游戏的运行以场景为基础，每时每刻都有一个场景正在运行，其内部有一个场景栈，遵循后进后出的原则，当咱们显示的调用 end() 方法，或者弹出当前场景之时，其自动判断，若是没有场景存在，也会触发 end() 方法，以说明场景运行的结束，而游戏若是没有场景，就像演出没有了舞台，程序进入最后收尾的工做，经过修改变量 m_bPurgeDirecotorInNextLoop 促使在程序 mainLoop 方法以内调用 purgeDirector 方法。

CCEGLView 的收尾工做

　　purgeDirector 方法以内，经过猜想与排查，最终定位到 m_pobOpenGLView->end(); 方法，在这里结束了 cocos2d-x 游戏进程。而 m_pobOpenGLView 什么时候赋值，它的具体实现又在哪里呢？咱们能够在 AppDelegate 的 applicationDidFinishLaunching 方法中找到以下代码：

// AppDelegate.cpp

CCDirector *pDirector = CCDirector::sharedDirector();
pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());

咱们终于走到最后一步，看 CCEGLView 是若是负责收尾工做的:

// [cocos2dx-path]/cocos2dx/platform/linux.CCEGLView.cpp

...
CCEGLView* CCEGLView::sharedOpenGLView()
{
    static CCEGLView* s_pEglView = NULL;
    if (s_pEglView == NULL)
    {
        s_pEglView = new CCEGLView();
    }
    return s_pEglView;
}
...

// openglview 结束方法
void CCEGLView::end()
{
    /* Exits from GLFW */
    glfwTerminate();
    delete this;
    exit(0);
}

end() 方法很简单，只须要看到最后一句 exit(0); 就明白了。

cocos2d-x 程序的结束流程

　　程序运行时期，由 mainLoop 方法维持运行着游戏以内的各个逻辑，当在弹出最后一个场景，或者直接调用 CCDirector::end(); 方法后，触发游戏的清理工做，执行 purgeDirector 方法，从而结束了 CCEGLView（不一样平台不一样封装，PC使用OpenGl封装，移动终端封装的为 OpenGl ES） 的运行，调用其 end() 方法，从而直接执行 exit(0); 退出程序进程，从而结束了整个程序的运行。（Android 平台的 end() 方法内部经过Jni 方法 terminateProcessJNI(); 调用 Java 实现的功能，其功能同样，直接结束了当前运行的进程）

　　从程序的 main 方法开始，再建立 AppDelegate 等对象，运行过程当中倒是经过 exit(0); 来退出程序。因此咱们看到了 AppDelegate 构造函数被调用，而其析构函数没有被调用的现象。exit(0); 的执行，意味着咱们的程序彻底结束，固然咱们的进程资源也会被操做系统释放。可是注意，这里的"在构造函数建立[资源]，而且在析构函数中释放[资源]"并不是绝对意义上的程序进程资源，在程序退出的时候，程序所使用的资源固然会被系统回收. 可是若是我在构造函数调用网络接口初始化，析构再调用一次通知，所影响到的相似这种 非本地资源 逻辑上的处理，便会留下隐患。而经过理解 cocos2d-x 的运行机制，能够减小这种可能存在的隐患。

cocos2d-x 的总体把握

　　在本文经过解决一个小疑问，而去分析 cocos2d-x 游戏的运行流程，固然其中不少细致末叶咱们并无深刻下去。不去解决这个疑问也能够，知道没有调用析构函数，那我就不调用即是 （这也是简单的解决方法，也不用以为这不可行 ）。这里只是借着这个疑问，对 cocos2d-x 的流程稍做探寻而已。也没有贴一堆 cocos2d-x 源码去分析，其思路也有迹可循。

　　什么是 cocos2d-x ,它是 cocos2d 一个 C++ 的实现，除 C++ 以外，有 python ，Objective-C 等其它语言的实现，那该怎么去理解 cocos2d ，能够这么理解，cocos2d 是一个编写 2D 游戏的通用形框架，这种框架提供了一个通用模型，而这种模型或者说架构是 无关语言与平台 的，说 cocos2d-x 使用 C++ 编写，其跨平台能力很强，但它能跑在浏览器上么？cocos2d 仍是有着 html5 的实现，固然平台决定着语言的选择，而 cocos2d 可以适应这么多不一样的语言和平台，其良好的设计，清晰的结构功不可没。 而对不一样语言，对相同功能有着不一样的封装，正如在本文问题中，在不一样平台（Linux 和 Android），对相同功能有着不一样的封装殊途同归。那么封装到最后，咱们对 cocos2d 的理解就只剩下了，咱们要写游戏，那么须要导演，场景、层、精灵、动做等 ~~ 组织好这些之间的关系便可 ~

【转自】http://game.dapps.net/gamedev/game-engine/9515.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程