polygon-offset: Assortment of coding standards fixes

It would be trivial it there weren't so many of them.

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
Reviewed-by: Matt Turner <mattst88@gmail.com>
Thanked-by: Kristian Høgsberg <krh@bitplanet.net>

1 files 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 e14bf0535..ec44d5429 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@sgi.com>
- * in September 2000 and Rickard E. (Rik) Faith <faith@valinux.com> in
- * October 2000.
+ * Derived in part from tests written by Angus Dorbie <dorbie@sgi.com> in
+ * September 2000 and Rickard E. (Rik) Faith <faith@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 */
+}