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