【cocos2d-x 源码解析】创建 OpenGL 环境

创建 OpenGL 上下文

cocos2d-x 是基本 OpenGL 实现的，所以游戏启动之后做的第一件事就是创建 OpenGL 上下文，之后才能进行渲染。在 win32 上，创建 OpenGL context 的过程就是创建一个 OpenGL 窗口，cocos2d-x 使用的是 glfw 库，首先我们回顾一下 glfw 创建窗口的过程

int main()
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
    GLFWwindow* window = glfwCreateWindow(400, 400, "Color", nullptr, nullptr);
    if (window == nullptr) { return 1; }
    glfwMakeContextCurrent(window);

    glewExperimental = GL_TRUE;
    if (GLEW_OK != glewInit()) { return 2; }

    glClearColor(255, 255, 255, 255);
    while (!glfwWindowShouldClose(window))
    {
        glfwPollEvents();
        glClear(GL_COLOR_BUFFER_BIT);
        //render
        glfwSwapBuffers(window);
    }

    glfwTerminate();
    return 0;
}

这是 glfw 创建 OpenGL 窗口、调用 OpenGL 渲染指令以及监听处理各种事件的过程，接下来看看 cocos2d-x 中是如何使用 glfw 的。

回顾窗口启动

关于 cocos2d-x 的窗口启动过程可以看我前面的文章
cocos2d-x 窗口启动
下面简单的回顾一下这个过程。在 main 函数创建一个 AppDelegate 实例之后，调用 Application 的 run 方法启动游戏

int Application::run()
{
    //...
    initGLContextAttrs();

    if (!applicationDidFinishLaunching())
    {
        return 1;
    }

    auto director = Director::getInstance();
    auto glview = director->getOpenGLView();
    glview->retain();

    while(!glview->windowShouldClose())
    {
        //...
        director->mainLoop();
        glview->pollEvents();
    }

    if (glview->isOpenGLReady())
    {
        director->end();
        director->mainLoop();
        director = nullptr;
    }
    glview->release();
    return 0;
}

这是 run 方法的关键代码，首先调用 initGLContextAttrs 设置 OpenGL context 的属性，这个方法在其子类 Appdelegate 中实现

void AppDelegate::initGLContextAttrs()
{
    GLContextAttrs glContextAttrs = {8, 8, 8, 8, 24, 8};
    GLView::setGLContextAttrs(glContextAttrs);
}

目前 cocos2d-x 只能设置六个属性，分别是 rgba 四个颜色属性，深度和模板；定义一个 GLContextAttrs 变量，然后调用 GLView 的静态方法进行设置，GLView 是我们这篇文章的重点，下面会解析这个类。设置完 OpenGL Context 属性之后，调用 applicationDidFinishLaunching 方法进行一些初始化，这个方法也是在子类 AppDelegate 中实现

bool AppDelegate::applicationDidFinishLaunching() {
    auto director = Director::getInstance();
    auto glview = director->getOpenGLView();
    if(!glview) {
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32) || (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) || (CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)
        glview = GLViewImpl::createWithRect("CppSource", Rect(0, 0, designResolutionSize.width, designResolutionSize.height));
#else
        glview = GLViewImpl::create("CppSource");
#endif
        director->setOpenGLView(glview);
    }
    //...
    return true;
}

applicationDidFinishLaunching 做了很多初始化工作，其中最重要的就是初始化导演实例 Director 和 OpenGL 窗口管理类实例 GLView。Director 对象中有一个 GLView 实例，该实例默认为空，调用 GLViewImpl 的 createWithRect 创建一个实例。GLViewImpl 继承自 GLView，是桌面程序的 OpenGL 窗口管理类，而 GLView 则是一个上层的 OpenGL 窗口管理类，提供部分接口，更多的接口则在 GLViewImpl 中实现。GLView 和 GLViewImpl 的目录结构

|-cocos
    |-platform
        |-CCGLView.h
        |-CCGLView.cpp
        |-desktop
            |-CCGLViewImpl-desktop.h
            |-CCGLViewImpl-desktop.cpp

