[Piglit] [PATCH 02/17] polygonoffset: 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.
Signedoffby: Ian Romanick <ian.d.romanick at intel.com>

tests/spec/gl1.4/polygonoffset.c  318 +++++++++++++++++
1 file changed, 142 insertions(+), 176 deletions()
diff git a/tests/spec/gl1.4/polygonoffset.c b/tests/spec/gl1.4/polygonoffset.c
index e14bf05..ec44d54 100644
 a/tests/spec/gl1.4/polygonoffset.c
+++ b/tests/spec/gl1.4/polygonoffset.c
@@ 32,45 +32,39 @@
*
* Implementation of polygon offset tests.
*
 * This test verifies glPolygonOffset. It is run on every
 * OpenGLcapable 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 OpenGLcapable
+ * 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 socalled
 * \"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 socalled "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 slopedependent 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 slopedependent 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 unsignedinteger depth buffers that aren't too
 * deep (so that precision isn't an issue during coordinate
 * transformations), it should be about one leastsignificant
 * bit. For deep or floatingpoint 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 unsignedinteger depth buffers that aren't too deep (so
+ * that precision isn't an issue during coordinate transformations),
+ * it should be about one leastsignificant bit. For deep or
+ * floatingpoint 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 (floatingpoint, 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 depthbuffer formats, the
 * ideal MRD is simply the largest of the two.
+ * To insure that we get reasonable results on machines with unusual
+ * depth buffers (floatingpoint, 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 depthbuffer
+ * 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 binarysearch 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
+ * binarysearch 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 64bit
+ /* This normalization of "depth" is correct even on 64bit
* machines because GL types have machineindependent 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 slopebased offsets for
 * a quad rotated to a given angle around a given axis.
+ /* This function checks for correct slopebased 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 depthbuffer 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 depthbuffer 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 nearplane distance equal to 1.0, and take
 * the limit of the matrix elements as the farplane distance
 * goes to infinity.)
+ * To derive this matrix, start with the matrix generated by glFrustum
+ * with nearplane distance equal to 1.0, and take the limit of the
+ * matrix elements as the farplane 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 depthbuffer 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