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