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); }
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 B2DLayer::draw(){ CCLayer::draw(); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); kmGLPushMatrix(); world->DrawDebugData(); kmGLPopMatrix(); }
void EXSunShineSprite::draw() { ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex); m_sBlendFunc.src = GL_DST_COLOR; m_sBlendFunc.dst = GL_ONE; ccGLBlendFunc( m_sBlendFunc.src, m_sBlendFunc.dst ); this->getShaderProgram()->use(); this->getShaderProgram()->setUniformsForBuiltins(); ccGLBindTexture2D( this->getTexture()->getName() ); #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); CC_INCREMENT_GL_DRAWS(1); }
void ccDrawQuadBezier(const CCPoint& origin, const CCPoint& control, const CCPoint& destination, unsigned int segments) { lazy_init(); ccVertex2F* vertices = new ccVertex2F[segments + 1]; float t = 0.0f; for(unsigned int i = 0; i < segments; i++) { vertices[i].x = powf(1 - t, 2) * origin.x + 2.0f * (1 - t) * t * control.x + t * t * destination.x; vertices[i].y = powf(1 - t, 2) * origin.y + 2.0f * (1 - t) * t * control.y + t * t * destination.y; t += 1.0f / segments; } vertices[segments].x = destination.x; vertices[segments].y = destination.y; s_pShader->use(); s_pShader->setUniformsForBuiltins(); s_pShader->setUniformLocationWith4fv(s_nColorLocation, (GLfloat*) &s_tColor.r, 1); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices); glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) segments + 1); CC_SAFE_DELETE_ARRAY(vertices); CC_INCREMENT_GL_DRAWS(1); }
void CCGSpell::onDraw(const Mat4 &transform, uint32_t flags) { // 启用attributes变量输入,顶点坐标,纹理坐标,颜色 ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex); _pShaderProgram->use(); _pShaderProgram->setUniformsForBuiltins(transform); // 绑定纹理到纹理槽0 ccGLBindTexture2D(_texture->getName()); long offset = (long)&_quad; // vertex int diff = offsetof(V3F_C4B_T2F, vertices); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), (void*)(offset + diff)); // texCoods diff = offsetof(V3F_C4B_T2F, texCoords); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), (void*)(offset + diff)); // color diff = offsetof(V3F_C4B_T2F, colors); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V3F_C4B_T2F), (void*)(offset + diff)); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 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 ccDrawPoints( const CCPoint *points, unsigned int numberOfPoints ) { lazy_init(); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); shader_->use(); shader_->setUniformForModelViewProjectionMatrix(); shader_->setUniformLocationWith4fv(colorLocation_, (GLfloat*) &color_.r, 1); shader_->setUniformLocationWith1f(pointSizeLocation_, pointSize_); // XXX: Mac OpenGL error. arrays can't go out of scope before draw is executed ccVertex2F* newPoints = new ccVertex2F[numberOfPoints]; // iPhone and 32-bit machines optimization if( sizeof(CCPoint) == sizeof(ccVertex2F) ) { glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, points); } else { // Mac on 64-bit for( unsigned int i=0; i<numberOfPoints;i++) { newPoints[i].x = points[i].x; newPoints[i].y = points[i].y; } glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, newPoints); } glDrawArrays(GL_POINTS, 0, (GLsizei) numberOfPoints); CC_SAFE_DELETE_ARRAY(newPoints); CC_INCREMENT_GL_DRAWS(1); }
void ccDrawPoint( const CCPoint& point ) { lazy_init(); ccVertex2F p; p.x = point.x; p.y = point.y; ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); s_pShader->use(); s_pShader->setUniformsForBuiltins(); s_pShader->setUniformLocationWith4fv(s_nColorLocation, (GLfloat*) &s_tColor.r, 1); s_pShader->setUniformLocationWith1f(s_nPointSizeLocation, s_fPointSize); #ifdef EMSCRIPTEN setGLBufferData(&p, 8); glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, 0); #else glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, &p); #endif // EMSCRIPTEN glDrawArrays(GL_POINTS, 0, 1); CC_INCREMENT_GL_DRAWS(1); }
void ccDrawCubicBezier(const CCPoint& origin, const CCPoint& control1, const CCPoint& control2, const CCPoint& destination, unsigned int segments) { lazy_init(); ccVertex2F* vertices = new ccVertex2F[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_pShader->use(); s_pShader->setUniformsForBuiltins(); s_pShader->setUniformLocationWith4fv(s_nColorLocation, (GLfloat*) &s_tColor.r, 1); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); #ifdef EMSCRIPTEN setGLBufferData(vertices, (segments + 1) * sizeof(ccVertex2F)); glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, 0); #else glVertexAttribPointer(kCCVertexAttrib_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_DRAWS(1); }
void BloodFlashSprite::draw() { ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex); ccGLBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); getShaderProgram()->use(); getShaderProgram()->setUniformsForBuiltins(); ccGLBindTexture2D(getTexture()->getName()); // attributes. #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); CC_INCREMENT_GL_DRAWS(1); }
void SpriteBlur::draw() { ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex ); ccGLBlendFunc( m_sBlendFunc.src, m_sBlendFunc.dst ); getShaderProgram()->use(); getShaderProgram()->setUniformForModelViewProjectionMatrix(); getShaderProgram()->setUniformLocationWith2f(blurLocation, blur_.x, blur_.y); getShaderProgram()->setUniformLocationWith4fv(subLocation, sub_, 1); ccGLBindTexture2D( getTexture()->getName() ); // // Attributes // #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); CC_INCREMENT_GL_DRAWS(1); }
void ccDrawSolidPoly( const CCPoint *poli, unsigned int numberOfPoints, ccColor4F color ) { lazy_init(); s_pShader->use(); s_pShader->setUniformsForBuiltins(); s_pShader->setUniformLocationWith4fv(s_nColorLocation, (GLfloat*) &color.r, 1); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); // XXX: Mac OpenGL error. arrays can't go out of scope before draw is executed ccVertex2F* newPoli = new ccVertex2F[numberOfPoints]; // iPhone and 32-bit machines optimization if( sizeof(CCPoint) == sizeof(ccVertex2F) ) { glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, poli); } else { // Mac on 64-bit for( unsigned int i=0; i<numberOfPoints; i++) { newPoli[i] = vertex2( poli[i].x, poli[i].y ); } glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, newPoli); } glDrawArrays(GL_TRIANGLE_FAN, 0, (GLsizei) numberOfPoints); CC_SAFE_DELETE_ARRAY(newPoli); 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(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 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 CCDrawNode::render() { if (m_bDirty) { glBindBuffer(GL_ARRAY_BUFFER, m_uVbo); glBufferData(GL_ARRAY_BUFFER, sizeof(ccV2F_C4B_T2F)*m_uBufferCapacity, m_pBuffer, GL_STREAM_DRAW); m_bDirty = false; } #if CC_TEXTURE_ATLAS_USE_VAO ccGLBindVAO(m_uVao); #else ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex); glBindBuffer(GL_ARRAY_BUFFER, m_uVbo); // vertex glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, sizeof(ccV2F_C4B_T2F), (GLvoid *)offsetof(ccV2F_C4B_T2F, vertices)); // color glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(ccV2F_C4B_T2F), (GLvoid *)offsetof(ccV2F_C4B_T2F, colors)); // texcood glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, sizeof(ccV2F_C4B_T2F), (GLvoid *)offsetof(ccV2F_C4B_T2F, texCoords)); #endif glDrawArrays(GL_TRIANGLES, 0, m_nBufferCount); glBindBuffer(GL_ARRAY_BUFFER, 0); //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 CBTextureAtlas::drawNumberOfQuadsEx(unsigned int n, unsigned int start) { if (0 == n) { return; } ccGLBindTexture2D(m_pTexture->getName()); #define kQuadSize sizeof(m_pQuads[0].bl) ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex); // vertices long offset = (long)m_pQuads; int diff = offsetof( ccV3F_C4B_T2F, vertices); glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*)(offset + diff)); // colors diff = offsetof(ccV3F_C4B_T2F, colors); glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (GLvoid*)(offset + diff)); // tex coords diff = offsetof(ccV3F_C4B_T2F, texCoords); glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*)(offset + diff)); #if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP glDrawElements(GL_TRIANGLE_STRIP, (GLsizei)n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6 + m_pIndices)); #else glDrawElements(GL_TRIANGLES, (GLsizei)n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6 + m_pIndices)); #endif // CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP CC_INCREMENT_GL_DRAWS(1); 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 TestColliderDetector::draw() { ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); kmGLPushMatrix(); world->DrawDebugData(); kmGLPopMatrix(); }
void RigidBlock::draw() { if(!m_isAlive) return; ccGLBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); m_vertexCoord[0] = Vertex2DMake((m_position.x - m_size.width/2), (m_position.y + m_size.height/2) ); m_vertexCoord[1] = Vertex2DMake((m_position.x + m_size.width/2), (m_position.y + m_size.height/2)); m_vertexCoord[2] = Vertex2DMake((m_position.x - m_size.width/2), (m_position.y - m_size.height/2) ); m_vertexCoord[3] = Vertex2DMake((m_position.x + m_size.width/2), (m_position.y - m_size.height/2)); /* m_vertexCoord[0] = Vertex2DMake( -m_size.width/2, m_size.height/2); m_vertexCoord[1] = Vertex2DMake( m_size.width/2, m_size.height/2); m_vertexCoord[2] = Vertex2DMake( -m_size.width/2, -m_size.height/2); m_vertexCoord[3] = Vertex2DMake( m_size.width/2, -m_size.height/2);*/ ccGLBindTexture2D(m_texture->getName()); m_texture->getShaderProgram()->use(); m_texture->getShaderProgram()->setUniformsForBuiltins(); ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords); glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, m_textCoord); glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, m_vertexCoord); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); }
void ccDrawCubicBezier(const CCPoint& origin, const CCPoint& control1, const CCPoint& control2, const CCPoint& destination, unsigned int segments) { lazy_init(); ccVertex2F* vertices = new ccVertex2F[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; shader_->use(); shader_->setUniformForModelViewProjectionMatrix(); shader_->setUniformLocationWith4fv(colorLocation_, (GLfloat*) &color_.r, 1); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices); glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) segments + 1); CC_SAFE_DELETE_ARRAY(vertices); CC_INCREMENT_GL_DRAWS(1); }
//-------------------------------------------------------- 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 HueSprite::draw() { 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(); ccGLEnable( m_eGLServerState ); ccGLBlendFunc( m_sBlendFunc.src, m_sBlendFunc.dst ); m_shader->use(); m_shader->setUniformsForBuiltins(); if (m_pobTexture != NULL) { //ccGLBindTexture2D( m_texure1->getName()); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_pobTexture->getName()); } else { ccGLBindTexture2D(0); } glUniformMatrix3fv(m_loc_hue, 1, GL_FALSE, (GLfloat*)&m_mat); // // Attributes // ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex ); #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); CHECK_GL_ERROR_DEBUG(); CC_INCREMENT_GL_DRAWS(1); CC_PROFILER_STOP_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw"); }
// overriding draw method void 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(); }
void BuoyancyScene::draw() { CCLayer::draw(); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); kmGLPushMatrix(); physics->drawDebugData(); kmGLPopMatrix(); CHECK_GL_ERROR_DEBUG(); }
void PaintLayer::fillLineTriangles(LineVertex *vertices, int count, ccColor4F color) { getShaderProgram()->use(); getShaderProgram()->setUniformsForBuiltins(); ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position | kCCVertexAttribFlag_Color); ccColor4F fullColor = color; ccColor4F fadeOutColor = color; fadeOutColor.a = 0; for (int i = 0; i < count / 18; ++i) { for (int j = 0; j < 6; ++j) { vertices[i * 18 + j].color = color; } //! F*G vertices[i * 18 + 6].color = fadeOutColor; vertices[i * 18 + 7].color = fullColor; vertices[i * 18 + 8].color = fadeOutColor; //! AGD vertices[i * 18 + 9].color = fullColor; vertices[i * 18 + 10].color = fadeOutColor; vertices[i * 18 + 11].color = fullColor; //! BHC vertices[i * 18 + 12].color = fullColor; vertices[i * 18 + 13].color = fadeOutColor; vertices[i * 18 + 14].color = fullColor; //! HCI vertices[i * 18 + 15].color = fadeOutColor; vertices[i * 18 + 16].color = fullColor; vertices[i * 18 + 17].color = fadeOutColor; } glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, sizeof(LineVertex), &vertices[0].pos); glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_FLOAT, GL_FALSE, sizeof(LineVertex), &vertices[0].color); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glDrawArrays(GL_TRIANGLES, 0, (GLsizei)count); for (unsigned int i = 0; i < circlesPoints->count() / 2; ++i) { LinePoint *prevPoint = (LinePoint *)circlesPoints->objectAtIndex(i * 2); LinePoint *curPoint = (LinePoint *)circlesPoints->objectAtIndex(i * 2 + 1); CCPoint dirVector = ccpNormalize(ccpSub(curPoint->pos, prevPoint->pos)); this->fillLineEndPointAt(curPoint->pos, dirVector, curPoint->width * 0.4f, color); } circlesPoints->removeAllObjects(); }
void HelloWorld::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags) { Layer::draw(renderer, transform, flags); // Draw debug for Box2D. ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position); kmGLPushMatrix(); m_world->DrawDebugData(); kmGLPopMatrix(); }
//------------------------------------------------------------- //- Render //- Renders a specific frame of the MD2 model //------------------------------------------------------------- void CCModelMd2::draw(unsigned int uiFrame) { float* m_pUV = new float[m_Head.numTriangles * 6]; memset(m_pUV, 0, m_Head.numTriangles * 6); float* m_pVertices = new float[m_Head.numTriangles * 9]; memset(m_pVertices, 0, m_Head.numTriangles * 9); int uvIdx = 0; int vertexIdx = 0; for (int i =0; i < m_Head.numTriangles; i++) { m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[0]].x; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[0]].y; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[0]].z; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[1]].x; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[1]].y; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[1]].z; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[2]].x; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[2]].y; m_pVertices[vertexIdx++] = m_pFrames[uiFrame].verts[m_pTriangles[i].vertIndices[2]].z; m_pUV[uvIdx++] = m_pTexCoords[m_pTriangles[i].texIndices[0]].s; m_pUV[uvIdx++] = m_pTexCoords[m_pTriangles[i].texIndices[0]].t; m_pUV[uvIdx++] = m_pTexCoords[m_pTriangles[i].texIndices[1]].s; m_pUV[uvIdx++] = m_pTexCoords[m_pTriangles[i].texIndices[1]].t; m_pUV[uvIdx++] = m_pTexCoords[m_pTriangles[i].texIndices[2]].s; m_pUV[uvIdx++] = m_pTexCoords[m_pTriangles[i].texIndices[2]].t; } ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords); if(!m_bIsCustomSkin) { if (m_pSkins) { ccGLBindTexture2D(m_pSkins[m_uiSkin].m_Image->getName()); } } else { ccGLBindTexture2D(m_pCustSkin->getName()); } glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, 0, m_pVertices); glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, m_pUV); glDrawArrays(GL_TRIANGLES, 0, m_Head.numTriangles * 3); CC_INCREMENT_GL_DRAWS(1); CHECK_GL_ERROR_DEBUG(); CC_SAFE_DELETE_ARRAY(m_pUV); CC_SAFE_DELETE_ARRAY(m_pVertices); }
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); }