cocos2d-x 3.6版本学习笔记－渲染过程

最新推荐文章于 2022-03-20 08:53:15 发布
最新推荐文章于 2022-03-20 08:53:15 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： cocos2dx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itol925/article/details/46010681
版权

姑且从Application::run()开始吧。代码1：

int Application::run()
{
    PVRFrameEnableControlWindow(false);//设置注册表PVRFrame隐藏 

    // Main message loop:
    LARGE_INTEGER nLast;
    LARGE_INTEGER nNow;

    QueryPerformanceCounter(&nLast); //获取当前的计数值,即频率x当前时间 

	initGLContextAttrs();//设置 context 属性,目前只能设置6个属性 red,green,blue,alpha,depth(深度),stencil(模板),详见GLViewImpl::initWithRect

    // Initialize instance and cocos2d.
    if (!applicationDidFinishLaunching())
    {
        return 1;
    }

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

    // Retain glview to avoid glview being released in the while loop
    glview->retain();

    while(!glview->windowShouldClose())
    {
        QueryPerformanceCounter(&nNow);// 取得当前的计数值,即频率x当前时间 
        if (nNow.QuadPart - nLast.QuadPart > _animationInterval.QuadPart)	// 每隔_animationInterval.QuadPart时间绘制一次
        {
            nLast.QuadPart = nNow.QuadPart - (nNow.QuadPart % _animationInterval.QuadPart);
            
            director->mainLoop();
            glview->pollEvents();
        }
        else
        {
            Sleep(1);
        }
    }

    // Director should still do a cleanup if the window was closed manually.
    if (glview->isOpenGLReady())	// 判断glView窗口是否创建成功
    {
        director->end();		// 将结束标志设为真，再做一次循环
        director->mainLoop();	// 此交循环中将会对资源进行清理，释放
        director = nullptr;
    }
    glview->release();
    return 0;
}

渲染之前，先整理一下Director对象，因为Director做了opengl渲染的一些准备工作。创建代码如下，代码2： 

Director* Director::getInstance()
{
    if (!s_SharedDirector)
    {
        s_SharedDirector = new (std::nothrow) DisplayLinkDirector(); // new(std::nothrow)表示当创建失败时不抛出异常,直接返回NULL
        CCASSERT(s_SharedDirector, "FATAL: Not enough memory");
        s_SharedDirector->init();
    }

    return s_SharedDirector;
}

init函数，代码3：

bool Director::init(void)
{
    setDefaultValues();

    ...

    //init TextureCache
    initTextureCache();	// 构造_textureCache对象
    initMatrixStack();	// 初始化_modelViewMatrixStack，_projectionMatrixStack，_textureMatrixStack三个矩阵

    _renderer = new (std::nothrow) Renderer;	// 构造render对象

    return true;
}

setDefaultValues函数，代码4：

void Director::setDefaultValues(void)
{
    Configuration *conf = Configuration::getInstance();


    // default FPS
    double fps = conf->getValue("cocos2d.x.fps", Value(kDefaultFPS)).asDouble();
    _oldAnimationInterval = _animationInterval = 1.0 / fps;


    // 是滞显示 FPS
    _displayStats = conf->getValue("cocos2d.x.display_fps", Value(false)).asBool();


    // GL projection,2d 和 3D，在设置视景体时有区别，默认是3D
    std::string projection = conf->getValue("cocos2d.x.gl.projection", Value("3d")).asString();
    if (projection == "3d")
        _projection = Projection::_3D;
    else if (projection == "2d")
        _projection = Projection::_2D;
    else if (projection == "custom")
        _projection = Projection::CUSTOM;
    else
        CCASSERT(false, "Invalid projection value");


<span style="white-space:pre">	</span>/*RGBA8888，RGBA4444，RGB5A1：为3种像素格式，详见百度。*/
    // Default pixel format for PNG images with alpha
    std::string pixel_format = conf->getValue("cocos2d.x.texture.pixel_format_for_png", Value("rgba8888")).asString();
    if (pixel_format == "rgba8888")
        Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA8888);
    else if(pixel_format == "rgba4444")
        Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA4444);
    else if(pixel_format == "rgba5551")
        Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGB5A1);


    // PVR v2 has alpha premultiplied ?
    bool pvr_alpha_premultipled = conf->getValue("cocos2d.x.texture.pvrv2_has_alpha_premultiplied", Value(false)).asBool();
    Image::setPVRImagesHavePremultipliedAlpha(pvr_alpha_premultipled);
}
setDefaultValues设置了FPS，是否显示FPS，投影类型，像素格式等参数。所有的参数都是通过Configuration对象获取的，除此之外，Configuration配置的参数还包括：所支持的MaxTextureSize, MaxModelviewStackDepth,  MaxTextureUnits;NPOT(2的幂);  PVRTC,ETC,S3TC压缩标准,  BGRA8888纹理格式;  glDiscardFramebufferEXT;  VAO; MaxSupportDirLight, GLExtension.。Configuration的实现这里不展开了。

