基于Cocos2d-x学习OpenGLES2.0系列——OpenGLES渲染之LayerColor（8）

auto layerColor = LayerColor::create(Color4B(255, 0, 0, 255), 100, 100);  
layerColor->setPosition(100,100);  

LayerColor* LayerColor::create(const Color4B& color, GLfloat width, GLfloat height)  
{  
    LayerColor * layer = new LayerColor();  
    if( layer &&layer->initWithColor(color,width,height)) {  
        layer->autorelease();  
        return layer;  
    }  
    CC_SAFE_DELETE(layer);  
    return nullptr;  
}

boolLayerColor::initWithColor(const Color4B& color, GLfloat w, GLfloat h){  
    if (Layer::init()){  
        _blendFunc =BlendFunc::ALPHA_NON_PREMULTIPLIED;  //设置混合模式        
　　　　 _displayedColor.r = _realColor.r =color.r;          _displayedColor.g = _realColor.g =color.g;  
        _displayedColor.b = _realColor.b =color.b;  
        _displayedOpacity = _realOpacity =color.a;  
        for (size_t i = 0;i<sizeof(_squareVertices) / sizeof( _squareVertices[0]); i++ )  
        {  
            _squareVertices[i].x = 0.0f;  
            _squareVertices[i].y = 0.0f;  
        }  
    
        updateColor();  
        setContentSize(Size(w, h));  
    
        setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_POSITION_COLOR_NO_MVP));  
        return true;  
    }  
    return false;  
}

Application::run()  
{  
    ……  
    DisplayLinkDirector::mainLoop()  
    ……  
}  
DisplayLinkDirector::mainLoop()  
{  
    ……  
    Director::drawScene()  
    ……  
    ……  
}  
Director::drawScene()  
{  
    ……  
    Node::visit(…)  
    ……  
    Renderer::render()  
    ……  
}  
Node::visit(…)  
{  
    ……  
    LayerColor::draw(…)  
    ……  
}

voidLayerColor::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)  
{  
    _customCommand.init(_globalZOrder);  
    _customCommand.func =CC_CALLBACK_0(LayerColor::onDraw, this, transform, flags);  
    renderer->addCommand(&_customCommand);  
      
    for(int i = 0; i <4; ++i)  
    {  
        Vec4 pos;  
        pos.x = _squareVertices[i].x; 
        pos.y =_squareVertices[i].y; 
        pos.z = _positionZ;          pos.w = 1;  
        _modelViewTransform.transformVector(&pos);  
        _noMVPVertices[i] = Vec3(pos.x,pos.y,pos.z)/pos.w;  
    }  
}

voidRenderer::addCommand(RenderCommand* command)  
{  
    int renderQueue =_commandGroupStack.top();  
    addCommand(command, renderQueue);  
}  
voidRenderer::addCommand(RenderCommand* command, int renderQueue)  
{  
    _renderGroups[renderQueue].push_back(command);  
}

voidRenderer::render()  
{  
    _isRendering = true;  
      
    if (_glViewAssigned)  
    {  
        _drawnBatches = _drawnVertices = 0;  
        for (auto &renderqueue : _renderGroups){  
            renderqueue.sort();  
        }  
        visitRenderQueue(_renderGroups[0]);  
        flush();  
    }  
    clean();  
    _isRendering = false;  
}

voidRenderQueue::sort()  
{  
      std::sort(std::begin(_queueNegZ),std::end(_queueNegZ), compareRenderCommand);  
    std::sort(std::begin(_queuePosZ), std::end(_queuePosZ),compareRenderCommand);  
}  
staticbool compareRenderCommand(RenderCommand* a, RenderCommand* b)  
{  
    return a->getGlobalOrder() getGlobalOrder();  
}

voidRenderer::visitRenderQueue(const RenderQueue& queue)  
{  
    ssize_t size = queue.size();  
      
    for (ssize_t index = 0; index index){  
        auto command = queue[index];  
        auto commandType = command->getType();  
        if(RenderCommand::Type::QUAD_COMMAND ==commandType) {  
           ……  
        }else if(RenderCommand::Type::GROUP_COMMAND== commandType) {  
            ……  
        }else if(RenderCommand::Type::CUSTOM_COMMAND== commandType) {  
            ……      
        }else if(RenderCommand::Type::BATCH_COMMAND ==commandType) {  
            ……  
        }else if (RenderCommand::Type::MESH_COMMAND== commandType) {  
            ……  
      }  
    }  
}

elseif(RenderCommand::Type::CUSTOM_COMMAND == commandType)  
{  
    flush();  
    auto cmd = static_cast(command);  
    cmd->execute();  
}

voidCustomCommand::execute()  
{  
    if(func) {  
        func();  
    }  
}

voidLayerColor::onDraw(const Mat4& transform, uint32_t flags)  
{  
    getGLProgram()->use();  
    getGLProgram()->setUniformsForBuiltins(transform);  
    
　　 GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION| GL::VERTEX_ATTRIB_FLAG_COLOR );  
    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION,3, GL_FLOAT, GL_FALSE, 0, _noMVPVertices);      glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR,4, GL_FLOAT, GL_FALSE, 0, _squareColors);  
    
    GL::blendFunc( _blendFunc.src, _blendFunc.dst);  
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);  
    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,4);  
}