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

void BatchNode::draw(Renderer *renderer, const kmMat4 &transform, bool transformUpdated){    if (_children.empty())    {        return;    }    CC_NODE_DRAW_SETUP();    bool pushed = false;    for(auto object : _children)    {        Armature *armature = dynamic_cast<Armature *>(object);        if (armature)        {            if (!pushed)            {                generateGroupCommand();                pushed = true;            }                    armature->visit(renderer, transform, transformUpdated);        }        else        {            renderer->popGroup();            pushed = false;                        ((Node *)object)->visit(renderer, transform, transformUpdated);        }    }}

void TextureSprite::draw(){    if (!m_bVisible) return;    CC_NODE_DRAW_SETUP();    ccGLBlendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);    ccGLBindTexture2D(mTexture2D->getName());    ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords);    /// Time offset    getShaderProgram()->setUniformLocationWith2f(mTimeLocation, mTime.x, mTime.y);    /// Color    getShaderProgram()->setUniformLocationWith4f(mColorLocation, mColor.r, mColor.g, mColor.b, mColor.a);    /// Vertex    glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, sizeof(ccVertex3F), (void*)&mVertexPos[0]);    /// Texture coord.    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, sizeof(ccTex2F), (void*)&mTexCoords[0]);    /// Available mode: GL_TRIANGLES, GL_TRIANGLES_STRIP and GL_TRIANGLE_FAN    glDrawArrays(GL_TRIANGLES, 0, mVertexPos.size());    /// Do NOT call glFlush or performance will decrease drastically!    /// glFlush();    CHECK_GL_ERROR_DEBUG();    CC_INCREMENT_GL_DRAWS(1);}

void CADrawView::draw(){    CC_NODE_DRAW_SETUP();    ccGLBlendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);        render();}

KDvoid Controller::draw ( KDvoid ){    CC_NODE_DRAW_SETUP ( );    	GLfloat  fVertices [ ] = 	{		   0,  512, 		1024,  512, 		   0,    0, 		1024,    0, 	};	GLfloat  fCoords [ ] =	{		   0,  0,		   1,  0,		   0,  1, 		   1,  1, 	};	ccGLBindTexture2D ( m_uTexture );    ccGLEnableVertexAttribs ( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords );	if ( m_pDrawFunc )	{		m_pDrawFunc ( KD_GET_UST2MSEC );	}	ccGLVertexAttribPointer ( kCCVertexAttrib_Position , 2, GL_FLOAT, GL_FALSE, 0, fVertices );	ccGLVertexAttribPointer ( kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, fCoords );		glDrawArrays ( GL_TRIANGLE_STRIP, 0, 4 );	ccGLBindTexture2D ( 0 );}

