enum piglit_result test_clearing(void) { #if 0 static const GLfloat purple[4] = {1.0, 0.0, 1.0, 1.0}; GLuint buf = GL_FRONT; GLfloat color[4], z; #endif GLfloat z; GLint stencil; GLenum err; while (glGetError() != GL_NO_ERROR) ; /* XXX this fails with NVIDIA's driver. Is this test correct?? */ #if 0 /* Color */ glClearBufferfv(GL_COLOR, buf, purple); err = glGetError(); if (err) { printf("%s: glClearBufferfv() generated error 0x%x.\n", Prog, err); return PIGLIT_FAIL; } glReadBuffer(buf); glReadPixels(20, 20, 1, 1, GL_RGBA, GL_FLOAT, color); if (color[0] != purple[0] || color[1] != purple[1] || color[2] != purple[2] || color[3] != purple[3]) { printf("%s: glClearBufferfv() failed.\n", Prog); return PIGLIT_FAIL; } #endif /* Depth & Stencil */ glClearBufferfi(GL_DEPTH_STENCIL, 0, 0.5, 3); err = glGetError(); if (err) { printf("%s: glClearBufferfi() generated error 0x%x.\n", Prog, err); return PIGLIT_FAIL; } glReadPixels(20, 20, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &z); if (fabs(z - 0.5) > 0.001) { printf("%s: glClearBufferfi() failed (z was %f, expected 0.5).\n", Prog, z); return PIGLIT_FAIL; } glReadPixels(20, 20, 1, 1, GL_STENCIL_INDEX, GL_INT, &stencil); if (stencil != 3) { printf("%s: glClearBufferfi() failed (stencil was %d, expected 3).\n", Prog, stencil); return PIGLIT_FAIL; } return PIGLIT_PASS; }
void rglClearBufferfi( GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil) { #if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3) glClearBufferfi(buffer, drawBuffer, depth, stencil); #endif }
virtual void render(double currentTime) { static const GLfloat blue[] = { 0.0f, 0.0f, 0.3f, 1.0f }; static const GLfloat one = 1.0f; vmath::mat4 proj_matrix = vmath::perspective(50.0f, (float)info.windowWidth / (float)info.windowHeight, 0.1f, 1000.0f); float f = (float)currentTime * 0.3f; vmath::mat4 mv_matrix = vmath::translate(0.0f, 0.0f, -4.0f) * vmath::translate(sinf(2.1f * f) * 0.5f, cosf(1.7f * f) * 0.5f, sinf(1.3f * f) * cosf(1.5f * f) * 2.0f) * vmath::rotate((float)currentTime * 45.0f, 0.0f, 1.0f, 0.0f) * vmath::rotate((float)currentTime * 81.0f, 1.0f, 0.0f, 0.0f); glBindFramebuffer(GL_FRAMEBUFFER, fbo); glViewport(0, 0, 512, 512); glClearBufferfv(GL_COLOR, 0, sb7::color::Green); glClearBufferfi(GL_DEPTH_STENCIL, 0, 1.0f, 0); glUseProgram(program1); glUniformMatrix4fv(proj_location, 1, GL_FALSE, proj_matrix); glUniformMatrix4fv(mv_location, 1, GL_FALSE, mv_matrix); glDrawArrays(GL_TRIANGLES, 0, 36); glBindFramebuffer(GL_FRAMEBUFFER, 0); glViewport(0, 0, info.windowWidth, info.windowHeight); glClearBufferfv(GL_COLOR, 0, blue); glClearBufferfv(GL_DEPTH, 0, &one); glBindTexture(GL_TEXTURE_2D, color_texture); glUseProgram(program2); glUniformMatrix4fv(proj_location2, 1, GL_FALSE, proj_matrix); glUniformMatrix4fv(mv_location2, 1, GL_FALSE, mv_matrix); glDrawArrays(GL_TRIANGLES, 0, 36); glBindTexture(GL_TEXTURE_2D, 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); }
enum piglit_result test_clearing(void) { static const GLfloat purple[] = {1.0, 0.0, 1.0}; static const GLfloat blue[] = {0.0, 0.0, 1.0}; static const GLfloat green[] = {0.0, 1.0, 0.0}; GLenum err; GLboolean pass = GL_TRUE; while (glGetError() != GL_NO_ERROR) ; /* Front buffer. */ glDrawBuffer(GL_FRONT); glClearBufferfv(GL_COLOR, 0, purple); err = glGetError(); if (err) { printf("%s: glClearBufferfv(GL_FRONT) generated error 0x%x.\n", Prog, err); return PIGLIT_FAIL; } glReadBuffer(GL_FRONT); if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, purple)) { printf(" from glClearBufferfv(GL_FRONT) failed.\n"); pass = GL_FALSE; } /* Back buffer. */ glDrawBuffer(GL_BACK); glClearBufferfv(GL_COLOR, 0, blue); err = glGetError(); if (err) { printf("%s: glClearBufferfv(GL_BACK) generated error 0x%x.\n", Prog, err); return PIGLIT_FAIL; } glReadBuffer(GL_BACK); if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, blue)) { printf(" from glClearBufferfv(GL_BACK) failed.\n"); pass = GL_FALSE; } /* Front and back buffer. */ glDrawBuffer(GL_FRONT_AND_BACK); glClearBufferfv(GL_COLOR, 0, green); err = glGetError(); if (err) { printf("%s: glClearBufferfv(GL_FRONT_AND_BACK) generated error 0x%x.\n", Prog, err); return PIGLIT_FAIL; } glReadBuffer(GL_FRONT); if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, green)) { printf(" the front buffer from glClearBufferfv(GL_FRONT_AND_BACK) failed.\n"); pass = GL_FALSE; } glReadBuffer(GL_BACK); if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, green)) { printf(" the back buffer from glClearBufferfv(GL_FRONT_AND_BACK) failed.\n"); pass = GL_FALSE; } /* Depth & Stencil */ glClearBufferfi(GL_DEPTH_STENCIL, 0, 0.5, 3); err = glGetError(); if (err) { printf("%s: glClearBufferfi() generated error 0x%x.\n", Prog, err); return PIGLIT_FAIL; } if (!piglit_probe_rect_depth(0, 0, piglit_width, piglit_height, 0.5)) { printf(" from glClearBufferfi() failed.\n"); pass = GL_FALSE; } if (!piglit_probe_rect_stencil(0, 0, piglit_width, piglit_height, 3)) { printf(" from glClearBufferfi() failed.\n"); pass = GL_FALSE; } return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void Framebuffer::clearBufferfi(const GLenum buffer, const GLint drawBuffer, const GLfloat depth, const GLint stencil) { bind(); glClearBufferfi(buffer, drawBuffer, depth, stencil); }
//! glClearBufferfi wrapper. May throw. inline void clearBufferfi(GLenum const buf, GLint const drawbuffer, GLfloat const depth, GLint const stencil) { glClearBufferfi(buf, drawbuffer, depth, stencil); checkError("glClearBufferfi"); }
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, false, true, false }, { true, false, true, false }, { false, true, true, false }, { true, true, true, false }, { false, true, true, true }, { true, true, true, true }, }; static const int first_s = 0x01; static const int second_s = 0xfe; static const float first_d = 0.5; static const float second_d = 0.8; 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. */ glClearBufferfi(GL_DEPTH_STENCIL, 0, first_d, first_s); err = glGetError(); if (err != GL_NO_ERROR) { fprintf(stderr, "First call to glClearBufferfi 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_s, test_vectors[i].depth, first_d) && pass; glClearBufferfi(GL_DEPTH_STENCIL, 0, second_d, second_s); err = glGetError(); if (err != GL_NO_ERROR) { fprintf(stderr, "Second call to glClearBufferfi 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_s, test_vectors[i].depth, second_d) && pass; glDeleteFramebuffers(1, &fb); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; } piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void FramebufferImplementation_Legacy::clearBufferfi(const Framebuffer *fbo, const GLenum buffer, const GLint drawBuffer, const GLfloat depth, const GLint stencil) const { fbo->bind(GL_DRAW_FRAMEBUFFER); glClearBufferfi(buffer, drawBuffer, depth, stencil); }