自学教程：C++ CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES函数代码示例

void MeshCommand::batchDraw(){    if (_material)    {        for(const auto& pass: _material->_currentTechnique->_passes)        {            pass->bind(_m);            glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0);            CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount);            pass->unbind();        }    }    else    {        _glProgramState->applyGLProgram(_m);        // set render state        applyRenderState();        // Draw        glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount);    }}

void BoneNode::onDraw(const cocos2d::Mat4 &transform, uint32_t flags){    getGLProgram()->use();    getGLProgram()->setUniformsForBuiltins(transform);    cocos2d::GL::enableVertexAttribs(cocos2d::GL::VERTEX_ATTRIB_FLAG_POSITION | cocos2d::GL::VERTEX_ATTRIB_FLAG_COLOR);    glBindBuffer(GL_ARRAY_BUFFER, 0);    glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, _noMVPVertices);    glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, _squareColors);    cocos2d::GL::blendFunc(_blendFunc.src, _blendFunc.dst);    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);#ifdef CC_STUDIO_ENABLED_VIEW    glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, _noMVPVertices);    glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, _squareColors);    glEnable(GL_LINE_SMOOTH);    glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);    glDrawArrays(GL_LINE_LOOP, 0, 4);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8);#else    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 4);#endif //CC_STUDIO_ENABLED_VIEW}

void MeshCommand::execute(){    // Draw without VAO    glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);    if (_material)    {        for(const auto& pass: _material->_currentTechnique->_passes)        {            pass->bind(_mv, true);            glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0);            CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount);            pass->unbind();        }    }    else    {        // set render state        _glProgramState->apply(_mv);        applyRenderState();        // Draw        glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0);                CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount);    }    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);    glBindBuffer(GL_ARRAY_BUFFER, 0);}

void drawSolidCircle( const Vec2& center, float radius, float angle, unsigned int segments, float scaleX, float scaleY){    lazy_init();        const float coef = 2.0f * (float)M_PI/segments;        GLfloat *vertices = (GLfloat*)calloc( sizeof(GLfloat)*2*(segments+2), 1);    if( ! vertices )        return;        for(unsigned int i = 0;i <= segments; i++) {        float rads = i*coef;        GLfloat j = radius * cosf(rads + angle) * scaleX + center.x;        GLfloat k = radius * sinf(rads + angle) * scaleY + center.y;                vertices[i*2] = j;        vertices[i*2+1] = k;    }    vertices[(segments+1)*2] = center.x;    vertices[(segments+1)*2+1] = center.y;        s_shader->use();    s_shader->setUniformsForBuiltins();    s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &s_color.r, 1);        GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);    glDrawArrays(GL_TRIANGLE_FAN, 0, (GLsizei) segments+1);        ::free( vertices );        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,segments+1);}