void BBWater::draw(){    CC_NODE_DRAW_SETUP();    //    ccGLBlendFunc( m_sBlendFunc.src, m_sBlendFunc.dst );        ccGLBindTexture2D( m_sprite->getTexture()->getName() );//    ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position );    //    glBindBuffer(GL_ARRAY_BUFFER, m_vertexVbo);//    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*vertexArray.size(), &vertexArray[0], GL_STATIC_DRAW);        glEnableVertexAttribArray( kCCVertexAttrib_Position );        // vertex    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3, &vertexArray[0]);    //    // texCoods//    diff = offsetof( ccV3F_C4B_T2F, texCoords);//    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));//    //    // color//    diff = offsetof( ccV3F_C4B_T2F, colors);//    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));            glDrawArrays(GL_TRIANGLES, 0, m_faceCount);        CHECK_GL_ERROR_DEBUG();}

void CCEPixelNode::draw(){	CC_NODE_DRAW_SETUP();    ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_Color );    //    // Attributes    //	ccePixelPart* pt = m_pPixels;	while(pt!=NULL) {		if(!pt->hide) {			for(int i=0;i<pt->len;i++) {				ccePixelInfo* p = pt->pixels+i;				if(p->hide)continue;				glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, p->square);				glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_FLOAT, GL_FALSE, 0, p->color);						ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );				glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);			}		}		pt = pt->next;	}    CC_INCREMENT_GL_DRAWS(1);	}

void CCMenuItemColor::draw(Renderer *renderer, const kmMat4& transform, bool transformUpdated) {    CC_NODE_DRAW_SETUP();        ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_Color );        //    // Attributes    //#ifdef EMSCRIPTEN    setGLBufferData(m_pSquareVertices, 4 * sizeof(ccVertex2F), 0);    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, 0);        setGLBufferData(m_pSquareColors, 4 * sizeof(ccColor4F), 1);    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_FLOAT, GL_FALSE, 0, 0);#else    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, m_pSquareVertices);    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_FLOAT, GL_FALSE, 0, m_pSquareColors);#endif // EMSCRIPTEN        ccGLBlendFunc(m_tBlendFunc.src, m_tBlendFunc.dst);        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);        CC_INCREMENT_GL_DRAWS(1);}

void Label::onDraw(){    CC_PROFILER_START("Label - draw");    // Optimization: Fast Dispatch    if( _batchNodes.size() == 1 && _textureAtlas->getTotalQuads() == 0 )    {        return;    }    CC_NODE_DRAW_SETUP();    if (_useDistanceField && _currLabelEffect != LabelEffect::NORMAL)    {        _shaderProgram->setUniformLocationWith3f(_uniformEffectColor, _effectColor.r/255.0f,_effectColor.g/255.0f,_effectColor.b/255.0f);    }    for(const auto &child: _children)    {        child->updateTransform();    }    GL::blendFunc( _blendFunc.src, _blendFunc.dst );    for (const auto& batchNode:_batchNodes)    {        batchNode->getTextureAtlas()->drawQuads();    }    CC_PROFILER_STOP("Label - draw");}

void CCDrawNode::draw(){    CC_NODE_DRAW_SETUP();    ccGLBlendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);        render();}

void MotionStreak::draw(){    if(_nuPoints <= 1)        return;    CC_NODE_DRAW_SETUP();    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_DRAWS(1);}

void CCMotionStreak::draw(){    if(m_uNuPoints <= 1)        return;    CC_NODE_DRAW_SETUP(this);    ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex );    ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );    ccGLBindTexture2D( m_pTexture->getName() );    if(m_pTexture->isETC()) {        getShaderProgram()->useSeparatedAlphaChannel(m_pTexture->getAlphaChannel()->getName());    }    #ifdef EMSCRIPTEN    // Size calculations from ::initWithFade    setGLBufferData(m_pVertices, (sizeof(ccVertex2F) * m_uMaxPoints * 2), 0);    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, 0);    setGLBufferData(m_pTexCoords, (sizeof(ccTex2F) * m_uMaxPoints * 2), 1);    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, 0);    setGLBufferData(m_pColorPointer, (sizeof(GLubyte) * m_uMaxPoints * 2 * 4), 2);    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);#else    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, m_pVertices);    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, m_pTexCoords);    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, m_pColorPointer);#endif // EMSCRIPTEN    glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)m_uNuPoints*2);    CC_INCREMENT_GL_DRAWS(1);}

void BatchNode::draw(){    if (_children.empty())    {        return;    }    CC_NODE_DRAW_SETUP();    bool pushed = false;    for(auto object : _children)    {        Armature *armature = dynamic_cast<Armature *>(object);        if (armature)        {            if (!pushed)            {                generateGroupCommand();                pushed = true;            }                    armature->visit();        }        else        {            Director::getInstance()->getRenderer()->popGroup();            pushed = false;                        ((Node *)object)->visit();        }    }}

void Sky::draw(Renderer *renderer, const Mat4& transform, uint32_t flags) {        cocos2d::Size s = Director::getInstance()->getWinSize();        DoodleTruck *doodleTruck = DoodleTruck::sharedDoodleTruck();    CC_NODE_DRAW_SETUP();        Vec2 _skyVertices[4];    Vec2 _skyTexCoords[4];        _skyVertices[0] = Vec2(0, 0);    _skyTexCoords[0] = Vec2(1.0, 1.0f);    _skyVertices[1] = Vec2(s.width, 0);    _skyTexCoords[1] = Vec2(1.0f, 1.0f);        _skyVertices[2] = Vec2(0, s.height);    _skyTexCoords[2] = Vec2(31.0f, 63.0f);    _skyVertices[3] = Vec2(s.width, s.height);    _skyTexCoords[3] = Vec2(31.0f, 63.0f);            Texture2D * tex = Director::getInstance()->getTextureCache()->textureForKey("sky-bg-rainbow.png");    GL::bindTexture2D(tex->getName());    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_TEX_COORD);        ccDrawColor4F(1.0f, 1.0f, 1.0f, 1.0f);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, _skyVertices);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, 0, _skyTexCoords);        glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)4);       // ccDrawColor4F(1.0, 1.0, 1.0, 1.0);*/}

