static enum piglit_result test_copy(void)
{
/* Clear. */
glClearDepth(0);
glClear(GL_DEPTH_BUFFER_BIT);
/* Initialize buffers. */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
/* Set the upper-right corner to 0x3333 and copy the content to the lower-left one. */
piglit_draw_rect_z(-0.5, 0, 0, 1, 1);
if (test == BLIT)
glBlitFramebufferEXT(BUF_SIZE/2+1, BUF_SIZE/2+1, BUF_SIZE, BUF_SIZE,
0, 0, BUF_SIZE/2, BUF_SIZE/2,
GL_DEPTH_BUFFER_BIT, GL_NEAREST);
else
glCopyPixels(BUF_SIZE/2+1, BUF_SIZE/2+1, BUF_SIZE/2, BUF_SIZE/2, GL_DEPTH);
/* Initialize the other corners. */
piglit_draw_rect_z(-0.25, 0, -1, 1, 1);
piglit_draw_rect_z(0.25, -1, 0, 1, 1);
piglit_draw_rect_z(0.5, 0, 0, 1, 1);
glDisable(GL_DEPTH_TEST);
return compare();
}
static void create_fbo(GLuint *out_tex)
{
GLuint tex, fb;
GLenum status;
/* Create the depth-stencil buffer. */
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
BUF_WIDTH, BUF_WIDTH, 0,
GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
assert(glGetError() == 0);
/* Create the FBO. */
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT,
GL_TEXTURE_2D,
tex,
0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
piglit_report_result(PIGLIT_SKIP);
}
glViewport(0, 0, BUF_WIDTH, BUF_WIDTH);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glClearDepth(0.0);
glClear(GL_DEPTH_BUFFER_BIT);
assert(glGetError() == 0);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5f);
glUseProgram(prog);
/* Does not draw (depth texture = 1.0) */
glUniform4f(color_location, 0.0, 1.0, 0.0, 0.0);
piglit_draw_rect_z(1.0,
-1.0, -1.0, 1.0, 2.0);
/* Draws (depth texture = 0.0). */
glUniform4f(color_location, 0.0, 1.0, 0.0, 1.0);
piglit_draw_rect_z(1.0,
0.0, -1.0, 1.0, 2.0);
glDeleteFramebuffersEXT(1, &fb);
glDisable(GL_ALPHA_TEST);
glDisable(GL_DEPTH_TEST);
glUseProgram(0);
*out_tex = tex;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLuint oq[3];
GLint result[3] = {2, 2, 2};
bool pass = true;
int i;
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0);
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glGenQueries(3, oq);
glDeleteQueries(3, oq);
glColor4f(0.0, 1.0, 0.0, 0.0);
glBeginQuery(GL_ANY_SAMPLES_PASSED, oq[0]);
piglit_draw_rect_z(0.5, -1, -1, 2, 2);
glEndQuery(GL_ANY_SAMPLES_PASSED);
glBeginQuery(GL_ANY_SAMPLES_PASSED, oq[1]);
glEndQuery(GL_ANY_SAMPLES_PASSED);
glColor4f(1.0, 0.0, 0.0, 0.0);
glBeginQuery(GL_ANY_SAMPLES_PASSED, oq[2]);
piglit_draw_rect_z(0.75, -0.5, -0.5, 1.0, 1.0);
glEndQuery(GL_ANY_SAMPLES_PASSED);
piglit_present_results();
for (i = 0; i < 3; i++) {
glGetQueryObjectiv(oq[i], GL_QUERY_RESULT, &result[i]);
}
if (result[0] != GL_TRUE) {
fprintf(stderr, "GL_ANY_SAMPLES_PASSED with passed fragments returned %d\n",
result[0]);
pass = false;
}
if (result[1] != GL_FALSE) {
fprintf(stderr, "GL_ANY_SAMPLES_PASSED with no rendering returned %d\n",
result[1]);
pass = false;
}
if (result[2] != GL_FALSE) {
fprintf(stderr, "GL_ANY_SAMPLES_PASSED with occluded rendering returned %d\n",
result[2]);
pass = false;
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
/**
* Draw 4 objects and handle name stack
*/
static void
draw_objects()
{
float zscale = (float)(~0u);
glInitNames();
/* no draw call issued for name '0' */
glPushName(0);
/* OBJECT 1 */
glPushName(1);
/* draw object */
glColor3f(1.0, 0.0, 0.0);
piglit_draw_rect_z(0.8, 10, 30, 50, 50);
/* fill reference buffer */
ReferenceHitEntries[0][NAME_STACK_DEPTH] = 2;
ReferenceHitEntries[0][MIN_Z] = (GLuint)roundf(zscale * ((1 - 0.8) * 0.5));
ReferenceHitEntries[0][MAX_Z] = ReferenceHitEntries[0][MIN_Z];
ReferenceHitEntries[0][NAME_STACK_0] = 0;
ReferenceHitEntries[0][NAME_STACK_0 + 1] = 1;
/* OBJECT 2 */
/* 2 draw calls for name '2' */
glPushName(2);
glColor3f(0.0, 1.0, 0.0);
piglit_draw_rect_z(0.5, 40, 5, 25, 30);
piglit_draw_rect_z(0.4, 10, 75, 25, 10);
/* fill reference buffer */
ReferenceHitEntries[1][NAME_STACK_DEPTH] = 3;
ReferenceHitEntries[1][MIN_Z] = (GLuint)roundf(zscale * ((1 - 0.5)*0.5));
ReferenceHitEntries[1][MAX_Z] = (GLuint)roundf(zscale * ((1 - 0.4)*0.5));
ReferenceHitEntries[1][NAME_STACK_0] = 0;
ReferenceHitEntries[1][NAME_STACK_0 + 1] = 1;
ReferenceHitEntries[1][NAME_STACK_0 + 2] = 2;
/* OBJECT 3 */
glPopName();
glPushName(3);
/* drawn offscreen */
piglit_draw_rect_z(0.3, 250, 45, 280, 20);
/* OBJECT 4 */
/* glLoadName instead of glPushName */
glLoadName(4);
glColor3f(0.0, 0.0, 1.0);
piglit_draw_rect_z(0.2, 50, 45, 80, 20);
/* fill reference buffer */
ReferenceHitEntries[2][NAME_STACK_DEPTH] = 3;
ReferenceHitEntries[2][MIN_Z] = (GLuint)roundf(zscale * ((1 - 0.2)*0.5));
ReferenceHitEntries[2][MAX_Z] = ReferenceHitEntries[2][MIN_Z];
ReferenceHitEntries[2][NAME_STACK_0] = 0;
ReferenceHitEntries[2][NAME_STACK_0 + 1] = 1;
ReferenceHitEntries[2][NAME_STACK_0 + 2] = 4;
}
enum piglit_result
draw(Display *dpy, GLXFBConfig config)
{
int dbits;
float green[3] = {0.0, 1.0, 0.0};
float blue[3] = {0.0, 0.0, 1.0};
float *left, *right;
bool pass = true;
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
glXGetFBConfigAttrib(dpy, config, GLX_DEPTH_SIZE, &dbits);
piglit_ortho_projection(piglit_width, piglit_height, false);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
/* Set half the FB to depth 0, half to 1, and everything blue */
glColor3fv(blue);
piglit_draw_rect_z(1.0,
0, 0,
piglit_width / 2, piglit_height);
piglit_draw_rect_z(0.0,
piglit_width / 2, 0,
piglit_width, piglit_height);
/* Now draw a rect trying to set just the 1 values to green. */
glColor3fv(green);
glDepthFunc(GL_LESS);
piglit_draw_rect_z(0.5,
0, 0, piglit_width, piglit_height);
/* If there was a depth buffer, then we get half the window
* set to green. Otherwise, the depth test always passes
* and the whole thing should have been set green.
*/
if (dbits) {
left = blue;
right = green;
} else {
left = green;
right = green;
}
pass = pass && piglit_probe_rect_rgb(0, 0,
piglit_width / 2, piglit_height,
left);
pass = pass && piglit_probe_rect_rgb(piglit_width / 2, 0,
piglit_width - piglit_width / 2,
piglit_height,
right);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static enum piglit_result test_clear(void)
{
GLuint cb;
GLenum status;
float green[3] = {0, 1, 0};
enum piglit_result res;
/* Add a colorbuffer. */
glGenRenderbuffersEXT(1, &cb);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, cb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, BUF_SIZE, BUF_SIZE);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER_EXT, cb);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glReadBuffer(GL_COLOR_ATTACHMENT0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("FBO incomplete status 0x%X\n", status);
piglit_report_result(PIGLIT_FAIL); /* RGBA8 must succeed. */
}
glClearDepth(0.75);
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glColor3fv(green);
glDepthFunc(GL_LEQUAL);
piglit_draw_rect_z(0.499, -1, -1, 1, 2); /* 0.75 converted to clip space is 0.5. */
glDepthFunc(GL_GEQUAL);
piglit_draw_rect_z(0.501, 0, -1, 1, 2);
glColor3f(1, 1, 1);
glDisable(GL_DEPTH_TEST);
res = piglit_probe_rect_rgb(0, 0, BUF_SIZE, BUF_SIZE, green) ? PIGLIT_PASS : PIGLIT_FAIL;
/* Display the colorbuffer. */
if (!piglit_automatic) {
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBlitFramebufferEXT(0, 0, BUF_SIZE, BUF_SIZE, 0, 0, BUF_SIZE, BUF_SIZE,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
glDeleteRenderbuffersEXT(1, &cb);
return res;
}
enum piglit_result
piglit_display(void)
{
#ifdef GL_ARB_ES2_compatibility
GLboolean pass = GL_TRUE;
float red[4] = {1.0, 0.0, 0.0, 0.0};
float green[4] = {0.0, 1.0, 0.0, 0.0};
float blue[4] = {0.0, 0.0, 1.0, 0.0};
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glClearColor(0.0, 0.0, 1.0, 0.0);
glClearDepthf(0.5);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
/* Keep in mind that the ortho projection flips near and far's signs,
* so 1.0 to quad()'s z maps to glDepthRange's near, and -1.0 maps to
* glDepthRange's far.
*/
glColor4fv(green);
glDepthRangef(0, 1);
piglit_draw_rect_z(0.5,
0, 0,
piglit_width / 2, piglit_height);
glColor4fv(red);
glDepthRangef(1, 0);
piglit_draw_rect_z(0.5,
piglit_width / 2, 0,
piglit_width, piglit_height);
pass = piglit_probe_pixel_rgb(piglit_width * 1 / 4, piglit_height / 2,
green) && pass;
pass = piglit_probe_pixel_rgb(piglit_width * 3 / 4, piglit_height / 2,
blue) && pass;
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
#else
return PIGLIT_SKIP;
#endif /* GL_ARB_ES2_compatibility */
}
static enum piglit_result test_readpixels()
{
/* Clear. */
glClearDepth(0);
glClear(GL_DEPTH_BUFFER_BIT);
/* Initialize. */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
piglit_draw_rect_z(-0.5, -1, -1, 1, 1);
piglit_draw_rect_z(-0.25, 0, -1, 1, 1);
piglit_draw_rect_z(0.25, -1, 0, 1, 1);
piglit_draw_rect_z(0.5, 0, 0, 1, 1);
glDisable(GL_DEPTH_TEST);
return compare();
}
static bool
test_with_format(GLenum internal_format, const char *name)
{
GLuint rb, fb;
GLenum status;
bool pass = true;
/* Storage for the values read. The largest type is
* GLuint-sized, so this will be big enough for all types.
*/
GLuint values[BUF_WIDTH * BUF_HEIGHT];
int i;
printf("testing %s:\n", name);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
glGenRenderbuffersEXT(1, &rb);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internal_format,
BUF_WIDTH, BUF_HEIGHT);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT,
rb);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "framebuffer incomplete\n");
piglit_report_subtest_result(PIGLIT_SKIP, "%s", name);
goto done;
}
glGetIntegerv(GL_DEPTH_BITS, &depth_bits);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glViewport(0, 0, BUF_WIDTH, BUF_HEIGHT);
piglit_ortho_projection(BUF_WIDTH, BUF_HEIGHT, false);
piglit_draw_rect_z(1.0, 0, 0, w, BUF_HEIGHT);
piglit_draw_rect_z(0.0, w, 0, w * 2, BUF_HEIGHT);
piglit_draw_rect_z(-1.0, w * 2, 0, w * 3, BUF_HEIGHT);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
for (i = 0; i < ARRAY_SIZE(read_formats); i++) {
int x, y;
bool format_passed = true;
glReadPixels(0, 0, BUF_WIDTH, BUF_HEIGHT,
GL_DEPTH_COMPONENT, read_formats[i].token, values);
for (y = 0; y < BUF_HEIGHT; y++) {
for (x = 0; x < BUF_WIDTH; x++) {
if (!read_formats[i].test(x, y, values)) {
format_passed = false;
break;
}
}
if (x != BUF_WIDTH)
break;
}
piglit_report_subtest_result((format_passed ?
PIGLIT_PASS : PIGLIT_FAIL),
"%s/%s",
name,
read_formats[i].name);
pass = format_passed && pass;
}
done:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
glDeleteRenderbuffersEXT(1, &rb);
return pass;
}
void
piglit_init(int argc, char **argv)
{
int i, j;
GLenum fbstatus;
bool pass = true;
GLuint fbo[2], texture[2];
GLint program;
float depths[4] = {
0.25, 0.5, 0.75, 1.0
};
GLfloat clearDepth = 0.0;
float expected[4] = { 0.0, 0.0, 0.0, 0.0 };
program = piglit_build_simple_program(vs_source, NULL);
glUseProgram(program);
glGenFramebuffers(2, fbo);
glGenTextures(2, texture);
for(i = 0; i < 2; i++) {
glBindFramebuffer(GL_FRAMEBUFFER, fbo[i]);
glBindTexture(GL_TEXTURE_2D_ARRAY, texture[i]);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER,
GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER,
GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S,
GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T,
GL_REPEAT);
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_DEPTH_COMPONENT32,
10, 10, 4, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
for(j = 0; j < 4; j++) {
glFramebufferTextureLayer(GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
texture[i], 0, j);
fbstatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (fbstatus != GL_FRAMEBUFFER_COMPLETE){
printf("%s\n", piglit_get_gl_enum_name(fbstatus));
piglit_report_result(PIGLIT_FAIL);
}
piglit_draw_rect_z(depths[j], -1, -1, 2, 2);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
}
glDisable(GL_DEPTH_TEST);
/* Once values are set, reattach the texture
* as a layered texture to the fbo.
*/
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
texture[i], 0);
fbstatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(fbstatus != GL_FRAMEBUFFER_COMPLETE){
printf("%s\n", piglit_get_gl_enum_name(fbstatus));
piglit_report_result(PIGLIT_FAIL);
}
if(!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
}
/* Clear fbo[0] with glClear() */
glBindFramebuffer(GL_FRAMEBUFFER, fbo[0]);
glClearDepth(clearDepth);
glClear(GL_DEPTH_BUFFER_BIT);
if(!probe_texture_layered_depth(texture[0], 0, 0, 0, 10,
10, 4, expected)) {
printf("Incorrect depth values recieved with glClear()\n");
pass = false;
}
/* Clear fbo[1] with glClearBuffer() */
glBindFramebuffer(GL_FRAMEBUFFER, fbo[1]);
glClearBufferfv(GL_DEPTH, 0, &clearDepth);
if(!probe_texture_layered_depth(texture[1], 0, 0, 0, 10,
10, 4, expected)) {
printf("Incorrect depth values recieved with glClearBuffer()\n");
pass = false;
}
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
bool
do_blit_test(bool use_es2, bool from_missing_to_complete)
{
GLuint rb[3];
GLuint fb[2];
GLenum status;
GLenum err;
const unsigned src = from_missing_to_complete ? 0 : 1;
const unsigned dst = 1 - src;
const char *const names[] = {
"buffer with missing attachment",
"complete buffer"
};
bool pass = true;
printf("Testing blit from %s to %s...\n", names[src], names[dst]);
/* Create a depth-only FBO and a depth/color FBO.
*/
glGenRenderbuffers(ARRAY_SIZE(rb), rb);
glBindRenderbuffer(GL_RENDERBUFFER, rb[0]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
piglit_width, piglit_height);
glBindRenderbuffer(GL_RENDERBUFFER, rb[1]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
piglit_width, piglit_height);
glBindRenderbuffer(GL_RENDERBUFFER, rb[2]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA,
piglit_width, piglit_height);
glGenFramebuffers(ARRAY_SIZE(fb), fb);
glBindFramebuffer(GL_FRAMEBUFFER, fb[0]);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, rb[0]);
if (!use_es2) {
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
}
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb[1]);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, rb[1]);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, rb[2]);
err = glGetError();
if (err != 0) {
fprintf(stderr, "Unexpected GL error state 0x%04x\n", err);
return false;
}
/* Check completeness of the source surface.
*/
glBindFramebuffer(GL_READ_FRAMEBUFFER, fb[src]);
status = glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
fprintf(stderr, "Read FBO erroneously incomplete: 0x%04x\n",
status);
return false;
}
/* In the source surface, clear the depth buffer and draw a single
* rectangle with a constant depth value. The depth test setting here
* is correct.
*/
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb[src]);
glClearDepth(0.0);
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
piglit_draw_rect_z(0.5, -0.5, -0.5, 1.0, 1.0);
/* Check completeness of the destination surface.
*/
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb[dst]);
status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
fprintf(stderr, "Draw FBO erroneously incomplete: 0x%04x\n",
status);
return false;
}
glBlitFramebuffer(0, 0, piglit_width, piglit_height,
0, 0, piglit_width, piglit_height,
GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT,
GL_NEAREST);
err = glGetError();
if (err != 0) {
fprintf(stderr, "Unexpected GL error state 0x%04x\n", err);
return false;
}
/* Probe depth values from the destination buffer to make sure the
* depth part of the blit actually happened.
*/
glBindFramebuffer(GL_READ_FRAMEBUFFER, fb[dst]);
pass = piglit_probe_rect_depth(0.25 * piglit_width,
0.25 * piglit_height,
0.4 * piglit_width,
0.4 * piglit_height,
0.75);
pass = piglit_probe_rect_depth(0,
0,
piglit_width,
0.2 * piglit_height,
0.0)
&& pass;
glBindFramebuffer(GL_READ_FRAMEBUFFER, piglit_winsys_fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, piglit_winsys_fbo);
glDeleteFramebuffers(ARRAY_SIZE(fb), fb);
glDeleteRenderbuffers(ARRAY_SIZE(rb), rb);
return pass;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
int i, mode;
float zNear = 0.0, zFar = 1.0;
GLfloat fogcolor[4] = {1, 1, 1, 1};
glEnable(GL_FOG);
glFogfv(GL_FOG_COLOR, fogcolor);
glColor4f(0, 0, 0, 0.5);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 1, 0, 1, -zNear, -zFar);
for (mode = 0; mode < 3; mode++) {
float y = mode / 3.0;
float h = 1.0 / 3.0;
switch (mode) {
case 0:
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, zNear);
glFogf(GL_FOG_END, zFar);
break;
case 1:
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 2);
break;
case 2:
glFogi(GL_FOG_MODE, GL_EXP2);
glFogf(GL_FOG_DENSITY, 2);
break;
}
for (i = 0; i < 5; i++) {
float x = i / 5.0;
float w = 1.0 / 5.0;
float z = zNear + (zFar - zNear) * i / 5.0;
piglit_draw_rect_z(z, x, y, w, h);
}
}
for (mode = 0; mode < 3; mode++) {
float y = (mode + 0.5) / 3.0 * piglit_height;
for (i = 0; i < 5; i++) {
float x = (i + 0.5) / 5.0 * piglit_width;
float z = zNear + (zFar - zNear) * i / 5.0;
float f;
float color[4];
switch (mode) {
case 0:
f = (zFar - z) / (zFar - zNear);
break;
case 1:
f = expf(-(2.0 * z));
break;
case 2:
f = expf(-(2.0 * z) * (2.0 * z));
break;
}
if (f > 1.0)
f = 1.0;
if (f < 0.0)
f = 0.0;
color[0] = 1.0 - f;
color[1] = 1.0 - f;
color[2] = 1.0 - f;
color[3] = 0.5;
pass = pass & piglit_probe_pixel_rgba(x, y, color);
}
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
