Cocos2d-x Auto-batching 浅浅的”深入分析”

渲染流程

1. drawScene开始绘制场景

void DisplayLinkDirector::mainLoop()
{
    if (_purgeDirectorInNextLoop)
    {
        _purgeDirectorInNextLoop = false;
        purgeDirector();
    }
    else if (! _invalid)
    {
        drawScene();
     
        // release the objects
        PoolManager::getInstance()->getCurrentPool()->clear();
    }
}

2.遍历场景的子节点

if (_runningScene)
    {
        _runningScene->visit(_renderer, identity, false);
        _eventDispatcher->dispatchEvent(_eventAfterVisit);
    }

3.对每一个子节点调用draw函数

void Sprite::draw(Renderer *renderer, const kmMat4 &transform, bool transformUpdated)
{
    // Don't do calculate the culling if the transform was not updated
    _insideBounds = transformUpdated ? isInsideBounds() : _insideBounds;

    if(_insideBounds)
    {
        _quadCommand.init(_globalZOrder, _texture->getName(), _shaderProgram, _blendFunc, &_quad, 1, transform);
        renderer->addCommand(&_quadCommand);
    }
}

4.初始化QuadCommand对象，这就是渲染命令

5.丢完QuadCommand就完事了

6.开始渲染

if(commandType == RenderCommand::Type::QUAD_COMMAND)
                {
                    auto cmd = static_cast<QuadCommand*>(command);
                    _batchedQuadCommands.push_back(cmd);
                                    }
                else if(commandType == RenderCommand::Type::CUSTOM_COMMAND)
                {}
                else if(commandType == RenderCommand::Type::BATCH_COMMAND)
                {}
                else if(commandType == RenderCommand::Type::GROUP_COMMAND)
                {}
                else
                {}

for(const auto& cmd : _batchedQuadCommands)
    {
        if(_lastMaterialID != cmd->getMaterialID())
        {
            //Draw quads
            if(quadsToDraw > 0)
            {
                glDrawElements(GL_TRIANGLES, (GLsizei) quadsToDraw*6, GL_UNSIGNED_SHORT, (GLvoid*) (startQuad*6*sizeof(_indices[0])) );
                _drawnBatches++;
                _drawnVertices += quadsToDraw*6;

                startQuad += quadsToDraw;
                quadsToDraw = 0;
            }

            //Use new material
            cmd->useMaterial();
            _lastMaterialID = cmd->getMaterialID();
        }

        quadsToDraw += cmd->getQuadCount();
    }

7. 为什么必须要相同纹理、相同混合函数、相同shader？

_quadCommand.init(_globalZOrder, _texture->getName(), _shaderProgram, _blendFunc, &_quad, 1, transform);

void QuadCommand::init(float globalOrder, GLuint textureID, GLProgram* shader, BlendFunc blendType, V3F_C4B_T2F_Quad* quad, ssize_t quadCount, const kmMat4 &mv)
{
    _globalOrder = globalOrder;
    _textureID = textureID;
    _blendType = blendType;
    _shader = shader;

    _quadsCount = quadCount;
    _quads = quad;

    _mv = mv;
   
    _dirty = true;

    generateMaterialID();
}

void QuadCommand::generateMaterialID()
{
    if (_dirty)
    {
        //Generate Material ID
       
        //TODO fix blend id generation
        int blendID = 0;
        if(_blendType == BlendFunc::DISABLE)
        {
            blendID = 0;
        }
        else if(_blendType == BlendFunc::ALPHA_PREMULTIPLIED)
        {
            blendID = 1;
        }
        else if(_blendType == BlendFunc::ALPHA_NON_PREMULTIPLIED)
        {
            blendID = 2;
        }
        else if(_blendType == BlendFunc::ADDITIVE)
        {
            blendID = 3;
        }
        else
        {
            blendID = 4;
        }
       
        // convert program id, texture id and blend id into byte array
        char byteArray[12];
        convertIntToByteArray(_shader->getProgram(), byteArray);
        convertIntToByteArray(blendID, byteArray + 4);
        convertIntToByteArray(_textureID, byteArray + 8);
       
        _materialID = XXH32(byteArray, 12, 0);
       
        _dirty = false;
    }
}

_blendType就是我们的BlendFunc混合函数，注意一下，这里所说的相同的混合函数，并不是指要完全相同的值，
其实只是相同类型，看看if else的那几个判断就知道了，最后需要的只是blendID这个值。

8. 怎样才能让相同材质的对象的渲染命令连续排列？

bool nodeComparisonLess(Node* n1, Node* n2)
{
    return( n1->getLocalZOrder() < n2->getLocalZOrder() ||
           ( n1->getLocalZOrder() == n2->getLocalZOrder() && n1->getOrderOfArrival() < n2->getOrderOfArrival() )
);

void Renderer::render()
{

    if (_glViewAssigned)
    {
        //1. Sort render commands based on ID
        for (auto &renderqueue : _renderGroups)
        {
            renderqueue.sort();
        }
    }

void RenderQueue::sort()
{
    // Don't sort _queue0, it already comes sorted
    std::sort(std::begin(_queueNegZ), std::end(_queueNegZ), compareRenderCommand);
    std::sort(std::begin(_queuePosZ), std::end(_queuePosZ), compareRenderCommand);
}

bool compareRenderCommand(RenderCommand* a, RenderCommand* b)
{
    return a->getGlobalOrder() < b->getGlobalOrder();
}

没错，渲染队列会根据节点的globalOrder再一次进行排序，默认的globalOrder当然是0了，也就是排不排序结果都一样。
这涉及到localZOrder和globalOrder的概念，这就帮star特做个广告吧，看看他的帖子：
Cocos2dx 3.0 过渡篇（二十九）globalZOrder()与localZOrder() 

/* 创建很多很多个精灵 */
    for(inti = 0; i < 14100; i++)
    {
        Sprite* xiaoruo = Sprite::create("sprite0.png");
        xiaoruo->setPosition(Point(CCRANDOM_0_1() * 480, 120 + CCRANDOM_0_1() * 300));
        this->addChild(xiaoruo);
 
        xiaoruo = Sprite::create("sprite1.png");
        xiaoruo->setPosition(Point(CCRANDOM_0_1() * 480, 120 + CCRANDOM_0_1() * 300));
        this->addChild(xiaoruo);
    }

/* 创建很多很多个精灵 */
    for(inti = 0; i < 14100; i++)
    {
        Sprite* xiaoruo = Sprite::create("sprite0.png");
        xiaoruo->setPosition(Point(CCRANDOM_0_1() * 480, 120 + CCRANDOM_0_1() * 300));
        this->addChild(xiaoruo, 1);
 
        xiaoruo = Sprite::create("sprite1.png");
        xiaoruo->setPosition(Point(CCRANDOM_0_1() * 480, 120 + CCRANDOM_0_1() * 300));
        this->addChild(xiaoruo, 2);
    }

9. 渲染队列存储上限