void NavMeshDebugDraw::drawImplement(const cocos2d::Mat4& transform, uint32_t flags){    _program->use();    _program->setUniformsForBuiltins(transform);    glBindBuffer(GL_ARRAY_BUFFER, _vbo);    GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(V3F_C4F), (GLvoid *)offsetof(V3F_C4F, position));    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(V3F_C4F), (GLvoid *)offsetof(V3F_C4F, color));    if (_dirtyBuffer){        glBufferData(GL_ARRAY_BUFFER, sizeof(V3F_C4F)* _vertices.size(), &_vertices[0], GL_STATIC_DRAW);        _dirtyBuffer = false;    }    for (auto &iter : _primitiveList){        _stateBlock->setDepthWrite(iter->depthMask);        if (iter->type == GL_POINTS){            //glPointSize(iter->size);        }        else if (iter->type == GL_LINES){            glLineWidth(iter->size);        }        _stateBlock->bind();        glDrawArrays(iter->type, iter->start, iter->end - iter->start);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, iter->end - iter->start);    }    glBindBuffer(GL_ARRAY_BUFFER, 0);}

/** * Draw a primitive. * * @param transform Transform matrix * @param flags Flags to draw */void ShaderTextureNode::onDraw(const Mat4 &transform, uint32_t flags){	GLfloat vertices[48] = {		-1, -1, 0, 1, 1, 1, 1, 1,		// Lower-Left		1, -1, 1, 1, 1, 1, 1, 1,		// Lower-Right		1, 1, 1, 0, 1, 1, 1, 1,			// Upper-Right		-1, -1, 0, 1, 1, 1, 1, 1,		// Lower-Left		1, 1, 1, 0, 1, 1, 1, 1,			// Upper-Right		-1, 1, 0, 0, 1, 1, 1, 1,		// Upper-Left	};	auto glProgramState = getGLProgramState();	glProgramState->setVertexAttribPointer("a_position", 2, GL_FLOAT, GL_FALSE, 32, vertices);	glProgramState->setVertexAttribPointer("a_texCoord", 2, GL_FLOAT, GL_FALSE, 32, vertices + 2);	glProgramState->setVertexAttribPointer("a_color", 4, GL_FLOAT, GL_FALSE, 32, vertices + 4);	glProgramState->apply(transform);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);	glDisable(GL_DEPTH_TEST);	glCullFace(GL_BACK);	glEnable(GL_CULL_FACE);	//	Alpha blending//	glEnable(GL_BLEND);//	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);		glDrawArrays(GL_TRIANGLES, 0, 6);//	glDisable(GL_BLEND);	CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 6);}

void MGRDrawNode::onDrawGLPoint(const Mat4 &transform, uint32_t flags){    auto glProgram = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_COLOR_TEXASPOINTSIZE);    glProgram->use();    glProgram->setUniformsForBuiltins(transform);    GL::blendFunc(_blendFunc.src, _blendFunc.dst);    if (_dirtyGLPoint)    {        glBindBuffer(GL_ARRAY_BUFFER, _vboGLPoint);        glBufferData(GL_ARRAY_BUFFER, sizeof(V2F_C4B_T2F)*_bufferCapacityGLPoint, _bufferGLPoint, GL_STREAM_DRAW);        _dirtyGLPoint = false;    }    glBindBuffer(GL_ARRAY_BUFFER, _vboGLPoint);    GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);    // vertex    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offsetof(V2F_C4B_T2F, vertices));    // color    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V2F_C4B_T2F), (GLvoid*)offsetof(V2F_C4B_T2F, colors));    // texcoord    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offsetof(V2F_C4B_T2F, texCoords));    glDrawArrays(GL_POINTS, 0, _bufferCountGLPoint);    glBindBuffer(GL_ARRAY_BUFFER, 0);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _bufferCountGLPoint);    CHECK_GL_ERROR_DEBUG();}

void MotionStreak::onDraw(const kmMat4 &transform, bool transformUpdated){    getShaderProgram()->use();    getShaderProgram()->setUniformsForBuiltins(transform);    GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX );    GL::blendFunc( _blendFunc.src, _blendFunc.dst );    GL::bindTexture2D( _texture->getName() );#ifdef EMSCRIPTEN    // Size calculations from ::initWithFade    setGLBufferData(_vertices, (sizeof(Vertex2F) * _maxPoints * 2), 0);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, 0);    setGLBufferData(_texCoords, (sizeof(Tex2F) * _maxPoints * 2), 1);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, 0, 0);    setGLBufferData(_colorPointer, (sizeof(GLubyte) * _maxPoints * 2 * 4), 2);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);#else    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, _vertices);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, 0, _texCoords);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, _colorPointer);#endif // EMSCRIPTEN    glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)_nuPoints*2);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _nuPoints*2);}

void DrawTextureScene::onDraw(){    Director::getInstance()->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);    Director::getInstance()->loadIdentityMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);    Director::getInstance()->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);    Director::getInstance()->loadIdentityMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);        auto glProgram=getGLProgram();    glProgram->use();    //更新CC_MVPMatrix    glProgram->setUniformsForBuiltins();            GLuint textureLocation = glGetUniformLocation(glProgram->getProgram(), "CC_Texture0");    // Set our sampler to user Texture Unit 0    glUniform1i(textureLocation, 0);//    GLuint uColorLocation = glGetUniformLocation(glProgram->getProgram(), "u_color");//    GLfloat uColor[]={1.0,1.0,1.0,1.0};//    glUniform4fv(uColorLocation, 1, uColor);        glBindVertexArray(vao);        //在调用draw call之前，我们需要绑定纹理        GL::bindTexture2D(textureID);//activeTexture(GL_TEXTURE0); //glBindTexture(GL_TEXTURE_2D, textureID);        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, (GLvoid*)0);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 6);    CHECK_GL_ERROR_DEBUG();            Director::getInstance()->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);    Director::getInstance()->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);    }