applicationDidFinishLaunching 执行完成之后就得到了一个 Director 实例和一个 GLViewImpl 实例，OpenGL 窗口也创建出来了，OpenGL context 也存在了，可以说 OpenGL 环境已经具备了，接下来就可以开始渲染了。在 while 循环中调用 GLView 的 windowShouldClose 检测 OpenGL 窗口是否关闭，如果关闭了则跳出循环，做一些回收操作然后程序结束，如果没关闭则程序在这里阻塞，每一帧都会进入到这个 while 循环体中，这个循环体做的事情就是监听事件和 OpenGL 渲染。

GLView(GLViewImpl)

接下来就是主角 GLView(GLViewImpl) 登场了，首先看 GLViewImpl 的构造函数

GLViewImpl::GLViewImpl(bool initglfw)
: _captured(false)
, _supportTouch(false)
, _isInRetinaMonitor(false)
, _isRetinaEnabled(false)
, _retinaFactor(1)
, _frameZoomFactor(1.0f)
, _mainWindow(nullptr)
, _monitor(nullptr)
, _mouseX(0.0f)
, _mouseY(0.0f)
{
    _viewName = "cocos2dx";
    g_keyCodeMap.clear();
    for (auto& item : g_keyCodeStructArray)
    {
        g_keyCodeMap[item.glfwKeyCode] = item.keyCode;
    }

    GLFWEventHandler::setGLViewImpl(this);
    if (initglfw)
    {
        glfwSetErrorCallback(GLFWEventHandler::onGLFWError);
        glfwInit();
    }
}

这里做了两件重要的事，第一件就是初始化 GLFWEventHandler；第二件就是执行 glfwInit()，也就是我们熟悉的 glfw 初始化了。接下来看GLFWEventHandler 这个类，这个类在 CCGLViewImpl-desktop.cpp 中定义，它的内容很简单

class GLFWEventHandler
{
public:
    static void onGLFWError(int errorID, const char* errorDesc)
    {
        if (_view)
            _view->onGLFWError(errorID, errorDesc);
    }

    static void onGLFWMouseCallBack(GLFWwindow* window, int button, int action, int modify)
    {
        if (_view)
            _view->onGLFWMouseCallBack(window, button, action, modify);
    }

    static void onGLFWMouseMoveCallBack(GLFWwindow* window, double x, double y)
    {
        if (_view)
            _view->onGLFWMouseMoveCallBack(window, x, y);
    }

    static void onGLFWMouseScrollCallback(GLFWwindow* window, double x, double y)
    {
        if (_view)
            _view->onGLFWMouseScrollCallback(window, x, y);
    }

    static void onGLFWKeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
    {
        if (_view)
            _view->onGLFWKeyCallback(window, key, scancode, action, mods);
    }

    static void onGLFWCharCallback(GLFWwindow* window, unsigned int character)
    {
        if (_view)
            _view->onGLFWCharCallback(window, character);
    }

    static void onGLFWWindowPosCallback(GLFWwindow* windows, int x, int y)
    {
        if (_view)
            _view->onGLFWWindowPosCallback(windows, x, y);
    }

    static void onGLFWframebuffersize(GLFWwindow* window, int w, int h)
    {
        if (_view)
            _view->onGLFWframebuffersize(window, w, h);
    }

    static void onGLFWWindowSizeFunCallback(GLFWwindow *window, int width, int height)
    {
        if (_view)
            _view->onGLFWWindowSizeFunCallback(window, width, height);
    }

    static void setGLViewImpl(GLViewImpl* view)
    {
        _view = view;
    }

    static void onGLFWWindowIconifyCallback(GLFWwindow* window, int iconified)
    {
        if (_view)
        {
            _view->onGLFWWindowIconifyCallback(window, iconified);
        }
    }

private:
    static GLViewImpl* _view;
};

可以看到，这是一个只有静态方法的工具类，用于 glfw 的事件回调处理。首先调用 setGLViewImpl 保存一个 GLViewImpl 实例，然后注册 glfw 事件时直接使用这个类的静态方法作为回调函数，当事件触发时就会调用这个类的静态方法，然后再调用 _view 相应的方法，这样就达到了将 GLViewImpl 的方法注册给事件的目的，所以 GLFWEventHandle 其实是一个中介，将 glfw 事件回调和 GLViewImpl 的实例方法联系起来。

总结起来，GLViewImpl 的构造函数做了这三件事件，初始化 GLFWEventHandler，注册一个错误回调函数，初始化 glfw。接下来回到 createWithRect 方法