//--------------------------------------------------------void CRemoveBKSprite::draw(void){	CC_PROFILER_START_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");	CCAssert(!m_pobBatchNode, "If CCSprite is being rendered by CCSpriteBatchNode, CCSprite#draw SHOULD NOT be called");	CC_NODE_DRAW_SETUP();	// 启用attributes变量输入，顶点坐标，纹理坐标，颜色	ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex );	ccGLBlendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);	m_pShaderProgram->use();	m_pShaderProgram->setUniformsForBuiltins();	// 绑定纹理到纹理槽0	ccGLBindTexture2D(m_pobTexture->getName());	long offset = (long)&m_sQuad;	// vertex	int diff = offsetof( ccV3F_C4B_T2F, vertices);	glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, sizeof(m_sQuad.bl), (void*) (offset + diff));	// texCoods	diff = offsetof( ccV3F_C4B_T2F, texCoords);	glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, sizeof(m_sQuad.bl), (void*)(offset + diff));	// color	diff = offsetof( ccV3F_C4B_T2F, colors);	glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(m_sQuad.bl), (void*)(offset + diff));	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);	CHECK_GL_ERROR_DEBUG();	CC_INCREMENT_GL_DRAWS(1);	CC_PROFILER_STOP_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");}

void ShaderNode::draw(){    CC_NODE_DRAW_SETUP();    float w = SIZE_X, h = SIZE_Y;    GLfloat vertices[12] = {0,0, w,0, w,h, 0,0, 0,h, w,h};    //    // Uniforms    //    getShaderProgram()->setUniformLocationWith2f(m_uniformCenter, m_center.x, m_center.y);    getShaderProgram()->setUniformLocationWith2f(m_uniformResolution, m_resolution.x, m_resolution.y);    // time changes all the time, so it is Ok to call OpenGL directly, and not the "cached" version    glUniform1f(m_uniformTime, m_time);    ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position );    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices);    glDrawArrays(GL_TRIANGLES, 0, 6);        CC_INCREMENT_GL_DRAWS(1);}

void CCControlSwitchSprite::draw(){    CC_NODE_DRAW_SETUP();    ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex);    ccGLBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);    getShaderProgram()->setUniformForModelViewProjectionMatrix();    glActiveTexture(GL_TEXTURE0);    glBindTexture( GL_TEXTURE_2D, getTexture()->getName());    glUniform1i(m_uTextureLocation, 0);    glActiveTexture(GL_TEXTURE1);    glBindTexture( GL_TEXTURE_2D, m_pMaskTexture->getName() );    glUniform1i(m_uMaskLocation, 1);#define kQuadSize sizeof(m_sQuad.bl)    long offset = (long)&m_sQuad;    // vertex    int diff = offsetof( ccV3F_C4B_T2F, vertices);    glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff));    // texCoods    diff = offsetof( ccV3F_C4B_T2F, texCoords);    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));    // color    diff = offsetof( ccV3F_C4B_T2F, colors);    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);    glActiveTexture(GL_TEXTURE0);}

void ShaderSprite::onDraw(){    CC_NODE_DRAW_SETUP();        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)    long offset = (long)&_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);}

//--------------------------------------------------------void CShaderNode::draw(){	CC_NODE_DRAW_SETUP();  	//传递uniform变量  	CCGLProgram* shader = getShaderProgram();  	shader->setUniformLocationWith2f(m_unUniformResolution, m_tagResolutionPos.x, m_tagResolutionPos.y);	shader->setUniformLocationWith1i(m_unUniformTex0, 0); 	glUniform1f(m_unUniformTime, m_fTime);	//获取attribute变量  	CCSize size = this->getContentSize();  	float w = size.width;  	float h = size.height;  	ccGLBindTexture2D(m_pTexture);								//绑定纹理到槽位  	glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, w, h, 0); //截取屏幕数据到纹理  	glEnableVertexAttribArray(m_unAttributePosition); 	//传递attribute变量  	GLfloat vertices[12] = {  		0, 0, //左下0		w, 0, //右下1		w, h, //右上2		0, 0, //左下0		0, h, //左上3		w, h, //右上2	};  	glVertexAttribPointer(m_unAttributePosition, 2, GL_FLOAT, GL_FALSE, 0, vertices);  	glVertexAttrib4fv(m_unAttributeColor, m_fColor);  	//绘制  	glDrawArrays(GL_TRIANGLES, 0, 6);  }

void LightLayer::draw(){	CC_NODE_DRAW_SETUP();	GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR);	glUniform3f(_spotLocation, _spotPoint.x, _spotPoint.y, 0);	glUniform4f(_innerColor, 0, 0, 0, 0);	glUniform1f(_spotInnerRadius, 50);	glUniform1f(_spotOuterRadius, 220);	//	// Attributes	//#ifdef EMSCRIPTEN	setGLBufferData(_squareVertices, 4 * sizeof(Vertex2F), 0);	glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, 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, 2, GL_FLOAT, GL_FALSE, 0, _squareVertices);	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_DRAWS(1);}