void RawStencilBufferTest::onBeforeDrawSprite(int planeIndex, const Vec2& pt){    this->setupStencilForDrawingOnPlane(planeIndex);    CHECK_GL_ERROR_DEBUG();    Vec2 vertices[] = {        Vec2::ZERO,        Vec2(pt.x, 0),        pt,        Vec2(0, pt.y)    };    auto glProgram = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_U_COLOR);    int colorLocation = glProgram->getUniformLocation("u_color");    CHECK_GL_ERROR_DEBUG();    Color4F color = _planeColor[planeIndex];    glProgram->use();    glProgram->setUniformsForBuiltins();    glProgram->setUniformLocationWith4fv(colorLocation, (GLfloat*) &color.r, 1);    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 4);}

void ShaderSprite::onDraw(const kmMat4 &transform, bool transformUpdated){    auto shader = getShaderProgram();    shader->use();    shader->setUniformsForBuiltins(transform);    setCustomUniforms();        GL::enableVertexAttribs(cocos2d::GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX );    GL::blendFunc(_blendFunc.src, _blendFunc.dst);    GL::bindTexture2D( getTexture()->getName());        //    // Attributes    //    #define kQuadSize sizeof(_quad.bl)    size_t offset = (size_t)&_quad;        // vertex    int diff = offsetof( V3F_C4B_T2F, vertices);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff));        // texCoods    diff = offsetof( V3F_C4B_T2F, texCoords);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));        // color    diff = offsetof( V3F_C4B_T2F, colors);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 4);}

void LayerColor::onDraw(const kmMat4& transform, bool transformUpdated){    getShaderProgram()->use();    getShaderProgram()->setUniformsForBuiltins(transform);    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR );    //    // Attributes    //#ifdef EMSCRIPTEN    setGLBufferData(_noMVPVertices, 4 * sizeof(Vertex3F), 0);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, 0);    setGLBufferData(_squareColors, 4 * sizeof(Color4F), 1);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, 0);#else    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, _noMVPVertices);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, _squareColors);#endif // EMSCRIPTEN    GL::blendFunc( _blendFunc.src, _blendFunc.dst );    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,4);}

void drawCubicBezier(const Vec2& origin, const Vec2& control1, const Vec2& control2, const Vec2& destination, unsigned int segments){    lazy_init();    Vec2* vertices = new (std::nothrow) Vec2[segments + 1];    float t = 0;    for (unsigned int i = 0; i < segments; i++)    {        vertices[i].x = powf(1 - t, 3) * origin.x + 3.0f * powf(1 - t, 2) * t * control1.x + 3.0f * (1 - t) * t * t * control2.x + t * t * t * destination.x;        vertices[i].y = powf(1 - t, 3) * origin.y + 3.0f * powf(1 - t, 2) * t * control1.y + 3.0f * (1 - t) * t * t * control2.y + t * t * t * destination.y;        t += 1.0f / segments;    }    vertices[segments].x = destination.x;    vertices[segments].y = destination.y;    s_shader->use();    s_shader->setUniformsForBuiltins();    s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &s_color.r, 1);    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );#ifdef EMSCRIPTEN    setGLBufferData(vertices, (segments + 1) * sizeof(Vec2));    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, 0);#else    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);#endif // EMSCRIPTEN    glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) segments + 1);    CC_SAFE_DELETE_ARRAY(vertices);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,segments+1);}