GLViewImpl* GLViewImpl::createWithRect(const std::string& viewName, Rect rect, float frameZoomFactor)
{
    auto ret = new (std::nothrow) GLViewImpl;
    if(ret && ret->initWithRect(viewName, rect, frameZoomFactor)) {
        ret->autorelease();
        return ret;
    }
    CC_SAFE_DELETE(ret);
    return nullptr;
}

这个方法也很简单，new 一个 GLViewImpl 实例，然后调用 initWithRect 方法

bool GLViewImpl::initWithRect(const std::string& viewName, Rect rect, float frameZoomFactor)
{
    setViewName(viewName);

    _frameZoomFactor = frameZoomFactor;

    glfwWindowHint(GLFW_RESIZABLE,GL_FALSE);
    glfwWindowHint(GLFW_RED_BITS,_glContextAttrs.redBits);
    glfwWindowHint(GLFW_GREEN_BITS,_glContextAttrs.greenBits);
    glfwWindowHint(GLFW_BLUE_BITS,_glContextAttrs.blueBits);
    glfwWindowHint(GLFW_ALPHA_BITS,_glContextAttrs.alphaBits);
    glfwWindowHint(GLFW_DEPTH_BITS,_glContextAttrs.depthBits);
    glfwWindowHint(GLFW_STENCIL_BITS,_glContextAttrs.stencilBits);

    int needWidth = rect.size.width * _frameZoomFactor;
    int neeHeight = rect.size.height * _frameZoomFactor;

    _mainWindow = glfwCreateWindow(needWidth, neeHeight, _viewName.c_str(), _monitor, nullptr);

    //...

    int realW = 0, realH = 0;
    glfwGetWindowSize(_mainWindow, &realW, &realH);

    //...

    glfwMakeContextCurrent(_mainWindow);

    glfwSetMouseButtonCallback(_mainWindow, GLFWEventHandler::onGLFWMouseCallBack);
    glfwSetCursorPosCallback(_mainWindow, GLFWEventHandler::onGLFWMouseMoveCallBack);
    glfwSetScrollCallback(_mainWindow, GLFWEventHandler::onGLFWMouseScrollCallback);
    glfwSetCharCallback(_mainWindow, GLFWEventHandler::onGLFWCharCallback);
    glfwSetKeyCallback(_mainWindow, GLFWEventHandler::onGLFWKeyCallback);
    glfwSetWindowPosCallback(_mainWindow, GLFWEventHandler::onGLFWWindowPosCallback);
    glfwSetFramebufferSizeCallback(_mainWindow, GLFWEventHandler::onGLFWframebuffersize);
    glfwSetWindowSizeCallback(_mainWindow, GLFWEventHandler::onGLFWWindowSizeFunCallback);
    glfwSetWindowIconifyCallback(_mainWindow, GLFWEventHandler::onGLFWWindowIconifyCallback);

    setFrameSize(rect.size.width, rect.size.height);

    //...

    initGlew();

    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
    return true;
}

在这个方法里看到很多熟悉的 glfw 函数，首先调用 glfwWindowHint 设置一些参数，然后调用 glfwCreateWindow 创建窗口，调用 glfwMakeContextCurrent 将创建出来的窗口设置为 OpenGL 的当前上下文；之后是注册各种事件，可以看到事件的回调函数都是 GLFWEventHandler 的静态方法，最后调用 initGlew 初始化 glew

bool GLViewImpl::initGlew()
{
#if (CC_TARGET_PLATFORM != CC_PLATFORM_MAC)
    GLenum GlewInitResult = glewInit();
    if (GLEW_OK != GlewInitResult)
    {
        MessageBox((char *)glewGetErrorString(GlewInitResult), "OpenGL error");
        return false;
    }
    //...

    return true;
}

initGlew 只是简单地调用 glewInit 函数，然后加一些成功与否判断而已。GLViewImpl 的构造函数和 initWithRect 方法，完成了 glfw 和 glew 的初始化工作，创建一个 OpenGL 窗口并设置 OpenGL context，注册各种 glfw 事件，所以我们可以说执行完 AppDelegate 的 applicationDidFinishLuanching 方法之后，OpenGL 环境已全部初始完成。