void ShaderNode::draw(){    CC_NODE_DRAW_SETUP();    float w = SIZE_X, h = SIZE_Y;    GLfloat vertices[12] = {0, 0, w, 0, w, h, 0, 0, 0, h, w, h};    //    // Uniforms    //    getShaderProgram()->setUniformLocationWith2f(_uniformCenter, _center.x, _center.y);    getShaderProgram()->setUniformLocationWith2f(_uniformResolution, _resolution.x, _resolution.y);    // time changes all the time, so it is Ok to call OpenGL directly, and not the "cached" version    glUniform1f(_uniformTime, _time);    GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);    glDrawArrays(GL_TRIANGLES, 0, 6);    CC_INCREMENT_GL_DRAWS(1);}

// overriding draw methodvoid CCParticleSystemQuad::draw(){        CCAssert(!m_pBatchNode,"draw should not be called when added to a particleBatchNode");    CC_NODE_DRAW_SETUP();    ccGLBindTexture2D( m_pTexture->getName() );    ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );    CCAssert( m_uParticleIdx == m_uParticleCount, "Abnormal error in particle quad");#if CC_TEXTURE_ATLAS_USE_VAO    //    // Using VBO and VAO    //    glBindVertexArray( m_uVAOname );#if CC_REBIND_INDICES_BUFFER    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);#endif    glDrawElements(GL_TRIANGLES, (GLsizei) m_uParticleIdx*6, GL_UNSIGNED_SHORT, 0);#if CC_REBIND_INDICES_BUFFER    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);#endif    glBindVertexArray( 0 );#else    //    // Using VBO without VAO    //    #define kQuadSize sizeof(m_pQuads[0].bl)    ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex );    glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]);    // vertices    glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, vertices));    // colors    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, colors));    // tex coords    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, texCoords));        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);    glDrawElements(GL_TRIANGLES, (GLsizei) m_uParticleIdx*6, GL_UNSIGNED_SHORT, 0);    glBindBuffer(GL_ARRAY_BUFFER, 0);    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);#endif    CC_INCREMENT_GL_DRAWS(1);    CHECK_GL_ERROR_DEBUG();}

// overriding draw methodvoid ParticleSystemQuad::draw(){        CCASSERT(!_batchNode,"draw should not be called when added to a particleBatchNode");    CC_NODE_DRAW_SETUP();    GL::bindTexture2D( _texture->getName() );    GL::blendFunc( _blendFunc.src, _blendFunc.dst );    CCASSERT( _particleIdx == _particleCount, "Abnormal error in particle quad");#if CC_TEXTURE_ATLAS_USE_VAO    //    // Using VBO and VAO    //    GL::bindVAO(_VAOname);#if CC_REBIND_INDICES_BUFFER    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffersVBO[1]);#endif    glDrawElements(GL_TRIANGLES, (GLsizei) _particleIdx*6, GL_UNSIGNED_SHORT, 0);#if CC_REBIND_INDICES_BUFFER    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);#endif#else    //    // Using VBO without VAO    //    #define kQuadSize sizeof(_quads[0].bl)    GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX );    glBindBuffer(GL_ARRAY_BUFFER, _buffersVBO[0]);    // vertices    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( V3F_C4B_T2F, vertices));    // colors    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (GLvoid*) offsetof( V3F_C4B_T2F, colors));    // tex coords    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( V3F_C4B_T2F, texCoords));        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffersVBO[1]);    glDrawElements(GL_TRIANGLES, (GLsizei) _particleIdx*6, GL_UNSIGNED_SHORT, 0);    glBindBuffer(GL_ARRAY_BUFFER, 0);    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);#endif    CC_INCREMENT_GL_DRAWS(1);    CHECK_GL_ERROR_DEBUG();}

// AtlasNode - drawvoid AtlasNode::draw(void){    CC_NODE_DRAW_SETUP();    ccGLBlendFunc( _blendFunc.src, _blendFunc.dst );    GLfloat colors[4] = {_displayedColor.r / 255.0f, _displayedColor.g / 255.0f, _displayedColor.b / 255.0f, _displayedOpacity / 255.0f};    getShaderProgram()->setUniformLocationWith4fv(_uniformColor, colors, 1);    _textureAtlas->drawNumberOfQuads(_quadsToDraw, 0);}

// CCAtlasNode - drawvoid CCAtlasNode::draw(void){    CC_NODE_DRAW_SETUP();    ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );    GLfloat colors[4] = {m_tColor.r / 255.0f, m_tColor.g / 255.0f, m_tColor.b / 255.0f, m_cOpacity / 255.0f};    getShaderProgram()->setUniformLocationWith4fv(m_nUniformColor, colors, 1);    m_pTextureAtlas->drawNumberOfQuads(m_uQuadsToDraw, 0);}

// Cocos2dxAtlasNode - drawvoid Cocos2dxAtlasNode::draw(){    CC_NODE_DRAW_SETUP();    ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );    GLfloat colors[4] = {_displayedColor.r / 255.0f, _displayedColor.g / 255.0f, _displayedColor.b / 255.0f, _displayedOpacity / 255.0f};    getShaderProgram()->setUniformLocationWith4fv(m_nUniformColor, colors, 1);    m_pTextureAtlas->drawNumberOfQuads(1, m_nQuadIndex);	m_pTextureAtlas->getQuads();}

void CCSprite3D::draw(){//    m_bDepthTestEnabled = 0 == glIsEnabled(GL_DEPTH_TEST) ? false : true;////    CCDirector::sharedDirector()->setDepthTest(true);//    CC_NODE_DRAW_SETUP();//    getShaderProgram()->use();//    getShaderProgram()->setUniformsForBuiltins();    CCPoint const & origin = ccp(0, 0);    CCPoint const & destination = ccp(100, 100);    ccVertex3F vertices[3] = {//        {origin.x, origin.y, 100},            {destination.x, origin.y, 200},            {destination.x, destination.y, 100},            {origin.x, destination.y, 200}    };    ccTex2F uv[3] = {//        {0.0f, 0.0f},            {1.0f, 0.0f},            {1.0f, 1.0f},            {0.0f, 1.0f}    };    ccColor4B colors[3] = {//        {255, 255, 255, 255},            {128, 128, 128, 128},            {128, 128, 128, 128},            {255, 255, 255, 255}    };    ccGLBindTexture2D(mCustSkin->getName());    ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex );    glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, 0, vertices);    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, uv);    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, colors);    glDrawArrays(GL_TRIANGLES, 0, 3);    CHECK_GL_ERROR_DEBUG();    CC_INCREMENT_GL_DRAWS(1);//    m_pModel->draw();//    static unsigned int uiStartFrame = 0, uiEndFrame = 182;//    static float fAnimSpeed = 16.5f;//   ((CCModelMd2*)m_pModel)->animate(fAnimSpeed, uiStartFrame, uiEndFrame, true);//   CCDirector::sharedDirector()->setDepthTest(m_bDepthTestEnabled);}

void TerrainTest::drawHill(){    CC_NODE_DRAW_SETUP();    GL::bindTexture2D(_stripes->getTexture()->getName());    //    ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords);    GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_TEX_COORD);    ccDrawColor4F(1.0f, 1.0f, 1.0f, 1.0f);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, _hillVertices);    glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, 0, _hillTexCoords);        glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)_nHillVertices);    }

void ShaderNode::draw(Renderer *renderer, const Mat4& transform, uint32_t flags){    _customCommand.init(_globalZOrder);    _customCommand.func = [=]() {        CC_NODE_DRAW_SETUP();        GL::bindTexture2D(_texture->getName());        GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_TEX_COORD);        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0,  &_vertices[0]);        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, 0, &_texCoords[0]);        glDrawArrays(GL_TRIANGLE_STRIP, 0, (int)_vertices.size());    };    Director::getInstance()->getRenderer()->addCommand(&_customCommand);}

/** * 绘制 */void MapCoordLine::draw(void){	CC_PROFILER_START_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");	CCAssert(!m_pobBatchNode, "If CCSprite is being rendered by CCSpriteBatchNode, CCSprite#draw SHOULD NOT be called");	CC_NODE_DRAW_SETUP();	ccGLBlendFunc( m_sBlendFunc.src, m_sBlendFunc.dst );	if (m_pobTexture != NULL)	{		ccGLBindTexture2D( m_pobTexture->getName() );	}	else	{		ccGLBindTexture2D(0);	}	//	// Attributes	//	ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex );	#define kQuadSize sizeof(m_sQuad.bl)	if (points.size())	{		long offset = (long)&points[0];		// vertex		int diff = offsetof( ccV3F_C4B_T2F, vertices);		glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff));		// texCoods		diff = offsetof( ccV3F_C4B_T2F, texCoords);		glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));		// color		diff = offsetof( ccV3F_C4B_T2F, colors);		glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));		glDrawArrays(GL_LINES, 0, points.size());	}	CHECK_GL_ERROR_DEBUG();	CC_INCREMENT_GL_DRAWS(1);	CC_PROFILER_STOP_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");}