void GLESDebugDraw::DrawSolidPolygon(const b2Vec2* old_vertices, int vertexCount, const b2Color& color){    mShaderProgram->use();    mShaderProgram->setUniformsForBuiltins();    b2Vec2* vertices = new b2Vec2[vertexCount];    for( int i=0;i<vertexCount;i++) {        vertices[i] = old_vertices[i];        vertices[i] *= mRatio;    }    mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r*0.5f, color.g*0.5f, color.b*0.5f, 0.5f);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);    glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount);    mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);    glDrawArrays(GL_LINE_LOOP, 0, vertexCount);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(2,vertexCount*2);    CHECK_GL_ERROR_DEBUG();    delete[] vertices;}

void GLESDebugDraw::DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color){    mShaderProgram->use();    mShaderProgram->setUniformsForBuiltins();    const float32 k_segments = 16.0f;    int vertexCount=16;    const float32 k_increment = 2.0f * b2_pi / k_segments;    float32 theta = 0.0f;    GLfloat*    glVertices = new GLfloat[vertexCount*2];    for (int i = 0; i < k_segments; ++i)    {        b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta));        glVertices[i*2]=v.x * mRatio;        glVertices[i*2+1]=v.y * mRatio;        theta += k_increment;    }    mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, glVertices);    glDrawArrays(GL_LINE_LOOP, 0, vertexCount);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,vertexCount);    CHECK_GL_ERROR_DEBUG();    delete[] glVertices;}

void LayerShaderStudy00::onCustomDraw(const cocos2d::Mat4 &transform, uint32_t flags){    Size winSize = Director::getInstance()->getWinSize();    // data define    GLfloat vertercies[] = {        0.0f,0.0f,        winSize.width,0.0f,        winSize.width*0.5f,winSize.height};    GLfloat color[] = {        1.0f,0.0f,0.0f,1.0f,        0.0f,1.0f,0.0f,1.0f,        0.0f,0.0f,1.0f,1.0f    };        // gl programe use    GLProgram* pGlPrograme = getGLProgram();    pGlPrograme->use();        // input params uniform-mvp    pGlPrograme->setUniformsForBuiltins();        // input params attribute    GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*2, vertercies);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, color);        // draw    glDrawArrays(GL_TRIANGLES, 0, 3);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 3);    CHECK_GL_ERROR_DEBUG();}

void MeshCommand::execute(){    // set render state    applyRenderState();    // Set material    GL::bindTexture2D(_textureID);    GL::blendFunc(_blendType.src, _blendType.dst);    glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);    _glProgramState->setUniformVec4("u_color", _displayColor);        if (_matrixPaletteSize && _matrixPalette)    {        _glProgramState->setUniformCallback("u_matrixPalette", CC_CALLBACK_2(MeshCommand::MatrixPalleteCallBack, this));            }        _glProgramState->apply(_mv);       if (Director::getInstance()->getRunningScene()->getLights().size() > 0)        setLightUniforms();        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);        // Draw    glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount);        //restore render state    restoreRenderState();    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);    glBindBuffer(GL_ARRAY_BUFFER, 0);}

void drawPoint(const Vec2& point){    lazy_init();    Vec2 p;    p.x = point.x;    p.y = point.y;    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );    s_shader->use();    s_shader->setUniformsForBuiltins();    s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &s_color.r, 1);    s_shader->setUniformLocationWith1f(s_pointSizeLocation, s_pointSize);#ifdef EMSCRIPTEN    setGLBufferData(&p, 8);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, 0);#else    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, &p);#endif // EMSCRIPTEN    glDrawArrays(GL_POINTS, 0, 1);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,1);}

void Triangle::onDraw(const Mat4 &transform, uint32_t flags){    auto glProgram = getGLProgram();    glProgram->use();    glProgram->setUniformsForBuiltins(transform);        glEnable(GL_DEPTH_TEST);    GL::blendFunc(_blendFunc.src, _blendFunc.dst);        if (_dirty)    {        glBindBuffer(GL_ARRAY_BUFFER, _vbo);        glBufferData(GL_ARRAY_BUFFER, sizeof(Vec3)*_bufferCapacity, _buffer, GL_STREAM_DRAW);        _dirty = false;    }        if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(_vao);    }        GL::bindTexture2D(_textureWall->getName());        glDrawArrays(_drawMode, 0, _bufferCount);    glBindBuffer(GL_ARRAY_BUFFER, 0);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_bufferCount);    glDisable(GL_DEPTH_TEST);    CHECK_GL_ERROR_DEBUG();}