下面来整理一下具体的渲染过程，进入director->mainLoop()，代码如下，代码5：

void DisplayLinkDirector::mainLoop()
{
    if (_purgeDirectorInNextLoop) //只有一种情况会调用到这里来，就是导演类调用end函数
    {
        _purgeDirectorInNextLoop = false;
        purgeDirector();	// 停止场景的所有动作，移除所有监听事件，释放相关的资源
    }
    else if (_restartDirectorInNextLoop)
    {
        _restartDirectorInNextLoop = false;
        restartDirector();	 // 先销毁，再重新创建所有对象
    }
    else if (! _invalid)	// 能否进行下一次渲染，如果开始动画（startAnimation），则渲染
    {
        drawScene();
     
        // release the objects
        PoolManager::getInstance()->getCurrentPool()->clear();
    }
}

mainLoop函数通过purge,restart几个标志位控制着渲染的暂停，结束，具体的渲染工作在drawScene中完成。

drawScene函数代码如下，代码6：

void Director::drawScene()
{
    // calculate "global" dt
    calculateDeltaTime();//计算间隔时间
    
    if (_openGLView)
    {
        _openGLView->pollEvents();<span style="white-space:pre">	</span>// 调用到glfwPollEvents()分发事件
    }


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


    _renderer->clear();//清除buffer和depth_buffer


    /* 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)<span style="white-space:pre">	</span>// 如果场景有更换的话，更换场景
    {
        setNextScene();// 清理当前场景_runningScene，将_nextScene设置为_runningScene
    }


    pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);//将模型矩阵、投影矩阵、纹理矩阵重置，注：此三个矩阵栈里均有两个Identity矩阵，一个用于计算，一个作为母本
    
    if (_runningScene)
    {
#if CC_USE_PHYSICS
        auto physicsWorld = _runningScene->getPhysicsWorld();
        if (physicsWorld && physicsWorld->isAutoStep())
        {
            physicsWorld->update(_deltaTime, false);
        }
#endif
        //clear draw stats
        _renderer->clearDrawStats();<span style="white-space:pre">	</span>//_drawnBatches = _drawnVertices = 0;
        
        //render the scene
        _runningScene->render(_renderer);//绘制运行的场景，包括组装command和执行command，注：每执行完一次，render都会清理一遍command
        
        _eventDispatcher->dispatchEvent(_eventAfterVisit);
    }


    // draw the notifications node
    if (_notificationNode)// 注：此节点不会随场景更换而移除
    {
        _notificationNode->visit(_renderer, Mat4::IDENTITY, 0);//如果有悬浮节点，则组装command到_renderer命令队列中
    }


    if (_displayStats)// 是否显示状态信息，即FPS等信息
    {
        showStats();
    }
    _renderer->render();//执行命令队列


    _eventDispatcher->dispatchEvent(_eventAfterDraw);


    popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);


    _totalFrames++;


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


    if (_displayStats)
    {
        calculateMPF();
    }
}
drawscene中，要渲染的内容分两部分，一部分是_runningScene，另一部分是_notificationNode（如果显示的话），_notificationNode只是一些测试数据，这里不展开。主要看_runningScene->render(_renderer)，代码如下，代码7： 

void Scene::render(Renderer* renderer)
{
    auto director = Director::getInstance();
    Camera* defaultCamera = nullptr;
    const auto& transform = getNodeToParentTransform(); // 获取从子节点坐标转换到父节点坐标的矩阵
    if (_cameraOrderDirty)
    {
        stable_sort(_cameras.begin(), _cameras.end(), camera_cmp);
        _cameraOrderDirty = false;
    }
    
    for (const auto& camera : _cameras) // 注:当_cameras在onEnter的时候会被绑定相应的scene,并加入到scene的_cameras列表中
    {
        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());
        
        //visit the scene 
        visit(renderer, transform, 0);	// 遍历场景和场景子节点并组装对应的渲染命令，并添加到render的命令列表
        renderer->render();				// 遍历渲染列表，并依次执行命令，实现渲染
        
        director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
    }

    Camera::_visitingCamera = nullptr;
}
在render函数里，就可以看出一点opengl的影子了，最起码 设置矩阵->渲染代码->重置矩阵 这个过程大家应该很熟悉。下面再接着往里扒，进入visit函数，代码8： 

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， node的draw什么也没做，但它是一个虚函数，实现在他的子类里面，完成的绘制命令的组装，添加添加到renderer的命令列表中（一个node对应0到多个命令对象，具体的命令定义在node的子类中）
        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;
}
visit函数递归调用了自己，重点在draw函数中，node的draw函数什么也没做，但它是一个虚函数，其子类是有实现的，以sprite为例，代码9： 

void Sprite::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
#if CC_USE_CULLING
    // Don't do calculate the culling if the transform was not updated
    _insideBounds = (flags & FLAGS_TRANSFORM_DIRTY) ? renderer->checkVisibility(transform, _contentSize) : _insideBounds;

    if(_insideBounds)
#endif
    {
        _quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &_quad, 1, transform, flags);// 构造渲染命令对象
        renderer->addCommand(&_quadCommand);
        
#if CC_SPRITE_DEBUG_DRAW
        _debugDrawNode->clear();
        Vec2 vertices[4] = {
            Vec2( _quad.bl.vertices.x, _quad.bl.vertices.y ),
            Vec2( _quad.br.vertices.x, _quad.br.vertices.y ),
            Vec2( _quad.tr.vertices.x, _quad.tr.vertices.y ),
            Vec2( _quad.tl.vertices.x, _quad.tl.vertices.y ),
        };
        _debugDrawNode->drawPoly(vertices, 4, true, Color4F(1.0, 1.0, 1.0, 1.0));
#endif //CC_SPRITE_DEBUG_DRAW
    }
}

sprite的draw函数主要就是init了一个_quadCommand命令对象，并添加到了renderer的命令列表中，可见，node->draw就际上就是一个构造rendercommand命令的过程，还没有任何实质的渲染行为。具体的命令对象的结构是什么这里不扒了，可以去看opengl vao,vbo，3.6版本里有6种渲染命令：TRIANGLES_COMMAND，QUAD_COMMAND，MESH_COMMAND，GROUP_COMMAND，CUSTOM_COMMAND，BATCH_COMMAND，PRIMITIVE_COMMAND，这些命令稍后再提。

下面回到代码7，visit函数遍历各node组装好渲染命令，并添加到renderer的命令列表中后，开始调用renderer->render();执行命令，代码如下，代码10：

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;
}
void Renderer::visitRenderQueue(RenderQueue& queue)
{
    queue.saveRenderState();<span style="white-space:pre">	</span>// 获取GL_DEPTH_TEST，GL_CULL_FACE和GL_DEPTH_WRITEMASK开关标志，为了绘制完后决定是否需要关闭这些开关，见restoreRenderState
    
    //
    //Process Global-Z < 0 Objects，需要做混合
    //
    const auto& zNegQueue = queue.getSubQueue(RenderQueue::QUEUE_GROUP::GLOBALZ_NEG);
    if (zNegQueue.size() > 0)
    {
        if(_isDepthTestFor2D)
        {
            glEnable(GL_DEPTH_TEST);
            glDepthMask(true);
        }
        else
        {
            glDisable(GL_DEPTH_TEST);
            glDepthMask(false);
        }
        for (auto it = zNegQueue.cbegin(); it != zNegQueue.cend(); ++it)
        {
            processRenderCommand(*it);
        }
        flush();
    }
    
    //
    //Process Opaque Object
    //
    const auto& opaqueQueue = queue.getSubQueue(RenderQueue::QUEUE_GROUP::OPAQUE_3D);
    if (opaqueQueue.size() > 0)
    {
        //Clear depth to achieve layered rendering
        glDepthMask(true);
        glEnable(GL_DEPTH_TEST);
        
        for (auto it = opaqueQueue.cbegin(); it != opaqueQueue.cend(); ++it)
        {
            processRenderCommand(*it);
        }
        flush();
    }
    
    //
    //Process 3D Transparent object
    //
    const auto& transQueue = queue.getSubQueue(RenderQueue::QUEUE_GROUP::TRANSPARENT_3D);
    if (transQueue.size() > 0)
    {
        glEnable(GL_DEPTH_TEST);
        glDepthMask(false);
        
        for (auto it = transQueue.cbegin(); it != transQueue.cend(); ++it)
        {
            processRenderCommand(*it);
        }
        flush();
    }
    
    //
    //Process Global-Z = 0 Queue
    //
    const auto& zZeroQueue = queue.getSubQueue(RenderQueue::QUEUE_GROUP::GLOBALZ_ZERO);
    if (zZeroQueue.size() > 0)
    {
        if(_isDepthTestFor2D)
        {
            glEnable(GL_DEPTH_TEST);
            glDepthMask(true);
        }
        else
        {
            glDisable(GL_DEPTH_TEST);
            glDepthMask(false);
        }
        for (auto it = zZeroQueue.cbegin(); it != zZeroQueue.cend(); ++it)
        {
            processRenderCommand(*it);
        }
        flush();
    }
    
    //
    //Process Global-Z > 0 Queue
    //
    const auto& zPosQueue = queue.getSubQueue(RenderQueue::QUEUE_GROUP::GLOBALZ_POS);
    if (zPosQueue.size() > 0)
    {
        for (auto it = zPosQueue.cbegin(); it != zPosQueue.cend(); ++it)
        {
            processRenderCommand(*it);
        }
        flush();
    }
    
    queue.restoreRenderState();
}

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 ( RenderCommand::Type::QUAD_COMMAND == commandType )
    {
        //Draw if we have batched other commands which are not quad command
        flush3D();
        flushTriangles();
        
        //Process quad command
        auto cmd = static_cast<QuadCommand*>(command);
        
        //Draw batched quads if necessary
        if(cmd->isSkipBatching()|| (_numberQuads + cmd->getQuadCount()) * 4 > VBO_SIZE )
        {
            CCASSERT(cmd->getQuadCount()>= 0 && cmd->getQuadCount() * 4 < VBO_SIZE, "VBO for vertex is not big enough, please break the data down or use customized render command");
            //Draw batched quads if VBO is full
            drawBatchedQuads();
        }
        
        //Batch Quads
        _batchQuadCommands.push_back(cmd);
        
        fillQuads(cmd);
        
        if(cmd->isSkipBatching())
        {
            drawBatchedQuads();
        }
    }
    else if (RenderCommand::Type::MESH_COMMAND == commandType)
    {
        flush2D();
        auto cmd = static_cast<MeshCommand*>(command);
        
        if (cmd->isSkipBatching() || _lastBatchedMeshCommand == nullptr || _lastBatchedMeshCommand->getMaterialID() != cmd->getMaterialID())
        {
            flush3D();
            
            if(cmd->isSkipBatching())
            {
                cmd->execute();
            }
            else
            {
                cmd->preBatchDraw();
                cmd->batchDraw();
                _lastBatchedMeshCommand = cmd;
            }
        }
        else
        {
            cmd->batchDraw();
        }
    }
    else if(RenderCommand::Type::GROUP_COMMAND == commandType)
    {
        flush();
        int renderQueueID = ((GroupCommand*) command)->getRenderQueueID();
        visitRenderQueue(_renderGroups[renderQueueID]);
    }
    else if(RenderCommand::Type::CUSTOM_COMMAND == commandType)
    {
        flush();
        auto cmd = static_cast<CustomCommand*>(command);
        cmd->execute();
    }
    else if(RenderCommand::Type::BATCH_COMMAND == commandType)
    {
        flush();
        auto cmd = static_cast<BatchCommand*>(command);
        cmd->execute();
    }
    else if(RenderCommand::Type::PRIMITIVE_COMMAND == commandType)
    {
        flush();
        auto cmd = static_cast<PrimitiveCommand*>(command);
        cmd->execute();
    }
    else
    {
        CCLOGERROR("Unknown commands in renderQueue");
    }
}
再这里，一次渲染过程结束。

最后，我们现再来看看6个renderercommand类型（细节还没有深入研究，等研究了再整理吧。。）

TRIANGLES_COMMAND（详见TrianglesCommand类）：

用于渲染三角形，renderer类中专门有drawBatchedTriangles来批量处理该命令。


QUAD_COMMAND（详见QuadCommand类）：

用于渲染4边形，与TRIANGLES_COMMAND类似，renderer类中专门也有drawBatchedQuads来批量处理该命令。


MESH_COMMAND（详见MeshCommand类）。

GROUP_COMMAND（详见GroupCommand类）。

CUSTOM_COMMAND（详见CustomCommand类），可以绑定一个回调函数如：

_customCommand.init(_globalZOrder);
_customCommand.func = CC_CALLBACK_0(DrawTest::onDraw, this, transform,flags);


BATCH_COMMAND（详见BatchCommand类）。

PRIMITIVE_COMMAND（详见BatchCommand类）。

木乃伊x
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cocos2d-x-3.13.1 spine3.6.zip
04-21
总之，Cocos2d-x 3.13.1版本更新了对Spine 3.6的支持，为开发者带来了更强大、更灵活的2D角色动画解决方案。通过熟练掌握Cocos2d-x与Spine的集成，开发者可以创作出更具视觉冲击力和沉浸感的游戏作品。在实际开发...
[Cocos2dx] CCCamera照相机 详解
weixin_30454481的博客
02-09 475
前言 在3D游戏当中，我们经常会使用到照相机这个东西，无论你使用的是哪一款引擎，都会用到，同时，照相机这个东西涉及到的东西比较多，基础知识需要扎实一些才可以。 如何使用 很久之前做项目的时候用到过一次，已经忘记的差不多了。为此，我找了cpp test中的示例代码，找了一个相对简单的代码，我把关键代码贴出来。 auto layer3D=Layer::create(); addChild(layer3...
Cocos2d-x引擎学习笔记（二）—— 渲染与绘制源码分析
dick的博客
08-14 838
Cocos2d-x引擎渲染与绘制源码分析 cocos2d-x版本：3.17.2 运行环境：Visual Studio 2017 解决方案配置：Debug Win32 渲染流程图 1. Renderer中的渲染队列RenderQueue类 Renderer对象在Director(导演类)中，Director一般是单例，因此可以认为Renderer也是全局唯一。Renderer里面存放着渲染命令...
OpenGL——矩阵堆栈的入栈出栈详解及金字塔案例
正在注销账号的博客
07-09 1253
什么是矩阵堆栈 矩阵堆栈指的就是内存中专门用来存放矩阵数据的某块特殊区域。 一般说来，矩阵堆栈常用于构造具有继承性的模型，即由一些简单目标构成的复杂模型。矩阵堆栈对复杂模型运动过程中的多个变换操作之间的联系与独立十分有利。 堆栈的特点是先进后出，堆栈的默认深度是64 矩形堆栈都有默认值，且默认值是单元矩阵。 初始化一个矩阵堆栈 矩阵堆栈中默认会有一个单元矩阵，但是你也可以初始化一个单元矩阵。 //初始化一个单元矩阵 modelViewMatrix.LoadIdentity(); 压栈 PushMatr
Qt基础——获取QGraphicsScene的缩略图即导出到图片
好习惯成就伟大
07-12 2474
是应用了他的render函数，render的作用是： Renders the source rect from scene into target, using painter. This function is useful for capturing the contents of the scene onto a paint device, such as a QImage (e.g., t...
cocos2dx渲染机制
ellis1970的博客
11-05 3985
cocos2dx渲染原理是cocos引擎工作原理的核心部分，也是面试cocos职位经常考的内容，通过理解渲染机制可以掌握一部分cocos源码 接下来通过源码介绍渲染流程,代码摘自3.10引擎版本 1.main.cpp中调用Application::getInstance()->run()中进入游戏主循环 2.Application::run()中调用director->main...
cocos2d-x-3.6.zip
11-07
总的来说，Cocos2d-x 3.6是一个经典而强大的游戏开发工具，尽管它可能缺少某些新版本的功能，但对于那些希望复用旧代码、学习历史版本或对特定功能有依赖的开发者来说，仍然具有很高的价值。通过深入研究和实践，...
Cocos2d-x 3.6 API离线文档
07-20
Cocos2d-x 是一个广泛使用的开源游戏开发框架，它基于C++，并...以上是对"Cocos2d-x 3.6 API离线文档"的详细介绍，这个文档对于任何想要使用Cocos2d-x 3.6版本进行游戏开发的人来说，都是不可或缺的学习和参考材料。
cocos2d-x-3.1.zip
11-02
总的来说，Cocos2d-x 3.1是游戏开发者学习2D游戏开发的一个重要参考点，虽然它已经不是最新的版本，但其核心概念和机制在后续版本中仍然保持一致，是理解整个Cocos2d-x框架的基础。解压并研究“cocos2d-x-3.1”中的...
cocos2d-x 3.6创建项目代码
08-12
在本文中，我们将深入探讨如何使用cocos2d-x 3.6版本创建一个新的项目，并解决可能遇到的编译问题。 首先，我们要确保已经正确地安装了cocos2d-x 3.6的开发环境。这包括安装C++编译器（如Visual Studio）、Python...
cocos2d中的可见性检测
bamei5868的博客
06-15 144
游戏的在进行一次渲染的时候，通常会提交大量的渲染对象给gpu。在这些需要渲染的对象中，并不是所有对象都会出现镜头中，即有一部分对象是不可见的。 通常有两种方式来完成不可见对象的剔除工作： （1）直接交给图形库帮我剔除，即性能消耗在gpu端； （2）在提交图元给gpu前，在游戏逻辑中进行剔除，即性能消耗在cpu端； 是将剔除操作放在cpu还是gpu来处理，没有一个具体的标准，个人认...
cocos的渲染原理代码彻底分析
m0_37609239的博客
03-20 4203
从头到尾梳理一遍cocos的渲染流程，并且简单介绍一些渲染知识。 带着猜想去看代码，最终得到验证。 设想一下还有哪些可以优化的地方。 最终总结一下，我们在日常开发中如何利用合批策略。
cocos2d-x的渲染流程及原理
翻肚鱼儿的博客
09-02 939
cocos2d-x的渲染流程及原理 环境： cocos3.10 Xcode UI元素的渲染流程图示： 1.从main进入到Application:run中，该方法下有个while循环，用于处理设定的每帧(FPS)刷新相关 {// ... glview->retain(); while (!glview->windowShouldClose()) { director->mainLoop(); ...
6.【cocos2d-x 源码分析】:渲染部分的详细分析(上)
会飞的徐公明
05-18 342
对应源码位置：cocos2d-x-3.3\cocos\render\* 主循环中的渲染部分 下面代码选自 void Director::drawScene() if (_runningScene) { //clear draw stats _renderer->clearDrawStats(); //render th...
cocos 中每个节点的visit与draw函数
u012861978的专栏
05-24 1188
visit函数内会先调用自己的draw函数，然后变量所有子节点递归调用字节的visit： cocos渲染流程是从Director类的主循环mainLoop中开始： 1.调用drawScene()： //精简后的代码，方便理解 void Director::drawScene() { /*此处省略一些代码 ..... */ _renderer->clear(); pushMatrix(MATRIX_STACK_TYPE::MATRIX_ST..
cocos---图形渲染的过程
WADE
08-09 1216
一、渲染概括 这里先简单说一下大概流程，Cocos3.x版本的渲染是将所有需要渲染的node先通过各种RenderCommand封装起来，你先不用管RenderCommand是什么，只需要记住它把我们要渲染的node封装起来了就行，然后引擎把这些RenderCommand添加到了一个队列中存了起来，这个队列叫CommandQueue，添加的时候顺便对这些RenderCommand设置了一些参数，...
COCOS学习笔记--Cocos引擎渲染流程
热门推荐
RapdoZoroの博客
12-27 1万+
最近在研究Cocos引擎的渲染流程，在这里将其整个渲染流程进行一下梳理： 梳理之前我们要知道一些东西，就是我们的Cocos引擎是通过使用OpenGL的一些API来进行渲染绘制的，所以如果我们要彻底理解Cocos引擎的渲染流程并想修改引擎底层渲染的相关内容，熟悉OpenGL是很有必要的。 这里先简单说一下大概流程，Cocos3.x版本的渲染是将所有需要渲染的node先通过各种RenderComm
【Cocos2d-x 3.x】 3.0版本的全新绘制系统
Mccree的博客专栏
08-29 2536
3.0之后的全新绘制系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值