From: Ian Romanick <[email protected]> It would be trivial it there weren't so many of them.
Signed-off-by: Ian Romanick <[email protected]> --- tests/spec/gl-1.4/polygon-offset.c | 318 +++++++++++++++++-------------------- 1 file changed, 142 insertions(+), 176 deletions(-) diff --git a/tests/spec/gl-1.4/polygon-offset.c b/tests/spec/gl-1.4/polygon-offset.c index e14bf05..ec44d54 100644 --- a/tests/spec/gl-1.4/polygon-offset.c +++ b/tests/spec/gl-1.4/polygon-offset.c @@ -32,45 +32,39 @@ * * Implementation of polygon offset tests. * - * This test verifies glPolygonOffset. It is run on every - * OpenGL-capable drawing surface configuration that supports - * creation of a window, has a depth buffer, and is RGB. + * This test verifies glPolygonOffset. It is run on every OpenGL-capable + * drawing surface configuration that supports creation of a window, has a + * depth buffer, and is RGB. * - * The first subtest verifies that the OpenGL implementation is - * using a plausible value for the \"minimum resolvable - * difference\" (MRD). This is the offset in window coordinates - * that is sufficient to provide separation in depth (Z) for any - * two parallel surfaces. The subtest searches for the MRD by - * drawing two surfaces at a distance from each other and - * checking the resulting image to see if they were cleanly - * separated. The distance is then modified (using a binary - * search) until a minimum value is found. This is the so-called - * \"ideal\" MRD. Then two surfaces are drawn using - * glPolygonOffset to produce a separation that should equal one - * MRD. The depth values at corresponding points on each surface - * are subtracted to form the \"actual\" MRD. The subtest performs - * these checks twice, once close to the viewpoint and once far - * away from it, and passes if the largest of the ideal MRDs and - * the largest of the actual MRDs are nearly the same. + * The first subtest verifies that the OpenGL implementation is using a + * plausible value for the "minimum resolvable difference" (MRD). This is the + * offset in window coordinates that is sufficient to provide separation in + * depth (Z) for any two parallel surfaces. The subtest searches for the MRD + * by drawing two surfaces at a distance from each other and checking the + * resulting image to see if they were cleanly separated. The distance is + * then modified (using a binary search) until a minimum value is found. This + * is the so-called "ideal" MRD. Then two surfaces are drawn using + * glPolygonOffset to produce a separation that should equal one MRD. The + * depth values at corresponding points on each surface are subtracted to form + * the "actual" MRD. The subtest performs these checks twice, once close to + * the viewpoint and once far away from it, and passes if the largest of the + * ideal MRDs and the largest of the actual MRDs are nearly the same. * - * The second subtest verifies that the OpenGL implementation is - * producing plausible values for slope-dependent offsets. The - * OpenGL spec requires that the depth slope of a surface be - * computed by an approximation that is at least as large as - * max(abs(dz/dx),abs(dz/dy)) and no larger than - * sqrt((dz/dx)**2+(dz/dy)**2). The subtest draws a quad rotated - * by various angles along various axes, samples three points on - * the quad's surface, and computes dz/dx and dz/dy. Then it - * draws two additional quads offset by one and two times the - * depth slope, respectively. The base quad and the two new - * quads are sampled and their actual depths read from the depth - * buffer. The subtest passes if the quads are offset by amounts - * that are within one and two times the allowable range, - * respectively. + * The second subtest verifies that the OpenGL implementation is producing + * plausible values for slope-dependent offsets. The OpenGL spec requires + * that the depth slope of a surface be computed by an approximation that is + * at least as large as max(abs(dz/dx),abs(dz/dy)) and no larger than + * sqrt((dz/dx)**2+(dz/dy)**2). The subtest draws a quad rotated by various + * angles along various axes, samples three points on the quad's surface, and + * computes dz/dx and dz/dy. Then it draws two additional quads offset by one + * and two times the depth slope, respectively. The base quad and the two new + * quads are sampled and their actual depths read from the depth buffer. The + * subtest passes if the quads are offset by amounts that are within one and + * two times the allowable range, respectively. * - * Derived in part from tests written by Angus Dorbie <[email protected]> - * in September 2000 and Rickard E. (Rik) Faith <[email protected]> in - * October 2000. + * Derived in part from tests written by Angus Dorbie <[email protected]> in + * September 2000 and Rickard E. (Rik) Faith <[email protected]> in October + * 2000. * * Ported to Piglit by Laura Ekstrand. */ @@ -100,7 +94,7 @@ struct angle_axis { GLfloat axis[3]; }; -void +static void draw_quad_at_distance(GLdouble dist) { glBegin(GL_QUADS); @@ -111,22 +105,21 @@ draw_quad_at_distance(GLdouble dist) glEnd(); } -GLdouble +static GLdouble window_coord_depth(GLdouble dist) { - /* - * Assumes we're using the "far at infinity" projection matrix - * and simple viewport transformation. + /* Assumes we're using the "far at infinity" projection matrix and + * simple viewport transformation. */ return 0.5 * (dist - 2.0) / dist + 0.5; } -bool +static bool red_quad_was_drawn(void) { - float expected[] = {1.0f, 0.0f, 0.0f}; - return piglit_probe_rect_rgb_silent(0, 0, piglit_width, - piglit_height, expected); + static const float expected[] = {1.0f, 0.0f, 0.0f}; + return piglit_probe_rect_rgb_silent(0, 0, piglit_width, piglit_height, + expected); } void @@ -135,61 +128,53 @@ piglit_init(int argc, char **argv) } -void -find_ideal_mrd(GLdouble* ideal_mrd_near, GLdouble* ideal_mrd_far, - GLdouble* next_to_near, GLdouble* next_to_far) +static void +find_ideal_mrd(GLdouble *ideal_mrd_near, GLdouble *ideal_mrd_far, + GLdouble *next_to_near, GLdouble *next_to_far) { - /* - * MRD stands for Minimum Resolvable Difference, the smallest - * distance in depth that suffices to separate any two - * polygons (or a polygon and the near or far clipping - * planes). + /* MRD stands for Minimum Resolvable Difference, the smallest distance + * in depth that suffices to separate any two polygons (or a polygon + * and the near or far clipping planes). * - * This function tries to determine the "ideal" MRD for the - * current rendering context. It's expressed in window - * coordinates, because the value in model or clipping - * coordinates depends on the scale factors in the modelview - * and projection matrices and on the distances to the near - * and far clipping planes. + * This function tries to determine the "ideal" MRD for the current + * rendering context. It's expressed in window coordinates, because + * the value in model or clipping coordinates depends on the scale + * factors in the modelview and projection matrices and on the + * distances to the near and far clipping planes. * - * For simple unsigned-integer depth buffers that aren't too - * deep (so that precision isn't an issue during coordinate - * transformations), it should be about one least-significant - * bit. For deep or floating-point or compressed depth - * buffers the situation may be more complicated, so we don't - * pass or fail an implementation solely on the basis of its - * ideal MRD. + * For simple unsigned-integer depth buffers that aren't too deep (so + * that precision isn't an issue during coordinate transformations), + * it should be about one least-significant bit. For deep or + * floating-point or compressed depth buffers the situation may be + * more complicated, so we don't pass or fail an implementation solely + * on the basis of its ideal MRD. * - * There are two subtle parts of this function. The first is - * the projection matrix we use for rendering. This matrix - * places the far clip plane at infinity (so that we don't run - * into arbitrary limits during our search process). The - * second is the method used for drawing the polygon. We - * scale the x and y coords of the polygon vertices by the - * polygon's depth, so that it always occupies the full view - * frustum. This makes it easier to verify that the polygon - * was resolved completely -- we just read back the entire - * window and see if any background pixels appear. + * There are two subtle parts of this function. The first is the + * projection matrix we use for rendering. This matrix places the far + * clip plane at infinity (so that we don't run into arbitrary limits + * during our search process). The second is the method used for + * drawing the polygon. We scale the x and y coords of the polygon + * vertices by the polygon's depth, so that it always occupies the + * full view frustum. This makes it easier to verify that the polygon + * was resolved completely -- we just read back the entire window and + * see if any background pixels appear. * - * To insure that we get reasonable results on machines with - * unusual depth buffers (floating-point, or compressed), we - * determine the MRD twice, once close to the near clipping - * plane and once as far away from the eye as possible. On a - * simple integer depth buffer these two values should be - * essentially the same. For other depth-buffer formats, the - * ideal MRD is simply the largest of the two. + * To insure that we get reasonable results on machines with unusual + * depth buffers (floating-point, or compressed), we determine the MRD + * twice, once close to the near clipping plane and once as far away + * from the eye as possible. On a simple integer depth buffer these + * two values should be essentially the same. For other depth-buffer + * formats, the ideal MRD is simply the largest of the two. */ GLdouble near_dist, far_dist, half_dist; int i; - /* - * First, find a distance that is as far away as possible, yet - * a quad at that distance can be distinguished from the - * background. Start by pushing quads away from the eye until - * we find an interval where the closer quad can be resolved, - * but the farther quad cannot. Then binary-search to find - * the threshold. + /* First, find a distance that is as far away as possible, yet a quad + * at that distance can be distinguished from the background. Start + * by pushing quads away from the eye until we find an interval where + * the closer quad can be resolved, but the farther quad cannot. Then + * binary-search to find the threshold. */ glDepthFunc(GL_LESS); @@ -218,22 +203,19 @@ find_ideal_mrd(GLdouble* ideal_mrd_near, GLdouble* ideal_mrd_far, } *next_to_far = near_dist; - /* - * We can derive a resolvable difference from the value - * next_to_far, but it's not necessarily the one we want. - * Consider mapping the object coordinate range [0,1] onto the - * integer window coordinate range [0,2]. A natural way to do - * this is with a linear function, windowCoord = - * 2*objectCoord. With rounding, this maps [0,0.25) to 0, - * [0.25,0.75) to 1, and [0.75,1] to 2. Note that the - * intervals at either end are 0.25 wide, but the one in the - * middle is 0.5 wide. The difference we can derive from - * next_to_far is related to the width of the final interval. - * We want to back up just a bit so that we can get a - * (possibly much larger) difference that will work for the - * larger interval. To do this we need to find a difference - * that allows us to distinguish two quads when the more - * distant one is at distance next_to_far. + /* We can derive a resolvable difference from the value next_to_far, + * but it's not necessarily the one we want. Consider mapping the + * object coordinate range [0,1] onto the integer window coordinate + * range [0,2]. A natural way to do this is with a linear function, + * windowCoord = 2*objectCoord. With rounding, this maps [0,0.25) to + * 0, [0.25,0.75) to 1, and [0.75,1] to 2. Note that the intervals at + * either end are 0.25 wide, but the one in the middle is 0.5 wide. + * The difference we can derive from next_to_far is related to the + * width of the final interval. We want to back up just a bit so that + * we can get a (possibly much larger) difference that will work for + * the larger interval. To do this we need to find a difference that + * allows us to distinguish two quads when the more distant one is at + * distance next_to_far. */ near_dist = 1.0; @@ -260,11 +242,9 @@ find_ideal_mrd(GLdouble* ideal_mrd_near, GLdouble* ideal_mrd_far, *ideal_mrd_far = window_coord_depth(*next_to_far) - window_coord_depth(near_dist); - /* - * Now we apply a similar strategy at the near end of the - * depth range, but swapping the senses of various comparisons - * so that we approach the near clipping plane rather than the - * far. + /* Now we apply a similar strategy at the near end of the depth range, + * but swapping the senses of various comparisons so that we approach + * the near clipping plane rather than the far. */ glClearDepth(0.0); @@ -307,29 +287,26 @@ find_ideal_mrd(GLdouble* ideal_mrd_near, GLdouble* ideal_mrd_far, *ideal_mrd_near = window_coord_depth(far_dist) - window_coord_depth(*next_to_near); -} /* find_ideal_mrd */ +} -double +static double read_depth(int x, int y) { GLuint depth; - glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, - GL_UNSIGNED_INT, &depth); + glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, &depth); - /* - * This normalization of "depth" is correct even on 64-bit + /* This normalization of "depth" is correct even on 64-bit * machines because GL types have machine-independent ranges. */ return ((double) depth) / 4294967295.0; } -void -find_actual_mrd(GLdouble* next_to_near, GLdouble* next_to_far, - GLdouble* actual_mrd_near, GLdouble* actual_mrd_far) +static void +find_actual_mrd(GLdouble *next_to_near, GLdouble *next_to_far, + GLdouble *actual_mrd_near, GLdouble *actual_mrd_far) { - /* - * Here we use polygon offset to determine the - * implementation's actual MRD. + /* Here we use polygon offset to determine the implementation's actual + * MRD. */ double base_depth; @@ -337,7 +314,8 @@ find_actual_mrd(GLdouble* next_to_near, GLdouble* next_to_far, glDepthFunc(GL_ALWAYS); /* Draw a quad far away from the eye and read the depth at its - * center: */ + * center: + */ glDisable(GL_POLYGON_OFFSET_FILL); draw_quad_at_distance(*next_to_far); base_depth = read_depth(piglit_width/2, piglit_height/2); @@ -347,9 +325,8 @@ find_actual_mrd(GLdouble* next_to_near, GLdouble* next_to_far, glPolygonOffset(0.0, -1.0); draw_quad_at_distance(*next_to_far); - /* - * The difference between the depths of the two quads is the - * value the implementation is actually using for one MRD: + /* The difference between the depths of the two quads is the value the + * implementation is actually using for one MRD: */ *actual_mrd_far = base_depth - read_depth(piglit_width/2, piglit_height/2); @@ -357,15 +334,15 @@ find_actual_mrd(GLdouble* next_to_near, GLdouble* next_to_far, /* Repeat the process for a quad close to the eye: */ glDisable(GL_POLYGON_OFFSET_FILL); draw_quad_at_distance(*next_to_near); - base_depth = read_depth(piglit_width/2, piglit_height/2); + base_depth = read_depth(piglit_width / 2, piglit_height / 2); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(0.0, 1.0); /* 1 MRD further away */ draw_quad_at_distance(*next_to_near); - *actual_mrd_near = read_depth(piglit_width/2, piglit_height/2) + *actual_mrd_near = read_depth(piglit_width / 2, piglit_height / 2) - base_depth; -} /* find_actual_mrd */ +} -void +static void draw_2x2_quad(void) { glBegin(GL_QUADS); @@ -376,12 +353,11 @@ draw_2x2_quad(void) glEnd(); } -bool -check_slope_offset(struct angle_axis* aa, GLdouble* ideal_mrd_near) +static bool +check_slope_offset(const struct angle_axis *aa, GLdouble *ideal_mrd_near) { - /* - * This function checks for correct slope-based offsets for - * a quad rotated to a given angle around a given axis. + /* This function checks for correct slope-based offsets for a quad + * rotated to a given angle around a given axis. * * The basic strategy is to: * Draw the quad. (Note: the quad's size and position @@ -403,7 +379,6 @@ check_slope_offset(struct angle_axis* aa, GLdouble* ideal_mrd_near) * (This verifies that the implementation is scaling * the depth offset correctly.) */ - const GLfloat quad_dist = 2.5; /* must be > 1+sqrt(2) to avoid */ /* clipping by the near plane */ GLdouble modelview_mat[16]; @@ -508,23 +483,19 @@ check_slope_offset(struct angle_axis* aa, GLdouble* ideal_mrd_near) return true; } -bool +static bool check_slope_offsets(GLdouble* ideal_mrd_near) { - /* - * This function checks that the implementation is offsetting - * primitives correctly according to their depth slopes. - * (Note that it uses some values computed by find_ideal_mrd, so - * that function must be run first.) + /* This function checks that the implementation is offsetting + * primitives correctly according to their depth slopes. (Note that + * it uses some values computed by find_ideal_mrd, so that function + * must be run first.) */ - bool pass = true; - int i; + unsigned i; - /* - * Rotation angles (degrees) - * and axes for which offset will be checked + /* Rotation angles (degrees) and axes for which offset will be checked */ - struct angle_axis aa[] = { + static const struct angle_axis aa[] = { { 0, {1, 0, 0}}, {30, {1, 0, 0}}, {45, {1, 0, 0}}, @@ -547,19 +518,20 @@ check_slope_offsets(GLdouble* ideal_mrd_near) {80, {2, 1, 0}} }; - for (i = 0; pass && i < ARRAY_SIZE(aa); ++i) - pass &= check_slope_offset(aa + i, ideal_mrd_near); - - return pass; + for (i = 0; i < ARRAY_SIZE(aa); ++i) + if (!check_slope_offset(aa + i, ideal_mrd_near)) + return false; + + return true; } /* check_slope_offsets */ -void +static void log_mrd(double mrd, GLint dbits) { int bits; bits = (int)(0.5 + (pow(2.0, dbits) - 1.0) * mrd); printf("%e (nominally %i %s)\n", mrd, bits, - (bits == 1)? "bit": "bits"); + (bits == 1) ? "bit": "bits"); } /* log_mrd */ enum piglit_result @@ -572,21 +544,17 @@ piglit_display(void) bool big_enough_mrd, small_enough_mrd; GLint dbits; - /* - * The following projection matrix places the near clipping - * plane at distance 1.0, and the far clipping plane at - * infinity. This allows us to stress depth-buffer resolution - * as far away from the eye as possible, without introducing - * code that depends on the size or format of the depth - * buffer. + /* The following projection matrix places the near clipping plane at + * distance 1.0, and the far clipping plane at infinity. This allows + * us to stress depth-buffer resolution as far away from the eye as + * possible, without introducing code that depends on the size or + * format of the depth buffer. * - * (To derive this matrix, start with the matrix generated by - * glFrustum with near-plane distance equal to 1.0, and take - * the limit of the matrix elements as the far-plane distance - * goes to infinity.) + * To derive this matrix, start with the matrix generated by glFrustum + * with near-plane distance equal to 1.0, and take the limit of the + * matrix elements as the far-plane distance goes to infinity. */ - - static GLfloat near_1_far_infinity[] = { + static const GLfloat near_1_far_infinity[] = { 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0, @@ -644,18 +612,16 @@ piglit_display(void) big_enough_mrd = (actual_mrd >= 0.99 * ideal_mrd); small_enough_mrd = (actual_mrd <= 2.0 * ideal_mrd); - pass &= big_enough_mrd; - pass &= small_enough_mrd; - pass &= check_slope_offsets(&ideal_mrd_near); + pass = big_enough_mrd && small_enough_mrd && pass; + pass = check_slope_offsets(&ideal_mrd_near) && pass; /* Print the results */ - if (!big_enough_mrd) - { + if (!big_enough_mrd) { printf("\tActual MRD is too small "); printf("(may cause incorrect results)\n"); } - if (!small_enough_mrd) - { + + if (!small_enough_mrd) { printf("\tActual MRD is too large "); printf("(may waste depth-buffer range)\n\n"); } @@ -672,4 +638,4 @@ piglit_display(void) printf("\n"); return pass ? PIGLIT_PASS : PIGLIT_FAIL; -} /* piglit_display */ +} -- 2.1.0 _______________________________________________ Piglit mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/piglit