void drawSolidPoly(const Vec2 *poli, unsigned int numberOfPoints, Color4F color){    lazy_init();    s_shader->use();    s_shader->setUniformsForBuiltins();    s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &color.r, 1);    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );    // FIXME: Mac OpenGL error. arrays can't go out of scope before draw is executed    Vec2* newPoli = new (std::nothrow) Vec2[numberOfPoints];    // iPhone and 32-bit machines optimization    if (sizeof(Vec2) == sizeof(Vec2))    {        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, poli);    }    else    {        // Mac on 64-bit        for(unsigned int i = 0; i < numberOfPoints; i++)        {            newPoli[i].set(poli[i].x, poli[i].y);        }        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, newPoli);    }    glDrawArrays(GL_TRIANGLE_FAN, 0, (GLsizei) numberOfPoints);    CC_SAFE_DELETE_ARRAY(newPoli);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, numberOfPoints);}

void MySprite::onDraw(const Mat4 &transform, uint32_t flags){    getGLProgram()->use();    getGLProgram()->setUniformsForBuiltins(transform);    GL::blendFunc( _blendFunc.src, _blendFunc.dst );    GL::bindTexture2D( _texture->getName() );    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX );    #define kQuadSize sizeof(_quad.bl)    size_t offset = (size_t)&_quad;    // vertex    int diff = offsetof( V3F_C4B_T2F, vertices);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff));    // texCoods    diff = offsetof( V3F_C4B_T2F, texCoords);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));    // color    diff = offsetof( V3F_C4B_T2F, colors);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);    CHECK_GL_ERROR_DEBUG();    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,4);}

void LHDrawNode::onDraw(const Mat4 &transform, uint32_t flags){    if(_texture)    {        GL::blendFunc(_blendFunc.src, _blendFunc.dst);        GL::bindTexture2D(_texture->getName());        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);        GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);    }    else{        GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR);    }        if(_glProgram){        _glProgram->use();        _glProgram->setUniformsForBuiltins(transform);    }	    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(cocos2d::Point), _trianglePoints);	glVertexAttribPointer(1, 4, GL_FLOAT, GL_TRUE, sizeof(cocos2d::Color4F), _colors);        if(_texture){        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(cocos2d::Point), _uvPoints);    }    	glDrawArrays(GL_TRIANGLES, 0, _numberOfTriangles*3);        glBindBuffer(GL_ARRAY_BUFFER, 0);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_numberOfTriangles*3);    CHECK_GL_ERROR_DEBUG();}

void LayerRadialGradient::onDraw(const Mat4& transform, uint32_t /*flags*/){    auto program = getGLProgram();    program->use();    program->setUniformsForBuiltins(transform);    program->setUniformLocationWith4f(_uniformLocationStartColor, _startColorRend.r,                                      _startColorRend.g, _startColorRend.b, _startColorRend.a);    program->setUniformLocationWith4f(_uniformLocationEndColor, _endColorRend.r,                                      _endColorRend.g, _endColorRend.b, _endColorRend.a);    program->setUniformLocationWith2f(_uniformLocationCenter, _center.x, _center.y);    program->setUniformLocationWith1f(_uniformLocationRadius, _radius);    program->setUniformLocationWith1f(_uniformLocationExpand, _expand);            GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION);        //    // Attributes    //    glBindBuffer(GL_ARRAY_BUFFER, 0);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, _vertices);        GL::blendFunc(_blendFunc.src, _blendFunc.dst);        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,4);}

void Skybox::onDraw(const Mat4& transform, uint32_t flags){    auto camera = Camera::getVisitingCamera();        Mat4 cameraModelMat = camera->getNodeToWorldTransform();        auto state = getGLProgramState();    state->apply(transform);    Vec4 color(_displayedColor.r / 255.f, _displayedColor.g / 255.f, _displayedColor.b / 255.f, 1.f);    state->setUniformVec4("u_color", color);    cameraModelMat.m[12] = cameraModelMat.m[13] = cameraModelMat.m[14] = 0;    state->setUniformMat4("u_cameraRot", cameraModelMat);    glEnable(GL_DEPTH_TEST);    StateBlock::_defaultState->setDepthTest(true);    glDepthFunc(GL_LEQUAL);    StateBlock::_defaultState->setDepthFunction(DEPTH_LEQUAL);    glEnable(GL_CULL_FACE);    StateBlock::_defaultState->setCullFace(true);    glCullFace(GL_BACK);    StateBlock::_defaultState->setCullFaceSide(CULL_FACE_SIDE_BACK);        glDisable(GL_BLEND);    StateBlock::_defaultState->setBlend(false);    if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(_vao);    }    else    {        GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION);        glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vec3), nullptr);        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);    }    glDrawElements(GL_TRIANGLES, (GLsizei)36, GL_UNSIGNED_BYTE, nullptr);    if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(0);    }    else    {        glBindBuffer(GL_ARRAY_BUFFER, 0);        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);    }    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8);    CHECK_GL_ERROR_DEBUG();}

void CameraBackgroundSkyBoxBrush::drawBackground(Camera* camera){    Mat4 cameraModelMat = camera->getNodeToWorldTransform();        _glProgramState->apply(Mat4::IDENTITY);        Vec4 color(1.f, 1.f, 1.f, 1.f);    _glProgramState->setUniformVec4("u_color", color);    cameraModelMat.m[12] = cameraModelMat.m[13] = cameraModelMat.m[14] = 0;    _glProgramState->setUniformMat4("u_cameraRot", cameraModelMat);        glEnable(GL_DEPTH_TEST);    StateBlock::_defaultState->setDepthTest(true);        glDepthMask(GL_TRUE);    StateBlock::_defaultState->setDepthWrite(true);        glDepthFunc(GL_ALWAYS);    StateBlock::_defaultState->setDepthFunction(DEPTH_ALWAYS);        glEnable(GL_CULL_FACE);    StateBlock::_defaultState->setCullFace(true);        glCullFace(GL_BACK);    StateBlock::_defaultState->setCullFaceSide(CULL_FACE_SIDE_BACK);        glDisable(GL_BLEND);    StateBlock::_defaultState->setBlend(false);        if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(_vao);    }    else    {        GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION);                glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vec3), nullptr);                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);    }        glDrawElements(GL_TRIANGLES, (GLsizei)36, GL_UNSIGNED_BYTE, nullptr);        if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(0);    }    else    {        glBindBuffer(GL_ARRAY_BUFFER, 0);        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);    }        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8);        CHECK_GL_ERROR_DEBUG();}

