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);
}