接下来回到 Application 的 run 方法，调用 applicationDidFinishLuanching 方法初始化 OpenGL 环境之后，在 while 循环条件体不断调用 GLView 的 windowShouldClose 方法检测窗口是否关闭

bool GLViewImpl::windowShouldClose()
{
    if(_mainWindow)
        return glfwWindowShouldClose(_mainWindow) ? true : false;
    else
        return true;
}

就是简单地调用 glfwWindowShouldClose 函数而已。如果窗口没有关闭，则循环执行两件事，监听事件和渲染，监听事件也很简单

void GLViewImpl::pollEvents()
{
    glfwPollEvents();
}

而渲染则是调用 Director 的 mainLoop 方法

void DisplayLinkDirector::mainLoop()
{
    if (_purgeDirectorInNextLoop)
    {
        _purgeDirectorInNextLoop = false;
        purgeDirector();
    }
    else if (_restartDirectorInNextLoop)
    {
        _restartDirectorInNextLoop = false;
        restartDirector();
    }
    else if (! _invalid)
    {
        drawScene();

        // release the objects
        PoolManager::getInstance()->getCurrentPool()->clear();
    }
}

Director 中有两个控制变量，_purgeDirectorInNextLoop 为真时清除导演，_restartDirectorInNextLoop 为真时重置导演，两个变量都为假时才调用 drawScene，很明显 drawScene 做的事就是真正的渲染场景了

void Director::drawScene()
{
    // calculate "global" dt
    calculateDeltaTime();

    if (_openGLView)
    {
        _openGLView->pollEvents();
    }

    //tick before glClear: issue #533
    if (! _paused)
    {
        _eventDispatcher->dispatchEvent(_eventBeforeUpdate);
        _scheduler->update(_deltaTime);
        _eventDispatcher->dispatchEvent(_eventAfterUpdate);
    }

    _renderer->clear();
    experimental::FrameBuffer::clearAllFBOs();
    /* to avoid flickr, nextScene MUST be here: after tick and before draw.
     * FIXME: Which bug is this one. It seems that it can't be reproduced with v0.9
     */
    if (_nextScene)
    {
        setNextScene();
    }

    pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);

    if (_runningScene)
    {
#if (CC_USE_PHYSICS || (CC_USE_3D_PHYSICS && CC_ENABLE_BULLET_INTEGRATION) || CC_USE_NAVMESH)
        _runningScene->stepPhysicsAndNavigation(_deltaTime);
#endif
        //clear draw stats
        _renderer->clearDrawStats();

        //render the scene
        _runningScene->render(_renderer);

        _eventDispatcher->dispatchEvent(_eventAfterVisit);
    }

    // draw the notifications node
    if (_notificationNode)
    {
        _notificationNode->visit(_renderer, Mat4::IDENTITY, 0);
    }

    if (_displayStats)
    {
        showStats();
    }
    _renderer->render();

    _eventDispatcher->dispatchEvent(_eventAfterDraw);

    popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);

    _totalFrames++;

    // swap buffers
    if (_openGLView)
    {
        _openGLView->swapBuffers();
    }

    if (_displayStats)
    {
        calculateMPF();
    }
}

drawScene 做的事比较，大概可分为三部分，处理计时和事件，切换场景，绘制场景。在第一部分中，首先调用 calculateDeltaTime 计算帧间隔时间，然后调用 glfwPollEvents 监听事件，最后执行调度器 scheduler 的 update 方法。第二部分只做一件事，检测是否需要切换到下个场景，如果需要则调用 setNextScene 方法设置 _runningScene 的值为 _nextScene。第三部分开始真正绘制场景，在导演 Director 中有两个变量，_runningScene 和 _render，分别表示当前运行的场景和渲染器。场景渲染的流程如下
* 第一步，如果使用了物理引擎或者 3D 导航 api，则调用 setPhysicsAndNavigation 方法执行相应的 update 方法
* 第二步，调用渲染器的 clearDrawStats 方法清除绘制统计
* 第三步，调用场景的 render 方法绘制场景中的所有对象
* 第四步，如果 _displayStats 为真则绘制调试信息
* 第五步，调用 glfwSwapBuffers 完成执行 OpenGL 渲染

其中最重要的是第三步，即场景的 render 方法

void Scene::render(Renderer* renderer)
{
    auto director = Director::getInstance();
    Camera* defaultCamera = nullptr;
    const auto& transform = getNodeToParentTransform();

    for (const auto& camera : getCameras())
    {
        if (!camera->isVisible())
            continue;

        Camera::_visitingCamera = camera;
        if (Camera::_visitingCamera->getCameraFlag() == CameraFlag::DEFAULT)
        {
            defaultCamera = Camera::_visitingCamera;
        }

        director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
        director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
        camera->apply();
        //clear background with max depth
        camera->clearBackground();
        //visit the scene
        visit(renderer, transform, 0);
#if CC_USE_NAVMESH
        if (_navMesh && _navMeshDebugCamera == camera)
        {
            _navMesh->debugDraw(renderer);
        }
#endif

        renderer->render();

        director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
    }

#if CC_USE_3D_PHYSICS && CC_ENABLE_BULLET_INTEGRATION
    if (_physics3DWorld && _physics3DWorld->isDebugDrawEnabled())
    {
        director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
        director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, _physics3dDebugCamera != nullptr ? _physics3dDebugCamera->getViewProjectionMatrix() : defaultCamera->getViewProjectionMatrix());
        _physics3DWorld->debugDraw(renderer);
        renderer->render();
        director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
    }
#endif

    Camera::_visitingCamera = nullptr;
    experimental::FrameBuffer::applyDefaultFBO();
}

首先取到场景的摄像机 Camera，然后调用 Camera.apply 方法填充 FBO 对象和设置视口

void Camera::apply()
{
    applyFrameBufferObject();
    applyViewport();
}

void Camera::applyViewport()
{
    if(nullptr == _fbo)
    {
        glViewport(getDefaultViewport()._left, getDefaultViewport()._bottom, getDefaultViewport()._width, getDefaultViewport()._height);
    }
    else
    {
        glViewport(_viewport._left * _fbo->getWidth(), _viewport._bottom * _fbo->getHeight(),
                   _viewport._width * _fbo->getWidth(), _viewport._height * _fbo->getHeight());
    }

}

然后调用 Camera.clearBackground 方法绘制背景

void Camera::clearBackground()
{
    if (_clearBrush)
    {
        _clearBrush->drawBackground(this);
    }
}

void CameraBackgroundDepthBrush::drawBackground(Camera* camera)
{
    //...

    _glProgramState->setUniformFloat("depth", _depth);
    _glProgramState->apply(Mat4::IDENTITY);
    GLshort indices[6] = {0, 1, 2, 3, 2, 1};

    {
        GL::bindVAO(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);

        // vertices
        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), &_quad.tl.vertices);

        // colors
        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V3F_C4B_T2F), &_quad.tl.colors);

        // tex coords
        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), &_quad.tl.texCoords);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
    }
    //..
}

在这个方法里我们终于看到了一些 OpenGL 的指令，比如 bindVAO 绑定顶点数组对象，glBindBuffer 绑定索引缓冲对象，glVertexAttribPointer 链接顶点属性，glDrawElements 使用索引绘制。接下来是调用 visit 方法，这个方法在基类 Node 中定义

void Node::visit(Renderer* renderer, const Mat4 &parentTransform, uint32_t parentFlags)
{
    // quick return if not visible. children won't be drawn.
    if (!_visible)
    {
        return;
    }

    uint32_t flags = processParentFlags(parentTransform, parentFlags);

    // IMPORTANT:
    // To ease the migration to v3.0, we still support the Mat4 stack,
    // but it is deprecated and your code should not rely on it
    _director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
    _director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW, _modelViewTransform);

    bool visibleByCamera = isVisitableByVisitingCamera();

    int i = 0;

    if(!_children.empty())
    {
        sortAllChildren();
        // draw children zOrder < 0
        for( ; i < _children.size(); i++ )
        {
            auto node = _children.at(i);

            if (node && node->_localZOrder < 0)
                node->visit(renderer, _modelViewTransform, flags);
            else
                break;
        }
        // self draw
        if (visibleByCamera)
            this->draw(renderer, _modelViewTransform, flags);

        for(auto it=_children.cbegin()+i; it != _children.cend(); ++it)
            (*it)->visit(renderer, _modelViewTransform, flags);
    }
    else if (visibleByCamera)
    {
        this->draw(renderer, _modelViewTransform, flags);
    }

    _director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);

    // FIX ME: Why need to set _orderOfArrival to 0??
    // Please refer to https://github.com/cocos2d/cocos2d-x/pull/6920
    // reset for next frame
    // _orderOfArrival = 0;
}

