[Piglit] [PATCH 02/17] polygon-offset: Assortment of coding standards fixes
Ian Romanick
idr at freedesktop.org
Tue Sep 22 08:36:27 PDT 2015
From: Ian Romanick <ian.d.romanick at intel.com>
It would be trivial it there weren't so many of them.
Signed-off-by: Ian Romanick <ian.d.romanick at intel.com>
---
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 <dorbie at sgi.com>
- * in September 2000 and Rickard E. (Rik) Faith <faith at valinux.com> in
- * October 2000.
+ * Derived in part from tests written by Angus Dorbie <dorbie at sgi.com> in
+ * September 2000 and Rickard E. (Rik) Faith <faith at valinux.com> 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
More information about the Piglit
mailing list