void BattleLowNode::onDraw(const cocos2d::Mat4 &transform, uint32_t flags){    auto glProgram = _programState->getGLProgram();    glProgram->use();    //    auto loc = glProgram->getUniformLocation("u_color");    //    glProgram->setUniformLocationWith4fv(loc, &_color.r, 1);    //    loc = glProgram->getUniformLocation("u_factor");    //    glProgram->setUniformLocationWith1f(loc, _factor);    //    loc = glProgram->getUniformLocation("u_texture_shadow");    //    glProgram->setUniformLocationWith1i(loc, 1);    //    loc = glProgram->getUniformLocation("u_light_color");    //    glProgram->setUniformLocationWith3fv(loc, &_lightColor.r, 1);    //    loc = glProgram->getUniformLocation("u_light_direction");    //    glProgram->setUniformLocationWith3fv(loc, &_lightDirection.x, 1);    //    loc = glProgram->getUniformLocation("u_speed");    //    glProgram->setUniformLocationWith1f(loc, _speed*25);    //    GL::bindTexture2DN(1, _textureShadow->getName());    auto loc = glProgram->getUniformLocation("u_texture_fieldbg");    glProgram->setUniformLocationWith1i(loc, 0);    GL::bindTexture2DN(0, _textureFieldBg->getName());    loc = glProgram->getUniformLocation("u_texture_buildingbg");    glProgram->setUniformLocationWith1i(loc, 1);    GL::bindTexture2DN(1, _textureBuildingBg->getName());    glProgram->setUniformsForBuiltins(transform);    glBindBuffer(GL_ARRAY_BUFFER, _vbo);    if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(_vao);    }    else    {        // TODO    }    glEnable (GL_BLEND);    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);    /*2D的，都在同一Z位置，开启depth test会导致后画的不再绘制。     glEnable(GL_DEPTH_TEST);     glDepthMask(true);     */    glDrawArrays(GL_TRIANGLES, 0, 6);    if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(0);    }    glBindBuffer(GL_ARRAY_BUFFER, 0);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,6);    CHECK_GL_ERROR_DEBUG();}

void SimplePixelNode::onDraw(const cocos2d::Mat4 &transform, uint32_t flags){    auto glProgram = _programState->getGLProgram();    glProgram->use();    glProgram->setUniformsForBuiltins(transform);    glBindBuffer(GL_ARRAY_BUFFER, _vbo);    if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(_vao);    }    else    {        // TODO    }//    glEnable (GL_BLEND);//    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);    glDisable(GL_BLEND);    glEnable(GL_CULL_FACE);    // shadow cover打开depth test同时在fsh中对a为0的进行discard，以保证重合交叠处不会交叠而加深。    glEnable(GL_DEPTH_TEST);    glDepthMask(true);    if (_stencil) {        glEnable(GL_STENCIL_TEST);        // Draw floor        glStencilFunc(GL_ALWAYS, 1, 0xFF); // Set any stencil to 1        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);        glStencilMask(0xFF); // Write to stencil buffer        glDepthMask(GL_FALSE); // Don't write to depth buffer        glClear(GL_STENCIL_BUFFER_BIT); // Clear stencil buffer (0 by default)    }    if (_stenciled) {        glEnable(GL_STENCIL_TEST);        glStencilFunc(GL_EQUAL, 1, 0xFF); // Pass test if stencil value is 1        glStencilMask(0x00); // Don't write anything to stencil buffer        glDepthMask(GL_TRUE); // Write to depth buffer    }    glDrawArrays(GL_TRIANGLES, 0, _count);    if (Configuration::getInstance()->supportsShareableVAO())    {        GL::bindVAO(0);    }    glDisable(GL_STENCIL_TEST);    glBindBuffer(GL_ARRAY_BUFFER, 0);    glDisable(GL_DEPTH_TEST);    glDepthMask(false);    glEnable (GL_BLEND);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_count);    CHECK_GL_ERROR_DEBUG();}

void TMXLayer::onDraw(Primitive *primitive){	_texture->prepareDraw();    GL::bindTexture2D(_texture->getName());    getGLProgramState()->apply(_modelViewTransform);        GL::bindVAO(0);    primitive->draw();    glBindBuffer(GL_ARRAY_BUFFER, 0);    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, primitive->getCount() * 4);}

void PrimitiveCommand::execute() const{    //Set texture    GL::bindTexture2D(_textureID);        //set blend mode    GL::blendFunc(_blendType.src, _blendType.dst);        _glProgramState->apply(_mv);        _primitive->draw();    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_primitive->getCount());}

void ShaderNode::onDraw(const Mat4 &transform, uint32_t flags){    float w = SIZE_X, h = SIZE_Y;    GLfloat vertices[12] = {0,0, w,0, w,h, 0,0, 0,h, w,h};    auto glProgramState = getGLProgramState();    glProgramState->setVertexAttribPointer("a_position", 2, GL_FLOAT, GL_FALSE, 0, vertices);    glProgramState->apply(transform);    glDrawArrays(GL_TRIANGLES, 0, 6);        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,6);}