void MeshCommand::batchDraw() { if (_material) { for(const auto& pass: _material->_currentTechnique->_passes) { pass->bind(_m); glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount); pass->unbind(); } } else { _glProgramState->applyGLProgram(_m); // set render state applyRenderState(); // Draw glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount); } }
void BoneNode::onDraw(const cocos2d::Mat4 &transform, uint32_t flags) { getGLProgram()->use(); getGLProgram()->setUniformsForBuiltins(transform); cocos2d::GL::enableVertexAttribs(cocos2d::GL::VERTEX_ATTRIB_FLAG_POSITION | cocos2d::GL::VERTEX_ATTRIB_FLAG_COLOR); glBindBuffer(GL_ARRAY_BUFFER, 0); glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, _noMVPVertices); glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, _squareColors); cocos2d::GL::blendFunc(_blendFunc.src, _blendFunc.dst); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); #ifdef CC_STUDIO_ENABLED_VIEW glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, _noMVPVertices); glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, _squareColors); glEnable(GL_LINE_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE); glDrawArrays(GL_LINE_LOOP, 0, 4); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8); #else CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 4); #endif //CC_STUDIO_ENABLED_VIEW }
void MeshCommand::execute() { // Draw without VAO glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer); if (_material) { for(const auto& pass: _material->_currentTechnique->_passes) { pass->bind(_mv, true); glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount); pass->unbind(); } } else { // set render state _glProgramState->apply(_mv); applyRenderState(); // Draw glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount); } glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); }
void drawSolidCircle( const Vec2& center, float radius, float angle, unsigned int segments, float scaleX, float scaleY) { lazy_init(); const float coef = 2.0f * (float)M_PI/segments; GLfloat *vertices = (GLfloat*)calloc( sizeof(GLfloat)*2*(segments+2), 1); if( ! vertices ) return; for(unsigned int i = 0;i <= segments; i++) { float rads = i*coef; GLfloat j = radius * cosf(rads + angle) * scaleX + center.x; GLfloat k = radius * sinf(rads + angle) * scaleY + center.y; vertices[i*2] = j; vertices[i*2+1] = k; } vertices[(segments+1)*2] = center.x; vertices[(segments+1)*2+1] = center.y; s_shader->use(); s_shader->setUniformsForBuiltins(); s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &s_color.r, 1); GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION ); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices); glDrawArrays(GL_TRIANGLE_FAN, 0, (GLsizei) segments+1); ::free( vertices ); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,segments+1); }
void NavMeshDebugDraw::drawImplement(const cocos2d::Mat4& transform, uint32_t flags) { _program->use(); _program->setUniformsForBuiltins(transform); glBindBuffer(GL_ARRAY_BUFFER, _vbo); GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(V3F_C4F), (GLvoid *)offsetof(V3F_C4F, position)); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(V3F_C4F), (GLvoid *)offsetof(V3F_C4F, color)); if (_dirtyBuffer){ glBufferData(GL_ARRAY_BUFFER, sizeof(V3F_C4F)* _vertices.size(), &_vertices[0], GL_STATIC_DRAW); _dirtyBuffer = false; } for (auto &iter : _primitiveList){ _stateBlock->setDepthWrite(iter->depthMask); if (iter->type == GL_POINTS){ //glPointSize(iter->size); } else if (iter->type == GL_LINES){ glLineWidth(iter->size); } _stateBlock->bind(); glDrawArrays(iter->type, iter->start, iter->end - iter->start); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, iter->end - iter->start); } glBindBuffer(GL_ARRAY_BUFFER, 0); }
/** * Draw a primitive. * * @param transform Transform matrix * @param flags Flags to draw */ void ShaderTextureNode::onDraw(const Mat4 &transform, uint32_t flags) { GLfloat vertices[48] = { -1, -1, 0, 1, 1, 1, 1, 1, // Lower-Left 1, -1, 1, 1, 1, 1, 1, 1, // Lower-Right 1, 1, 1, 0, 1, 1, 1, 1, // Upper-Right -1, -1, 0, 1, 1, 1, 1, 1, // Lower-Left 1, 1, 1, 0, 1, 1, 1, 1, // Upper-Right -1, 1, 0, 0, 1, 1, 1, 1, // Upper-Left }; auto glProgramState = getGLProgramState(); glProgramState->setVertexAttribPointer("a_position", 2, GL_FLOAT, GL_FALSE, 32, vertices); glProgramState->setVertexAttribPointer("a_texCoord", 2, GL_FLOAT, GL_FALSE, 32, vertices + 2); glProgramState->setVertexAttribPointer("a_color", 4, GL_FLOAT, GL_FALSE, 32, vertices + 4); glProgramState->apply(transform); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glDisable(GL_DEPTH_TEST); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); // Alpha blending // glEnable(GL_BLEND); // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDrawArrays(GL_TRIANGLES, 0, 6); // glDisable(GL_BLEND); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 6); }
void MGRDrawNode::onDrawGLPoint(const Mat4 &transform, uint32_t flags) { auto glProgram = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_COLOR_TEXASPOINTSIZE); glProgram->use(); glProgram->setUniformsForBuiltins(transform); GL::blendFunc(_blendFunc.src, _blendFunc.dst); if (_dirtyGLPoint) { glBindBuffer(GL_ARRAY_BUFFER, _vboGLPoint); glBufferData(GL_ARRAY_BUFFER, sizeof(V2F_C4B_T2F)*_bufferCapacityGLPoint, _bufferGLPoint, GL_STREAM_DRAW); _dirtyGLPoint = false; } glBindBuffer(GL_ARRAY_BUFFER, _vboGLPoint); GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX); // vertex glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offsetof(V2F_C4B_T2F, vertices)); // color glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V2F_C4B_T2F), (GLvoid*)offsetof(V2F_C4B_T2F, colors)); // texcoord glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offsetof(V2F_C4B_T2F, texCoords)); glDrawArrays(GL_POINTS, 0, _bufferCountGLPoint); glBindBuffer(GL_ARRAY_BUFFER, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _bufferCountGLPoint); CHECK_GL_ERROR_DEBUG(); }
void MotionStreak::onDraw(const kmMat4 &transform, bool transformUpdated) { getShaderProgram()->use(); getShaderProgram()->setUniformsForBuiltins(transform); GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX ); GL::blendFunc( _blendFunc.src, _blendFunc.dst ); GL::bindTexture2D( _texture->getName() ); #ifdef EMSCRIPTEN // Size calculations from ::initWithFade setGLBufferData(_vertices, (sizeof(Vertex2F) * _maxPoints * 2), 0); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, 0); setGLBufferData(_texCoords, (sizeof(Tex2F) * _maxPoints * 2), 1); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, 0, 0); setGLBufferData(_colorPointer, (sizeof(GLubyte) * _maxPoints * 2 * 4), 2); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); #else glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, _vertices); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, 0, _texCoords); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, _colorPointer); #endif // EMSCRIPTEN glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)_nuPoints*2); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _nuPoints*2); }
void DrawTextureScene::onDraw(){ Director::getInstance()->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW); Director::getInstance()->loadIdentityMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW); Director::getInstance()->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION); Director::getInstance()->loadIdentityMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION); auto glProgram=getGLProgram(); glProgram->use(); //更新CC_MVPMatrix glProgram->setUniformsForBuiltins(); GLuint textureLocation = glGetUniformLocation(glProgram->getProgram(), "CC_Texture0"); // Set our sampler to user Texture Unit 0 glUniform1i(textureLocation, 0); // GLuint uColorLocation = glGetUniformLocation(glProgram->getProgram(), "u_color"); // GLfloat uColor[]={1.0,1.0,1.0,1.0}; // glUniform4fv(uColorLocation, 1, uColor); glBindVertexArray(vao); //在调用draw call之前,我们需要绑定纹理 GL::bindTexture2D(textureID);//activeTexture(GL_TEXTURE0); //glBindTexture(GL_TEXTURE_2D, textureID); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, (GLvoid*)0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 6); CHECK_GL_ERROR_DEBUG(); Director::getInstance()->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION); Director::getInstance()->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW); }
void RawStencilBufferTest::onBeforeDrawSprite(int planeIndex, const Vec2& pt) { this->setupStencilForDrawingOnPlane(planeIndex); CHECK_GL_ERROR_DEBUG(); Vec2 vertices[] = { Vec2::ZERO, Vec2(pt.x, 0), pt, Vec2(0, pt.y) }; auto glProgram = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_U_COLOR); int colorLocation = glProgram->getUniformLocation("u_color"); CHECK_GL_ERROR_DEBUG(); Color4F color = _planeColor[planeIndex]; glProgram->use(); glProgram->setUniformsForBuiltins(); glProgram->setUniformLocationWith4fv(colorLocation, (GLfloat*) &color.r, 1); GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION ); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 4); }
void ShaderSprite::onDraw(const kmMat4 &transform, bool transformUpdated) { auto shader = getShaderProgram(); shader->use(); shader->setUniformsForBuiltins(transform); setCustomUniforms(); GL::enableVertexAttribs(cocos2d::GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX ); GL::blendFunc(_blendFunc.src, _blendFunc.dst); GL::bindTexture2D( getTexture()->getName()); // // Attributes // #define kQuadSize sizeof(_quad.bl) size_t offset = (size_t)&_quad; // vertex int diff = offsetof( V3F_C4B_T2F, vertices); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff)); // texCoods diff = offsetof( V3F_C4B_T2F, texCoords); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff)); // color diff = offsetof( V3F_C4B_T2F, colors); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff)); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 4); }
void LayerColor::onDraw(const kmMat4& transform, bool transformUpdated) { getShaderProgram()->use(); getShaderProgram()->setUniformsForBuiltins(transform); GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR ); // // Attributes // #ifdef EMSCRIPTEN setGLBufferData(_noMVPVertices, 4 * sizeof(Vertex3F), 0); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, 0); setGLBufferData(_squareColors, 4 * sizeof(Color4F), 1); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, 0); #else glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 0, _noMVPVertices); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, _squareColors); #endif // EMSCRIPTEN GL::blendFunc( _blendFunc.src, _blendFunc.dst ); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,4); }
void drawCubicBezier(const Vec2& origin, const Vec2& control1, const Vec2& control2, const Vec2& destination, unsigned int segments) { lazy_init(); Vec2* vertices = new (std::nothrow) Vec2[segments + 1]; float t = 0; for (unsigned int i = 0; i < segments; i++) { vertices[i].x = powf(1 - t, 3) * origin.x + 3.0f * powf(1 - t, 2) * t * control1.x + 3.0f * (1 - t) * t * t * control2.x + t * t * t * destination.x; vertices[i].y = powf(1 - t, 3) * origin.y + 3.0f * powf(1 - t, 2) * t * control1.y + 3.0f * (1 - t) * t * t * control2.y + t * t * t * destination.y; t += 1.0f / segments; } vertices[segments].x = destination.x; vertices[segments].y = destination.y; s_shader->use(); s_shader->setUniformsForBuiltins(); s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &s_color.r, 1); GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION ); #ifdef EMSCRIPTEN setGLBufferData(vertices, (segments + 1) * sizeof(Vec2)); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, 0); #else glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices); #endif // EMSCRIPTEN glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) segments + 1); CC_SAFE_DELETE_ARRAY(vertices); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,segments+1); }
void GLESDebugDraw::DrawSolidPolygon(const b2Vec2* old_vertices, int vertexCount, const b2Color& color) { mShaderProgram->use(); mShaderProgram->setUniformsForBuiltins(); b2Vec2* vertices = new b2Vec2[vertexCount]; for( int i=0;i<vertexCount;i++) { vertices[i] = old_vertices[i]; vertices[i] *= mRatio; } mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r*0.5f, color.g*0.5f, color.b*0.5f, 0.5f); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices); glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount); mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1); glDrawArrays(GL_LINE_LOOP, 0, vertexCount); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(2,vertexCount*2); CHECK_GL_ERROR_DEBUG(); delete[] vertices; }
void GLESDebugDraw::DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color) { mShaderProgram->use(); mShaderProgram->setUniformsForBuiltins(); const float32 k_segments = 16.0f; int vertexCount=16; const float32 k_increment = 2.0f * b2_pi / k_segments; float32 theta = 0.0f; GLfloat* glVertices = new GLfloat[vertexCount*2]; for (int i = 0; i < k_segments; ++i) { b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta)); glVertices[i*2]=v.x * mRatio; glVertices[i*2+1]=v.y * mRatio; theta += k_increment; } mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, glVertices); glDrawArrays(GL_LINE_LOOP, 0, vertexCount); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,vertexCount); CHECK_GL_ERROR_DEBUG(); delete[] glVertices; }
void LayerShaderStudy00::onCustomDraw(const cocos2d::Mat4 &transform, uint32_t flags) { Size winSize = Director::getInstance()->getWinSize(); // data define GLfloat vertercies[] = { 0.0f,0.0f, winSize.width,0.0f, winSize.width*0.5f,winSize.height}; GLfloat color[] = { 1.0f,0.0f,0.0f,1.0f, 0.0f,1.0f,0.0f,1.0f, 0.0f,0.0f,1.0f,1.0f }; // gl programe use GLProgram* pGlPrograme = getGLProgram(); pGlPrograme->use(); // input params uniform-mvp pGlPrograme->setUniformsForBuiltins(); // input params attribute GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*2, vertercies); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, color); // draw glDrawArrays(GL_TRIANGLES, 0, 3); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 3); CHECK_GL_ERROR_DEBUG(); }
void MeshCommand::execute() { // set render state applyRenderState(); // Set material GL::bindTexture2D(_textureID); GL::blendFunc(_blendType.src, _blendType.dst); glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer); _glProgramState->setUniformVec4("u_color", _displayColor); if (_matrixPaletteSize && _matrixPalette) { _glProgramState->setUniformCallback("u_matrixPalette", CC_CALLBACK_2(MeshCommand::MatrixPalleteCallBack, this)); } _glProgramState->apply(_mv); if (Director::getInstance()->getRunningScene()->getLights().size() > 0) setLightUniforms(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer); // Draw glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount); //restore render state restoreRenderState(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); }
void drawPoint(const Vec2& point) { lazy_init(); Vec2 p; p.x = point.x; p.y = point.y; GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION ); s_shader->use(); s_shader->setUniformsForBuiltins(); s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &s_color.r, 1); s_shader->setUniformLocationWith1f(s_pointSizeLocation, s_pointSize); #ifdef EMSCRIPTEN setGLBufferData(&p, 8); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, 0); #else glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, &p); #endif // EMSCRIPTEN glDrawArrays(GL_POINTS, 0, 1); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,1); }
void Triangle::onDraw(const Mat4 &transform, uint32_t flags) { auto glProgram = getGLProgram(); glProgram->use(); glProgram->setUniformsForBuiltins(transform); glEnable(GL_DEPTH_TEST); GL::blendFunc(_blendFunc.src, _blendFunc.dst); if (_dirty) { glBindBuffer(GL_ARRAY_BUFFER, _vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(Vec3)*_bufferCapacity, _buffer, GL_STREAM_DRAW); _dirty = false; } if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(_vao); } GL::bindTexture2D(_textureWall->getName()); glDrawArrays(_drawMode, 0, _bufferCount); glBindBuffer(GL_ARRAY_BUFFER, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_bufferCount); glDisable(GL_DEPTH_TEST); CHECK_GL_ERROR_DEBUG(); }
void drawSolidPoly(const Vec2 *poli, unsigned int numberOfPoints, Color4F color) { lazy_init(); s_shader->use(); s_shader->setUniformsForBuiltins(); s_shader->setUniformLocationWith4fv(s_colorLocation, (GLfloat*) &color.r, 1); GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION ); // FIXME: Mac OpenGL error. arrays can't go out of scope before draw is executed Vec2* newPoli = new (std::nothrow) Vec2[numberOfPoints]; // iPhone and 32-bit machines optimization if (sizeof(Vec2) == sizeof(Vec2)) { glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, poli); } else { // Mac on 64-bit for(unsigned int i = 0; i < numberOfPoints; i++) { newPoli[i].set(poli[i].x, poli[i].y); } glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, newPoli); } glDrawArrays(GL_TRIANGLE_FAN, 0, (GLsizei) numberOfPoints); CC_SAFE_DELETE_ARRAY(newPoli); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, numberOfPoints); }
void MySprite::onDraw(const Mat4 &transform, uint32_t flags) { getGLProgram()->use(); getGLProgram()->setUniformsForBuiltins(transform); GL::blendFunc( _blendFunc.src, _blendFunc.dst ); GL::bindTexture2D( _texture->getName() ); GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX ); #define kQuadSize sizeof(_quad.bl) size_t offset = (size_t)&_quad; // vertex int diff = offsetof( V3F_C4B_T2F, vertices); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff)); // texCoods diff = offsetof( V3F_C4B_T2F, texCoords); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff)); // color diff = offsetof( V3F_C4B_T2F, colors); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff)); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); CHECK_GL_ERROR_DEBUG(); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,4); }
void LHDrawNode::onDraw(const Mat4 &transform, uint32_t flags) { if(_texture) { GL::blendFunc(_blendFunc.src, _blendFunc.dst); GL::bindTexture2D(_texture->getName()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX); } else{ GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION | GL::VERTEX_ATTRIB_FLAG_COLOR); } if(_glProgram){ _glProgram->use(); _glProgram->setUniformsForBuiltins(transform); } glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(cocos2d::Point), _trianglePoints); glVertexAttribPointer(1, 4, GL_FLOAT, GL_TRUE, sizeof(cocos2d::Color4F), _colors); if(_texture){ glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(cocos2d::Point), _uvPoints); } glDrawArrays(GL_TRIANGLES, 0, _numberOfTriangles*3); glBindBuffer(GL_ARRAY_BUFFER, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_numberOfTriangles*3); CHECK_GL_ERROR_DEBUG(); }
void LayerRadialGradient::onDraw(const Mat4& transform, uint32_t /*flags*/) { auto program = getGLProgram(); program->use(); program->setUniformsForBuiltins(transform); program->setUniformLocationWith4f(_uniformLocationStartColor, _startColorRend.r, _startColorRend.g, _startColorRend.b, _startColorRend.a); program->setUniformLocationWith4f(_uniformLocationEndColor, _endColorRend.r, _endColorRend.g, _endColorRend.b, _endColorRend.a); program->setUniformLocationWith2f(_uniformLocationCenter, _center.x, _center.y); program->setUniformLocationWith1f(_uniformLocationRadius, _radius); program->setUniformLocationWith1f(_uniformLocationExpand, _expand); GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION); // // Attributes // glBindBuffer(GL_ARRAY_BUFFER, 0); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, _vertices); GL::blendFunc(_blendFunc.src, _blendFunc.dst); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,4); }
void Skybox::onDraw(const Mat4& transform, uint32_t flags) { auto camera = Camera::getVisitingCamera(); Mat4 cameraModelMat = camera->getNodeToWorldTransform(); auto state = getGLProgramState(); state->apply(transform); Vec4 color(_displayedColor.r / 255.f, _displayedColor.g / 255.f, _displayedColor.b / 255.f, 1.f); state->setUniformVec4("u_color", color); cameraModelMat.m[12] = cameraModelMat.m[13] = cameraModelMat.m[14] = 0; state->setUniformMat4("u_cameraRot", cameraModelMat); glEnable(GL_DEPTH_TEST); StateBlock::_defaultState->setDepthTest(true); glDepthFunc(GL_LEQUAL); StateBlock::_defaultState->setDepthFunction(DEPTH_LEQUAL); glEnable(GL_CULL_FACE); StateBlock::_defaultState->setCullFace(true); glCullFace(GL_BACK); StateBlock::_defaultState->setCullFaceSide(CULL_FACE_SIDE_BACK); glDisable(GL_BLEND); StateBlock::_defaultState->setBlend(false); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(_vao); } else { GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION); glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vec3), nullptr); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer); } glDrawElements(GL_TRIANGLES, (GLsizei)36, GL_UNSIGNED_BYTE, nullptr); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(0); } else { glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8); CHECK_GL_ERROR_DEBUG(); }
void CameraBackgroundSkyBoxBrush::drawBackground(Camera* camera) { Mat4 cameraModelMat = camera->getNodeToWorldTransform(); _glProgramState->apply(Mat4::IDENTITY); Vec4 color(1.f, 1.f, 1.f, 1.f); _glProgramState->setUniformVec4("u_color", color); cameraModelMat.m[12] = cameraModelMat.m[13] = cameraModelMat.m[14] = 0; _glProgramState->setUniformMat4("u_cameraRot", cameraModelMat); glEnable(GL_DEPTH_TEST); StateBlock::_defaultState->setDepthTest(true); glDepthMask(GL_TRUE); StateBlock::_defaultState->setDepthWrite(true); glDepthFunc(GL_ALWAYS); StateBlock::_defaultState->setDepthFunction(DEPTH_ALWAYS); glEnable(GL_CULL_FACE); StateBlock::_defaultState->setCullFace(true); glCullFace(GL_BACK); StateBlock::_defaultState->setCullFaceSide(CULL_FACE_SIDE_BACK); glDisable(GL_BLEND); StateBlock::_defaultState->setBlend(false); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(_vao); } else { GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION); glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer); glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vec3), nullptr); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer); } glDrawElements(GL_TRIANGLES, (GLsizei)36, GL_UNSIGNED_BYTE, nullptr); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(0); } else { glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8); CHECK_GL_ERROR_DEBUG(); }
void BattleLowNode::onDraw(const cocos2d::Mat4 &transform, uint32_t flags) { auto glProgram = _programState->getGLProgram(); glProgram->use(); // auto loc = glProgram->getUniformLocation("u_color"); // glProgram->setUniformLocationWith4fv(loc, &_color.r, 1); // loc = glProgram->getUniformLocation("u_factor"); // glProgram->setUniformLocationWith1f(loc, _factor); // loc = glProgram->getUniformLocation("u_texture_shadow"); // glProgram->setUniformLocationWith1i(loc, 1); // loc = glProgram->getUniformLocation("u_light_color"); // glProgram->setUniformLocationWith3fv(loc, &_lightColor.r, 1); // loc = glProgram->getUniformLocation("u_light_direction"); // glProgram->setUniformLocationWith3fv(loc, &_lightDirection.x, 1); // loc = glProgram->getUniformLocation("u_speed"); // glProgram->setUniformLocationWith1f(loc, _speed*25); // GL::bindTexture2DN(1, _textureShadow->getName()); auto loc = glProgram->getUniformLocation("u_texture_fieldbg"); glProgram->setUniformLocationWith1i(loc, 0); GL::bindTexture2DN(0, _textureFieldBg->getName()); loc = glProgram->getUniformLocation("u_texture_buildingbg"); glProgram->setUniformLocationWith1i(loc, 1); GL::bindTexture2DN(1, _textureBuildingBg->getName()); glProgram->setUniformsForBuiltins(transform); glBindBuffer(GL_ARRAY_BUFFER, _vbo); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(_vao); } else { // TODO } glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); /*2D的,都在同一Z位置,开启depth test会导致后画的不再绘制。 glEnable(GL_DEPTH_TEST); glDepthMask(true); */ glDrawArrays(GL_TRIANGLES, 0, 6); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(0); } glBindBuffer(GL_ARRAY_BUFFER, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,6); CHECK_GL_ERROR_DEBUG(); }
void SimplePixelNode::onDraw(const cocos2d::Mat4 &transform, uint32_t flags) { auto glProgram = _programState->getGLProgram(); glProgram->use(); glProgram->setUniformsForBuiltins(transform); glBindBuffer(GL_ARRAY_BUFFER, _vbo); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(_vao); } else { // TODO } // glEnable (GL_BLEND); // glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_BLEND); glEnable(GL_CULL_FACE); // shadow cover打开depth test同时在fsh中对a为0的进行discard,以保证重合交叠处不会交叠而加深。 glEnable(GL_DEPTH_TEST); glDepthMask(true); if (_stencil) { glEnable(GL_STENCIL_TEST); // Draw floor glStencilFunc(GL_ALWAYS, 1, 0xFF); // Set any stencil to 1 glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilMask(0xFF); // Write to stencil buffer glDepthMask(GL_FALSE); // Don't write to depth buffer glClear(GL_STENCIL_BUFFER_BIT); // Clear stencil buffer (0 by default) } if (_stenciled) { glEnable(GL_STENCIL_TEST); glStencilFunc(GL_EQUAL, 1, 0xFF); // Pass test if stencil value is 1 glStencilMask(0x00); // Don't write anything to stencil buffer glDepthMask(GL_TRUE); // Write to depth buffer } glDrawArrays(GL_TRIANGLES, 0, _count); if (Configuration::getInstance()->supportsShareableVAO()) { GL::bindVAO(0); } glDisable(GL_STENCIL_TEST); glBindBuffer(GL_ARRAY_BUFFER, 0); glDisable(GL_DEPTH_TEST); glDepthMask(false); glEnable (GL_BLEND); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_count); CHECK_GL_ERROR_DEBUG(); }
void TMXLayer::onDraw(Primitive *primitive) { _texture->prepareDraw(); GL::bindTexture2D(_texture->getName()); getGLProgramState()->apply(_modelViewTransform); GL::bindVAO(0); primitive->draw(); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, primitive->getCount() * 4); }
void PrimitiveCommand::execute() const { //Set texture GL::bindTexture2D(_textureID); //set blend mode GL::blendFunc(_blendType.src, _blendType.dst); _glProgramState->apply(_mv); _primitive->draw(); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_primitive->getCount()); }
void ShaderNode::onDraw(const Mat4 &transform, uint32_t flags) { float w = SIZE_X, h = SIZE_Y; GLfloat vertices[12] = {0,0, w,0, w,h, 0,0, 0,h, w,h}; auto glProgramState = getGLProgramState(); glProgramState->setVertexAttribPointer("a_position", 2, GL_FLOAT, GL_FALSE, 0, vertices); glProgramState->apply(transform); glDrawArrays(GL_TRIANGLES, 0, 6); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,6); }