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

骑猪看日落 2022-06-06 02:23 288阅读 0赞

# 创建 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 窗口启动][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 的目录结构

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 指令

[cocos2d-x]: http://blog.csdn.net/xingxinmanong/article/details/77256203