PXR_NAMESPACE_OPEN_SCOPE static void _ClearBuffer(GLenum buffer, GLint drawBuffer, const VtValue &value) { // XXX: There has to be a better way to handle the different formats. if (value.IsHolding<int>()) { glClearBufferiv(buffer, drawBuffer, &value.UncheckedGet<int>()); } else if (value.IsHolding<GfVec2i>()) { glClearBufferiv(buffer, drawBuffer, value.UncheckedGet<GfVec2i>().GetArray()); } else if (value.IsHolding<GfVec3i>()) { glClearBufferiv(buffer, drawBuffer, value.UncheckedGet<GfVec3i>().GetArray()); } else if (value.IsHolding<GfVec4i>()) { glClearBufferiv(buffer, drawBuffer, value.UncheckedGet<GfVec4i>().GetArray()); } else if (value.IsHolding<float>()) { glClearBufferfv(buffer, drawBuffer, &value.UncheckedGet<float>()); } else if (value.IsHolding<GfVec2f>()) { glClearBufferfv(buffer, drawBuffer, value.UncheckedGet<GfVec2f>().GetArray()); } else if (value.IsHolding<GfVec3f>()) { glClearBufferfv(buffer, drawBuffer, value.UncheckedGet<GfVec3f>().GetArray()); } else if (value.IsHolding<GfVec4f>()) { glClearBufferfv(buffer, drawBuffer, value.UncheckedGet<GfVec4f>().GetArray()); } else { TF_CODING_ERROR("Unsupported clear value type: %s", value.GetTypeName().c_str()); } }
void kit::PixelBuffer::clearAttachment(uint32_t attachment, glm::ivec4 clearcolor) { this->bind(); if (attachment >= this->m_colorAttachments.size()) { KIT_THROW("Cant clear attachment, index out of range."); } GLint color[4] = { clearcolor.x, clearcolor.y, clearcolor.z, clearcolor.w }; KIT_GL(glClearBufferiv(GL_COLOR, attachment, &color[0])); }
void OGLESFrameBuffer::Clear(uint32_t flags, Color const & clr, float depth, int32_t stencil) { OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance()); GLuint old_fbo = re.BindFramebuffer(); re.BindFramebuffer(fbo_); DepthStencilStateDesc const & ds_desc = re.CurDSSObj()->GetDesc(); BlendStateDesc const & blend_desc = re.CurBSObj()->GetDesc(); if (flags & CBM_Color) { if (blend_desc.color_write_mask[0] != CMASK_All) { glColorMask(true, true, true, true); } } if (flags & CBM_Depth) { if (!ds_desc.depth_write_mask) { glDepthMask(GL_TRUE); } } if (flags & CBM_Stencil) { if (!ds_desc.front_stencil_write_mask) { glStencilMaskSeparate(GL_FRONT, GL_TRUE); } if (!ds_desc.back_stencil_write_mask) { glStencilMaskSeparate(GL_BACK, GL_TRUE); } } if (glloader_GLES_VERSION_3_0()) { if (flags & CBM_Color) { if (fbo_ != 0) { for (size_t i = 0; i < clr_views_.size(); ++ i) { if (clr_views_[i]) { glClearBufferfv(GL_COLOR, static_cast<GLint>(i), &clr[0]); } } } else { glClearBufferfv(GL_COLOR, 0, &clr[0]); } } if ((flags & CBM_Depth) && (flags & CBM_Stencil)) { glClearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil); } else { if (flags & CBM_Depth) { glClearBufferfv(GL_DEPTH, 0, &depth); } else { if (flags & CBM_Stencil) { GLint s = stencil; glClearBufferiv(GL_STENCIL, 0, &s); } } } } else { GLbitfield ogl_flags = 0; if (flags & CBM_Color) { ogl_flags |= GL_COLOR_BUFFER_BIT; re.ClearColor(clr.r(), clr.g(), clr.b(), clr.a()); } if (flags & CBM_Depth) { ogl_flags |= GL_DEPTH_BUFFER_BIT; re.ClearDepth(depth); } if (flags & CBM_Stencil) { ogl_flags |= GL_STENCIL_BUFFER_BIT; re.ClearStencil(stencil); } glClear(ogl_flags); } if (flags & CBM_Color) { if (blend_desc.color_write_mask[0] != CMASK_All) { glColorMask((blend_desc.color_write_mask[0] & CMASK_Red) != 0, (blend_desc.color_write_mask[0] & CMASK_Green) != 0, (blend_desc.color_write_mask[0] & CMASK_Blue) != 0, (blend_desc.color_write_mask[0] & CMASK_Alpha) != 0); } } if (flags & CBM_Depth) { if (!ds_desc.depth_write_mask) { glDepthMask(GL_FALSE); } } if (flags & CBM_Stencil) { if (!ds_desc.front_stencil_write_mask) { glStencilMaskSeparate(GL_FRONT, GL_FALSE); } if (!ds_desc.back_stencil_write_mask) { glStencilMaskSeparate(GL_BACK, GL_FALSE); } } re.BindFramebuffer(old_fbo); }
void Framebuffer::clearBufferiv(const GLenum buffer, const GLint drawBuffer, const GLint * value) { bind(); glClearBufferiv(buffer, drawBuffer, value); }
//! glClearBufferiv wrapper. May throw. inline void clearBufferiv(GLenum const buf, GLint const drawbuffer, GLint const* value) { glClearBufferiv(buf, drawbuffer, value); checkError("glClearBufferiv"); }
void display() { glEnable(GL_DEPTH_TEST); glDepthMask(true); // Update of the uniform buffer { glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::UNIFORM_UPDATE_EACH_FRAME]); UPDATE_EACH_FRAME* uniformBufferUpdatedEachFrame = (UPDATE_EACH_FRAME*)glMapBufferRange( GL_UNIFORM_BUFFER, 0, sizeof(UPDATE_EACH_FRAME), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); float yScale = 1.0f / tanf( (3.14f / 4.0f) /2.0f); float xScale = yScale / (Window.Size.x / Window.Size.y); float zNear = 1.0f; float zFar = 500.0f; //glm::mat4 Projection = glm::perspectiveFov(45.f, (float)Window.Size.x, (float)Window.Size.y, zNear, zFar); glm::mat4 Projection; Projection[0] = glm::vec4(xScale, 0.0f, 0.0f, 0.0f); Projection[1] = glm::vec4(0.0f, yScale, 0.0f, 0.0f); Projection[2] = glm::vec4(0.0f, 0.0f, zFar/(zNear-zFar), -1.0f); Projection[3] = glm::vec4(0.0f, 0.0f, -zNear*zFar/(zFar-zNear), 0.0f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 ModelRotate = glm::rotate(glm::mat4(1.0f), rotateModel, glm::vec3(0.0f,1.0f,0.0f)); glm::mat4 Model = ModelRotate; rotateModel += 0.001f; uniformBufferUpdatedEachFrame->mMtoS = Projection * View * Model; // Make sure the uniform buffer is uploaded glUnmapBuffer(GL_UNIFORM_BUFFER); } glViewportIndexedf(0, 0, 0, GLfloat(Window.Size.x), GLfloat(Window.Size.y)); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.7f, 0.8f, 1.0f, 1.0f)[0]); const GLfloat clearDepthValue = 1.0f; glClearBufferfv(GL_DEPTH, 0, &clearDepthValue); const GLint clearStencilValue = 0; glClearBufferiv(GL_STENCIL, 0, &clearStencilValue); // Bind rendering objects glBindProgramPipeline(PipelineName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, oglTextureModelDiffuse); glBindVertexArray(VertexArrayModel); glBindBufferBase(GL_UNIFORM_BUFFER, MySemantic::uniform::UNIFORM_UPDATE_EACH_FRAME, BufferName[buffer::UNIFORM_UPDATE_EACH_FRAME]); glDrawElements(GL_TRIANGLES, sizeof(indexBuffer) / sizeof(GLushort), GL_UNSIGNED_SHORT, NULL); amd::swapBuffers(); }
void FramebufferImplementation_Legacy::clearBufferiv(const Framebuffer *fbo, const GLenum buffer, const GLint drawBuffer, const GLint * value) const { fbo->bind(GL_DRAW_FRAMEBUFFER); glClearBufferiv(buffer, drawBuffer, value); }
void Application::drawScene() { GLenum err; glViewport(0, 0, 2048, 2048); glBindFramebuffer(GL_FRAMEBUFFER, fbo); float back_color[] = { 1, 1, 1, 1 }; float zero[] = { 0.0f, 0.0f, 0.0f, -10.0f }; float one = 1.0f; int zero_int = 0; glClearBufferfv(GL_COLOR, 0, back_color); glClearBufferfv(GL_DEPTH, 0, &one); glClearBufferiv(GL_STENCIL, 0, &zero_int); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glm::mat4* transform_matrices = nullptr; GL_ERROR // ===================================================================== // ===================================================================== // == Rendering the mirror contents // ===================================================================== // ===================================================================== #define RENDER_MIRROR #ifdef RENDER_MIRROR glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 1, 1); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); GL_ERROR // Do Masking //glColorMask(0, 0, 0, 0); glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 1, 1); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); GL_ERROR // Apply the mirror glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer); transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT); transform_matrices[0] = m_projmat; transform_matrices[1] = m_viewmat; transform_matrices[2] = m_worldmat * glm::mat4( 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f ); glUnmapBuffer(GL_UNIFORM_BUFFER); drawMirror(); // Render Mirrored Triangle glDepthMask(GL_FALSE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_GREATER); glColorMask(1, 1, 1, 1); glStencilFunc(GL_EQUAL, 1, 1); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); // Apply the mirror glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer); transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT); transform_matrices[0] = m_projmat; transform_matrices[1] = m_viewmat; transform_matrices[2] = m_worldmat * glm::mat4( 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, -5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f ); glUnmapBuffer(GL_UNIFORM_BUFFER); drawTriangle(); GL_ERROR #endif // =================================================================== // =================================================================== // Render main triangle // =================================================================== // =================================================================== glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer); transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT); transform_matrices[0] = m_projmat; transform_matrices[1] = m_viewmat; transform_matrices[2] = m_worldmat * glm::mat4( 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f ); glUnmapBuffer(GL_UNIFORM_BUFFER); glDepthFunc(GL_LESS); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDisable(GL_STENCIL_TEST); drawTriangle(); GL_ERROR glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer); transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT); transform_matrices[0] = m_projmat; transform_matrices[1] = m_viewmat; transform_matrices[2] = m_worldmat; glUnmapBuffer(GL_UNIFORM_BUFFER); GL_ERROR }
void piglit_init(int argc, char **argv) { static const struct { bool color; bool stencil; bool depth; bool packed; } test_vectors[] = { { true, false, false, false }, { false, true, false, false }, { true, true, false, false }, { false, true, true, false }, { true, true, true, false }, { false, true, true, true }, { true, true, true, true }, }; static const int first[4] = { 0x01, 0x00, 0x00, 0x00 }; static const int second[4] = { 0xfe, 0x88, 0x88, 0x88 }; unsigned i; bool pass = true; piglit_require_gl_version(30); for (i = 0; i < ARRAY_SIZE(test_vectors); i++) { GLenum err; GLuint fb = generate_simple_fbo(test_vectors[i].color, test_vectors[i].stencil, test_vectors[i].depth, test_vectors[i].packed); if (fb == 0) { if (!piglit_automatic) { printf("Skipping framebuffer %s color, " "%s depth, and " "%s stencil (%s).\n", test_vectors[i].color ? "with" : "without", test_vectors[i].depth ? "with" : "without", test_vectors[i].stencil ? "with" : "without", test_vectors[i].packed ? "packed" : "separate"); } continue; } if (!piglit_automatic) { printf("Trying framebuffer %s color, " "%s depth and " "%s stencil (%s)...\n", test_vectors[i].color ? "with" : "without", test_vectors[i].depth ? "with" : "without", test_vectors[i].stencil ? "with" : "without", test_vectors[i].packed ? "packed" : "separate"); } /* The GL spec says nothing about generating an error for * clearing a buffer that does not exist. Certainly glClear * does not. */ glClearBufferiv(GL_STENCIL, 0, first); err = glGetError(); if (err != GL_NO_ERROR) { fprintf(stderr, "First call to glClearBufferiv erroneously " "generated a GL error (%s, 0x%04x)\n", piglit_get_gl_error_name(err), err); pass = false; } pass = simple_probe(test_vectors[i].color, default_color, test_vectors[i].stencil, first[0], test_vectors[i].depth, default_depth) && pass; glClearBufferiv(GL_STENCIL, 0, second); err = glGetError(); if (err != GL_NO_ERROR) { fprintf(stderr, "Second call to glClearBufferiv erroneously " "generated a GL error (%s, 0x%04x)\n", piglit_get_gl_error_name(err), err); pass = false; } pass = simple_probe(test_vectors[i].color, default_color, test_vectors[i].stencil, second[0], test_vectors[i].depth, default_depth) && pass; glDeleteFramebuffers(1, &fb); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; } piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }