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);
}
// Wireframe OpenGL drawing
void
Scene_polylines_item::draw_edges(Viewer_interface* viewer) const {
if(!are_buffers_filled)
initialize_buffers(viewer);
vaos[0]->bind();
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
program->bind();
QColor temp = this->color();
program->setAttributeValue("colors", temp);
qFunc.glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(positions_lines.size()/4));
program->release();
vaos[0]->release();
if(d->draw_extremities)
{
vaos[2]->bind();
attrib_buffers(viewer, PROGRAM_INSTANCED_WIRE);
program = getShaderProgram(PROGRAM_INSTANCED_WIRE);
program->bind();
qFunc.glDrawArraysInstanced(GL_LINES, 0,
static_cast<GLsizei>(positions_wire_spheres.size()/4), nbSpheres);
program->release();
vaos[2]->release();
}
}
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);
}
bool BloodFlashSprite::initWithTexture(CCTexture2D *pTexture, const CCRect& rect)
{
if (CCSprite::initWithTexture(pTexture, rect))
{
CCGLProgram *program = new CCGLProgram;
GLchar *fragSrc = (GLchar *)CCString::createWithContentsOfFile(
CCFileUtils::sharedFileUtils()->fullPathForFilename(_fragShaderName.c_str()).c_str())->getCString();
program->initWithVertexShaderByteArray(ccPositionTextureColor_vert, fragSrc);
setShaderProgram(program);
program->release();
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->link();
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->updateUniforms();
CHECK_GL_ERROR_DEBUG();
return true;
}
return false;
}
// Shaded OpenGL drawing: only draw spheres
void
Scene_polylines_item::draw(Viewer_interface* viewer) const {
if(!are_buffers_filled)
initialize_buffers(viewer);
if(d->draw_extremities)
{
if(viewer->extension_is_found)
{
vaos[1]->bind();
program = getShaderProgram(PROGRAM_INSTANCED);
attrib_buffers(viewer, PROGRAM_INSTANCED);
program->bind();
viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
static_cast<GLsizei>(nb_spheres/3), nbSpheres);
program->release();
vaos[1]->release();
}
else
{
vaos[1]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
glPointSize(8.0f);
glEnable(GL_POINT_SMOOTH);
program->bind();
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(nb_centers/3));
glDisable(GL_POINT_SMOOTH);
program->release();
vaos[1]->release();
}
}
}
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);
}
// Wireframe OpenGL drawing
void
Scene_polylines_item::draw_edges(Viewer_interface* viewer) const {
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
vaos[0]->bind();
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(nb_lines/4));
program->release();
vaos[0]->release();
if(d->draw_extremities)
{
if(viewer->extension_is_found)
{
vaos[2]->bind();
attrib_buffers(viewer, PROGRAM_INSTANCED_WIRE);
program = getShaderProgram(PROGRAM_INSTANCED_WIRE);
program->bind();
viewer->glDrawArraysInstanced(GL_LINES, 0,
static_cast<GLsizei>(nb_wire/3), nbSpheres);
program->release();
vaos[2]->release();
}
}
}
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 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 CCTMXLayer::parseInternalProperties()
{
// if cc_vertex=automatic, then tiles will be rendered using vertexz
CCString *vertexz = propertyNamed("cc_vertexz");
if (vertexz)
{
// If "automatic" is on, then parse the "cc_alpha_func" too
if (vertexz->m_sString == "automatic")
{
m_bUseAutomaticVertexZ = true;
CCString *alphaFuncVal = propertyNamed("cc_alpha_func");
float alphaFuncValue = 0.0f;
if (alphaFuncVal != NULL)
{
alphaFuncValue = alphaFuncVal->floatValue();
}
setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTextureColorAlphaTest));
GLint alphaValueLocation = glGetUniformLocation(getShaderProgram()->getProgram(), kCCUniformAlphaTestValue);
getShaderProgram()->use();
// NOTE: alpha test shader is hard-coded to use the equivalent of a glAlphaFunc(GL_GREATER) comparison
getShaderProgram()->setUniformLocationWith1f(alphaValueLocation, alphaFuncValue);
CHECK_GL_ERROR_DEBUG();
}
else
{
m_nVertexZvalue = vertexz->intValue();
}
}
}
void Scene_c3t3_item::draw_points(CGAL::Three::Viewer_interface * viewer) const
{
if (!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
vaos[Edges]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(positions_lines.size() / 3));
vaos[Edges]->release();
program->release();
vaos[2]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", this->color());
QMatrix4x4 f_mat;
for (int i = 0; i<16; i++)
f_mat.data()[i] = frame->matrix()[i];
program->setUniformValue("f_matrix", f_mat);
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(positions_grid.size() / 3));
program->release();
vaos[2]->release();
}
void TMXLayer::parseInternalProperties()
{
// if cc_vertex=automatic, then tiles will be rendered using vertexz
String *vertexz = getProperty("cc_vertexz");
if (vertexz)
{
// If "automatic" is on, then parse the "cc_alpha_func" too
if (vertexz->m_sString == "automatic")
{
m_bUseAutomaticVertexZ = true;
String *alphaFuncVal = getProperty("cc_alpha_func");
float alphaFuncValue = 0.0f;
if (alphaFuncVal != NULL)
{
alphaFuncValue = alphaFuncVal->floatValue();
}
setShaderProgram(ShaderCache::getInstance()->getProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST));
GLint alphaValueLocation = glGetUniformLocation(getShaderProgram()->getProgram(), GLProgram::UNIFORM_NAME_ALPHA_TEST_VALUE);
// NOTE: alpha test shader is hard-coded to use the equivalent of a glAlphaFunc(GL_GREATER) comparison
// use shader program to set uniform
getShaderProgram()->use();
getShaderProgram()->setUniformLocationWith1f(alphaValueLocation, alphaFuncValue);
CHECK_GL_ERROR_DEBUG();
}
else
{
m_nVertexZvalue = vertexz->intValue();
}
}
}
void GrayMask::initProgram()
{
std::string sharderStr = CCFileUtils::getInstance()->fullPathForFilename("Shaders/shader_gray.fsh");
GLchar * fragSource = (GLchar*)CCString::createWithContentsOfFile(sharderStr.c_str())->getCString();
CCGLProgram* pProgram = new CCGLProgram();
pProgram->initWithVertexShaderByteArray(ccPositionTextureColor_vert, fragSource);
setShaderProgram(pProgram);
pProgram->release();
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->addAttribute(kCCAttributeNamePosition, kCCVertexAttrib_Position);
getShaderProgram()->addAttribute(kCCAttributeNameColor, kCCVertexAttrib_Color);
getShaderProgram()->addAttribute(kCCAttributeNameTexCoord, kCCVertexAttrib_TexCoords);
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->link();
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->updateUniforms();
CHECK_GL_ERROR_DEBUG();
}
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 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 XSpriteBatchNode::draw()
{
XFUNC_START();
CC_PROFILER_START("XSpriteBatchNode - draw");
if (m_pobTextureAtlas->getTotalQuads() == 0)
{
return;
}
do
{
ccGLEnable(m_eGLServerState);
if (m_pShaderKTX)
{
CCGLProgram* pProg = m_pShaderKTX->GetProgram();
if (pProg)
{
pProg->use();
pProg->setUniformsForBuiltins();
}
}
else
{
if (getShaderProgram())
{
getShaderProgram()->use();
getShaderProgram()->setUniformsForBuiltins();
}
}
if(m_pShaderOnce)
{
m_pShaderOnce->use();
m_pShaderOnce->setUniformsForBuiltins();
if(m_pShaderOnce->m_pShader)
m_pShaderOnce->m_pShader->RunBeforeDraw();
m_pShaderOnce = NULL;
}
//else if(m_pobTextureAtlas->getTexture())
//{
// static XShaderBloom stShaderBloom;
// stShaderBloom.UseShader();
// stShaderBloom.SetTexSize(SCRPIX_W, SCRPIX_H);
//}
} while (0);
arrayMakeObjectsPerformSelector(m_pChildren, updateTransform, CCSprite*);
ccGLBlendFunc(m_blendFunc.src, m_blendFunc.dst);
if (m_pTexKtxAlpha)
{
ccGLBindTexture2DN(1, m_pTexKtxAlpha->getName());
if (m_pShaderKTX)
{
m_pShaderKTX->RunBeforeDraw();
}
}
m_pobTextureAtlas->drawQuads();
CC_PROFILER_STOP("XSpriteBatchNode - draw");
XFUNC_END();
}
void CCDrawNode::draw()
{
ccGLBlendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);
getShaderProgram()->use();
getShaderProgram()->setUniformsForBuiltins();
render();
}
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 BlurSprite::buildCustomUniforms()
{
auto s = getTexture()->getContentSizeInPixels();
blur_ = Point(1/s.width, 1/s.height);
sub_[0] = sub_[1] = sub_[2] = sub_[3] = 0;
subLocation = glGetUniformLocation( getShaderProgram()->getProgram(), "substract");
blurLocation = glGetUniformLocation( getShaderProgram()->getProgram(), "blurSize");
}
void LensFlareSprite::setCustomUniforms()
{
_textureResolution[0] = getTexture()->getContentSizeInPixels().width;
_textureResolution[1] = getTexture()->getContentSizeInPixels().height;
_resolution[0] = getContentSize().width;
_resolution[1] = getContentSize().height;
getShaderProgram()->setUniformLocationWith2fv(_resolutionLoc, _resolution, 1);
getShaderProgram()->setUniformLocationWith2fv(_textureResolutionLoc, _textureResolution, 1);
}
void initialize_buffers(CGAL::Three::Viewer_interface *viewer)
{
//vao containing the data for the facets
{
program = getShaderProgram(PROGRAM_WITH_LIGHT, viewer);
program->bind();
vaos[Facets]->bind();
buffers[Vertices].bind();
buffers[Vertices].allocate(vertices->data(),
static_cast<int>(vertices->size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
buffers[Vertices].release();
buffers[Normals].bind();
buffers[Normals].allocate(normals->data(),
static_cast<int>(normals->size()*sizeof(float)));
program->enableAttributeArray("normals");
program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
buffers[Normals].release();
buffers[Colors].bind();
buffers[Colors].allocate(colors->data(),
static_cast<int>(colors->size()*sizeof(float)));
program->enableAttributeArray("colors");
program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
buffers[Colors].release();
vaos[Facets]->release();
program->release();
}
//vao containing the data for the lines
{
program = getShaderProgram(PROGRAM_NO_SELECTION, viewer);
program->bind();
vaos[Lines]->bind();
buffers[Edges].bind();
buffers[Edges].allocate(edges->data(),
static_cast<int>(edges->size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
buffers[Edges].release();
vaos[Lines]->release();
program->release();
}
}
void FlatDrawable::draw(Transform2D& transform_2D) {
if (isHidden()){
return;
}
getMesh().prepareToBeDrawn();
getShaderProgram().use();
glm::mat3 transformation = transform_2D.getTransformationMatrix();
GLint transformation_location = getShaderProgram().getUniformLocation("transformation");
glUniformMatrix3fv(transformation_location, 1, GL_FALSE, glm::value_ptr(transformation));
getMesh().draw();
}
void DynamicBackground::initProgram()
{
std::string sharderStr = CCFileUtils::getInstance()->fullPathForFilename("Shaders/shader_dynamic_bg.fsh");
GLchar * fragSource = (GLchar*)CCString::createWithContentsOfFile(sharderStr.c_str())->getCString();
sharderStr = CCFileUtils::getInstance()->fullPathForFilename("Shaders/shader_very_pos_color.vsh");
GLchar * vertexSource = (GLchar*)CCString::createWithContentsOfFile(sharderStr.c_str())->getCString();
CCGLProgram* pProgram = new CCGLProgram();
pProgram->initWithVertexShaderByteArray(vertexSource, fragSource);
setShaderProgram(pProgram);
pProgram->release();
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->addAttribute(kCCAttributeNamePosition, kCCVertexAttrib_Position);
getShaderProgram()->addAttribute(kCCAttributeNameColor, kCCVertexAttrib_Color);
getShaderProgram()->addAttribute(kCCAttributeNameTexCoord, kCCVertexAttrib_TexCoords);
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->link();
CHECK_GL_ERROR_DEBUG();
getShaderProgram()->updateUniforms();
CHECK_GL_ERROR_DEBUG();
_bgLocation = glGetUniformLocation(getShaderProgram()->getProgram(), "u_bg_texture");
_bgSize = glGetUniformLocation(getShaderProgram()->getProgram(), "u_bg_size");
_bgTextureCoordOffset = glGetUniformLocation(getShaderProgram()->getProgram(), "u_bg_CoordOffset");
CHECK_GL_ERROR_DEBUG();
}
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 Scene_plane_item::initialize_buffers(Viewer_interface *viewer) const
{
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT, viewer);
program->bind();
vaos[0]->bind();
buffers[0].bind();
buffers[0].allocate(positions_quad.data(),
static_cast<int>(positions_quad.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex",GL_FLOAT,0,3);
buffers[0].release();
vaos[0]->release();
vaos[1]->bind();
buffers[1].bind();
buffers[1].allocate(positions_lines.data(),
static_cast<int>(positions_lines.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex",GL_FLOAT,0,3);
buffers[1].release();
vaos[1]->release();
program->release();
are_buffers_filled = true;
}
void EdgeDetectionSprite::setCustomUniforms()
{
_resolution[0] = getTexture()->getContentSizeInPixels().width;
_resolution[1] = getTexture()->getContentSizeInPixels().height;
getShaderProgram()->setUniformLocationWith2fv(_resolutionLoc, _resolution, 1);
}
KDbool CCAtlasNode::initWithTexture ( CCTexture2D* pTexture, KDuint uTileWidth, KDuint uTileHeight, KDuint uItemsToRender )
{
m_uItemWidth = uTileWidth;
m_uItemHeight = uTileHeight;
m_tColorUnmodified = ccWHITE;
m_bIsOpacityModifyRGB = KD_TRUE;
m_tBlendFunc.src = CC_BLEND_SRC;
m_tBlendFunc.dst = CC_BLEND_DST;
m_pTextureAtlas = new CCTextureAtlas ( );
m_pTextureAtlas->initWithTexture ( pTexture, uItemsToRender );
if ( !m_pTextureAtlas )
{
CCLOG ( "XCocos2D : Could not initialize CCAtlasNode. Invalid Texture.");
return KD_FALSE;
}
this->updateBlendFunc ( );
this->updateOpacityModifyRGB ( );
this->calculateMaxItems ( );
m_uQuadsToDraw = uItemsToRender;
// shader stuff
setShaderProgram ( CCShaderCache::sharedShaderCache ( )->programForKey ( kCCShader_PositionTexture_uColor ) );
#if defined ( USE_OPEN_GLES2 )
m_nUniformColor = glGetUniformLocation ( getShaderProgram ( )->getProgram ( ), "u_color" );
#endif
return KD_TRUE;
}
bool AtlasNode::initWithTexture(Texture2D* texture, int tileWidth, int tileHeight, int itemsToRender)
{
_itemWidth = tileWidth;
_itemHeight = tileHeight;
_colorUnmodified = Color3B::WHITE;
_isOpacityModifyRGB = true;
_blendFunc = BlendFunc::ALPHA_PREMULTIPLIED;
_textureAtlas = new TextureAtlas();
_textureAtlas->initWithTexture(texture, itemsToRender);
if (! _textureAtlas)
{
CCLOG("cocos2d: Could not initialize AtlasNode. Invalid Texture.");
return false;
}
this->updateBlendFunc();
this->updateOpacityModifyRGB();
this->calculateMaxItems();
_quadsToDraw = itemsToRender;
// shader stuff
setShaderProgram(ShaderCache::getInstance()->getProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_U_COLOR));
_uniformColor = glGetUniformLocation( getShaderProgram()->getProgram(), "u_color");
return true;
}
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);
}
bool CCAtlasNode::initWithTexture(CCTexture2D* texture, unsigned int tileWidth, unsigned int tileHeight,
unsigned int itemsToRender)
{
m_uItemWidth = tileWidth;
m_uItemHeight = tileHeight;
m_tColorUnmodified = ccWHITE;
//m_bIsOpacityModifyRGB = true;
m_tBlendFunc.src = CC_BLEND_SRC;
m_tBlendFunc.dst = CC_BLEND_DST;
m_pTextureAtlas = new CCTextureAtlas();
m_pTextureAtlas->initWithTexture(texture, itemsToRender);
if (! m_pTextureAtlas)
{
CCLOG("cocos2d: Could not initialize CCAtlasNode. Invalid Texture.");
return false;
}
this->updateBlendFunc();
this->updateOpacityModifyRGB();
this->calculateMaxItems();
m_uQuadsToDraw = itemsToRender;
// shader stuff
setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTexture_uColor));
m_nUniformColor = glGetUniformLocation( getShaderProgram()->getProgram(), "u_color");
return true;
}