这个方法很长，它的作用就是递归地调用每一个子结点，然后执行每个结点的 draw 方法，每种需要绘制的结点都实现了 draw 方法，我们以 Sprite 为例

void Sprite::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
    //...
    {
        _trianglesCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, _polyInfo.triangles, transform, flags);
        renderer->addCommand(&_trianglesCommand);
        //...
    }
}

其核心代码就是创建一个渲染指令，然后将指令添加到渲染器 renderer 中去。接下来就是调用渲染器的 render 方法

void Renderer::render()
{
    //Uncomment this once everything is rendered by new renderer
    //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //TODO: setup camera or MVP
    _isRendering = true;

    if (_glViewAssigned)
    {
        //Process render commands
        //1. Sort render commands based on ID
        for (auto &renderqueue : _renderGroups)
        {
            renderqueue.sort();
        }
        visitRenderQueue(_renderGroups[0]);
    }
    clean();
    _isRendering = false;
}

这个方法先对所有渲染组进行排列，然后渲染第一个组，调用 visitRenderQueue 进行渲染

void Renderer::visitRenderQueue(RenderQueue& queue)
{
    queue.saveRenderState();

    const auto& zNegQueue = queue.getSubQueue(RenderQueue::QUEUE_GROUP::GLOBALZ_NEG);
    if (zNegQueue.size() > 0)
    {
        //...
        for (auto it = zNegQueue.cbegin(); it != zNegQueue.cend(); ++it)
        {
            processRenderCommand(*it);
        }
        flush();
    }
    //...
}

这又是一个特别特别长的方法，其核心代码就是遍历渲染指令，然后调用 processRenerCommand 执行该指令

void Renderer::processRenderCommand(RenderCommand* command)
{
    auto commandType = command->getType();
    if( RenderCommand::Type::TRIANGLES_COMMAND == commandType)
    {
        //Draw if we have batched other commands which are not triangle command
        flush3D();
        flushQuads();

        //Process triangle command
        auto cmd = static_cast<TrianglesCommand*>(command);

        //Draw batched Triangles if necessary
        if(cmd->isSkipBatching() || _filledVertex + cmd->getVertexCount() > VBO_SIZE || _filledIndex + cmd->getIndexCount() > INDEX_VBO_SIZE)
        {
            CCASSERT(cmd->getVertexCount()>= 0 && cmd->getVertexCount() < VBO_SIZE, "VBO for vertex is not big enough, please break the data down or use customized render command");
            CCASSERT(cmd->getIndexCount()>= 0 && cmd->getIndexCount() < INDEX_VBO_SIZE, "VBO for index is not big enough, please break the data down or use customized render command");
            //Draw batched Triangles if VBO is full
            drawBatchedTriangles();
        }

        //Batch Triangles
        _batchedCommands.push_back(cmd);

        fillVerticesAndIndices(cmd);

        if(cmd->isSkipBatching())
        {
            drawBatchedTriangles();
        }

    }
    //else if(...)
}

在 processRenderCommand 方法中就可以看到很多绘制方法了，我们随便打开一个诸如 drawBatchedTriangles 的方法，可以看到全是 OpenGL 指令

总结

• 在 Application 的 run 方法中调用 AppDelegate 的 applicationDidFinishLaunching 方法，在这个方法中创建并初始化 GLView，这个过程就是创建和初始化 OpenGL 的过程，经过这过程之后，一个 OpenGL 窗口就被创建出来了
• 在 Application 的 run 方法中调用 GLView 的 windowShouldClose 方法检测窗口是否关闭，如果未关闭则都调用渲染指令
• Driector 的 drawScene 负责绘制渲染，首先拿到当前场景的摄像机并设置视口，然后递归遍历所有结点并调用结点的 draw 方法
• 结点的 draw 方法创建一个渲染 command 并把这个 command 添加到渲染器 renderer 中去
• 在 Driector 的 drawScene 方法中调用渲染器的 render 方法进行渲染，render 方法取到渲染指令后调用 processRenderCommand 执行 OpenGL 指令