[Piglit] [PATCH v3] Add a test of tessellation of transform feedback primitives.
Ian Romanick
idr at freedesktop.org
Fri Dec 16 17:03:59 PST 2011
On 12/16/2011 03:33 PM, Paul Berry wrote:
> According to the OpenGL 3.0 spec (section 2.15: Transform Feedback):
>
> "When quads and polygons are provided to transform feedback with a
> primitive mode of TRIANGLES, they will be tessellated and recorded
> as triangles (the order of tessellation within a primitive is
> undefined). Individual lines or triangles of a strip or fan
> primitive will be extracted and recorded separately."
>
> This test verifies the correctness of the tessellation and extraction
> from strips and fans. It does so by feeding the output of transform
> feedback back into the GL pipeline and verifying that the rendered
> image is the same.
>
> Verified using the nVidia proprietary driver for Linux. The nVidia
> driver passes all tests except "tessellation polygon flat_last",
> "tessellation quad_strip flat_last", and "tessellation quads
> flat_last". These tests fail because the order in which the driver
> tessellates polygons and quads fails to preserve the correct provoking
> vertex, leading to different results from flatshading. However, this
> is unlikely to cause problems in practice (since transform feedback is
> a new feature, and quads and polygons are deprecated), and besides,
> the spec does caution that "the order of tessellation within a
> primitive is undefined". So failures with flatshading on deprecated
> primitive types are reported as mere warnings.
I tried this on an AMD system, and I got some odd results. On all of
the polygon tests, the second time it goes into draw()
GL_INVALID_OPERATION is generated. It looks like the only difference
between the two invocations is the program used to draw. I haven't had
a chance to dig into it deeply.
> ---
>
> Note: this is a re-spin of a patch I sent out in November and failed
> to follow up on. Changes since then:
>
> - I added a "wireframe" test mode, since during development of
> transform feedback for i965, I discovered that wireframe rendering
> would be easy to get wrong.
>
> - After consulting with Ian Romanick about the tests that were failing
> on nVidia (see above) we decided that those failures should be
> reported as warnings.
>
> - I added the ability to run this test using a drawing mode of
> GL_POINTS, GL_LINES, or GL_TRIANGLES. Even though these primitive
> types don't require transform feedback to do any extra tessellation,
> it seems reasonable to run the test in these modes anyhow, just to
> make sure that transform feedback doesn't introduce any changes that
> would result in an incorrect render.
>
>
> tests/all.tests | 11 +
> .../spec/ext_transform_feedback/CMakeLists.gl.txt | 1 +
> tests/spec/ext_transform_feedback/tessellation.c | 622 ++++++++++++++++++++
> 3 files changed, 634 insertions(+), 0 deletions(-)
> create mode 100644 tests/spec/ext_transform_feedback/tessellation.c
>
> diff --git a/tests/all.tests b/tests/all.tests
> index b713de0..4b1ba49 100644
> --- a/tests/all.tests
> +++ b/tests/all.tests
> @@ -1414,6 +1414,17 @@ for drawcall in ['arrays', 'elements']:
> test_name = 'order {0} {1}'.format(drawcall, mode)
> ext_transform_feedback[test_name] = PlainExecTest(
> 'ext_transform_feedback-{0} -auto'.format(test_name))
> +for draw_mode in ['points', 'lines', 'line_loop', 'line_strip',
> + 'triangles', 'triangle_strip', 'triangle_fan',
> + 'quads', 'quad_strip', 'polygon']:
> + for shade_mode in ['monochrome', 'smooth', 'flat_first', 'flat_last', 'wireframe']:
> + if shade_mode == 'wireframe' and \
> + draw_mode in ['points', 'lines', 'line_loop', 'line_strip']:
> + continue
> + test_name = 'tessellation {0} {1}'.format(
> + draw_mode, shade_mode)
> + ext_transform_feedback[test_name] = PlainExecTest(
> + 'ext_transform_feedback-{0} -auto'.format(test_name))
>
> ext_transform_feedback['output-type float'] = PlainExecTest(['ext_transform_feedback-output-type', '-auto', 'float'])
> ext_transform_feedback['output-type float[2]'] = PlainExecTest(['ext_transform_feedback-output-type', '-auto', 'float[2]'])
> diff --git a/tests/spec/ext_transform_feedback/CMakeLists.gl.txt b/tests/spec/ext_transform_feedback/CMakeLists.gl.txt
> index 35c5dce..06dd099 100644
> --- a/tests/spec/ext_transform_feedback/CMakeLists.gl.txt
> +++ b/tests/spec/ext_transform_feedback/CMakeLists.gl.txt
> @@ -23,5 +23,6 @@ add_executable (ext_transform_feedback-interleaved interleaved.c)
> add_executable (ext_transform_feedback-separate separate.c)
> add_executable (ext_transform_feedback-output-type output-type.c)
> add_executable (ext_transform_feedback-order order.c)
> +add_executable (ext_transform_feedback-tessellation tessellation.c)
>
> # vim: ft=cmake:
> diff --git a/tests/spec/ext_transform_feedback/tessellation.c b/tests/spec/ext_transform_feedback/tessellation.c
> new file mode 100644
> index 0000000..7874354
> --- /dev/null
> +++ b/tests/spec/ext_transform_feedback/tessellation.c
> @@ -0,0 +1,622 @@
> +/*
> + * Copyright © 2011 Intel Corporation
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> + * DEALINGS IN THE SOFTWARE.
> + */
> +
> +/**
> + * \file tessellation.c
> + *
> + * Verify that transform feedback properly converts primitives of
> + * types GL_LINE_LOOP, GL_LINE_STRIP, GL_TRIANGLE_STRIP,
> + * GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, and GL_POLYGON into
> + * primitives of type GL_LINES or GL_TRIANGLES, as appropriate.
> + *
> + * According to the OpenGL 3.0 spec (section 2.15: Transform Feedback):
> + *
> + * "When quads and polygons are provided to transform feedback
> + * with a primitive mode of TRIANGLES, they will be tessellated
> + * and recorded as triangles (the order of tessellation within a
> + * primitive is undefined). Individual lines or triangles of a
> + * strip or fan primitive will be extracted and recorded
> + * separately."
> + *
> + * Although it is not stated explicitly, it is clear from context that
> + * individual lines of a LINE_LOOP primitive are also expected to be
> + * extracted and recorded separately. Also, the spec does not place
> + * any requirement on the order in which vertices are output when
> + * extracting individual lines or triangles of a strip, fan, or
> + * LINE_LOOP primitive.
> + *
> + * Because the spec allows variability in how these primitives are
> + * tessellated and extracted, we can't verify correct operation by
> + * examining the vertices themselves. However, we can check that if
> + * the transform feedback output is fed back into the GL pipeline
> + * (using GL_TRIANGLES or GL_LINES, as appropriate), the same image
> + * will be rendered.
> + *
> + * This test operates by first rendering an image without transform
> + * feedback, then rendering the same image with transform feedback,
> + * then rendering the transform feedback output. Then it checks that
> + * the 3 generated images match exactly.
> + *
> + * In addition, the test verifies that the expected number of vertices
> + * was output by transform feedback.
> + *
> + * The images are rendered using a fragment shader that attenuates the
> + * color of back-facing primitives, so that the test will verify that
> + * tesellation preserves winding order properly.
> + *
> + * The test can be run in four different coloring modes:
> + *
> + * - "monochrome", meaning that all vertices are assigned the same
> + * color. A failure in this mode means that the tessellated image
> + * did not have the correct shape.
> + *
> + * - "wireframe", meaning that all vertices are assigned the same
> + * color, but the image is drawn using
> + * glPolygonMode(GL_FRONT_AND_BACK, GL_LINE). This test only makes
> + * sense for shapes that would normally be filled (e.g. polygons).
> + * Since we don't expect a tessellated polygon to have the same
> + * appearance as the original image (since additional edges are
> + * added), in this mode we merely check that the correct number of
> + * vertices are output and that the image renders the same with
> + * transform feedback active as with transform feedback inactive.
> + *
> + * - "smooth", meaning that all vertices are assigned different
> + * colors, and the primitives are drawn with smooth interpolation.
> + * A failure in this mode means that the tessellation performed by
> + * transform feedback failed to match the tessellation performed by
> + * the GL pipeline under normal operation.
> + *
> + * - "flat_last" or "flat_first", meaning that all vertices are
> + * assigned different colors, and the primitives are flatshaded. In
> + * the "flat_last" case, they are flatshaded using the GL standard
> + * "last vertex" convention to select the provoking vertex. In the
> + * "flat_first" case, they are flatshaded using the alternative
> + * "first vertex" convention provided by GL_EXT_provoking_vertex or
> + * GL_ARB_provoking_vertex. A failure in one of these modes means
> + * that within at least one of the tessellated primitives, transform
> + * feedback failed to output the vertices in the correct order for
> + * proper flatshading.
> + *
> + * Note: the test can also be run on primitive types "points",
> + * "lines", and "triangles". Although these primitive types are not
> + * subject to tessellation, the test is still useful for verifying
> + * that correct transform feedback output is generated.
> + *
> + * Note: some OpenGL implementations do not pass the "flat_first" and
> + * "flat_last" tests when rendering quads or polygons. That is, they
> + * produce a tessellation which contains the correct vertices, but not
> + * in the order required to preserve flat shaded colors. This is
> + * unlikely to cause problems for client programs, since client
> + * programs that use new features like transform feedback are unlikely
> + * to also use deprecated features like quads and polygons. Also, it
> + * is a matter of interpretation whether these tests are expected to
> + * pass at all--after all, the spec does say that "the order of
> + * tessellation within a primitive is undefined". Accordingly, these
> + * failures, should they occur, are flagged as warnings rather than
> + * failures.
> + */
> +
> +#include "piglit-util.h"
> +
> +#define BUFFER_SIZE 20
> +
> +int piglit_width = 256;
> +int piglit_height = 256;
> +int piglit_window_mode = GLUT_DOUBLE | GLUT_RGB | GLUT_ALPHA;
> +
> +/* Test parameters */
> +static GLenum draw_mode;
> +static GLenum xfb_mode;
> +static unsigned num_input_vertices;
> +static unsigned expected_num_output_vertices;
> +static float (*vertex_positions)[2];
> +static GLboolean monochrome;
> +static GLboolean use_flat_color;
> +static GLboolean wireframe;
> +static GLboolean is_deprecated_draw_mode;
> +
> +/* Other globals */
> +static GLuint normal_prog;
> +static GLuint xfb_prog;
> +static GLuint xfb_buf;
> +static float vertex_colors[][4] = {
> + { 0.00, 0.00, 0.00, 0.00 },
> + { 1.00, 0.25, 0.25, 1.00 },
> + { 0.15, 0.37, 0.98, 1.00 },
> + { 0.50, 0.93, 0.07, 1.00 },
> + { 0.85, 0.02, 0.63, 1.00 },
> + { 0.0, 0.75, 0.75, 1.00 },
> + { 0.85, 0.63, 0.02, 1.00 },
> + { 0.5, 0.07, 0.93, 1.00 },
> + { 0.15, 0.98, 0.37, 1.00 }
> +};
> +
> +static struct vertex_data {
> + float vertex[2];
> + float smooth_color[4];
> + float flat_color[4];
> +} verts[BUFFER_SIZE];
> +
> +/* Note: vertices are chosen to be on pixel centers to minimize the
> + * risk that rounding errors change the image.
> + */
> +static float points_vertices[][2] = {
> + { 2.5, 62.5 },
> + { 62.5, 62.5 },
> + { 2.5, 2.5 },
> + { 62.5, 2.5 }
> +};
> +
> +/* Note: vertices are chosen to be on pixel centers to minimize the
> + * risk that rounding errors change the image.
> + */
> +static float lines_vertices[][2] = {
> + { 2.5, 62.5 },
> + { 62.5, 62.5 },
> + { 2.5, 2.5 },
> + { 62.5, 2.5 }
> +};
> +
> +/* Note: vertices are chosen to be on pixel centers to minimize the
> + * risk that rounding errors change the image.
> + */
> +static float line_loop_vertices[][2] = {
> + { 2.5, 2.5 },
> + { 2.5, 62.5 },
> + { 62.5, 62.5 },
> + { 62.5, 2.5 }
> +};
> +
> +/* Note: vertices are chosen to be on pixel centers to minimize the
> + * risk that rounding errors change the image.
> + */
> +static float line_strip_vertices[][2] = {
> + { 2.5, 2.5 },
> + { 2.5, 32.5 },
> + { 32.5, 32.5 },
> + { 32.5, 62.5 }
> +};
> +
> +static float triangles_vertices[][2] = {
> + { 2, 2 },
> + { 2, 62 },
> + { 42, 2 },
> + { 62, 2 },
> + { 62, 62 },
> + { 102, 2 }
> +};
> +
> +static float triangle_strip_vertices[][2] = {
> + { 2, 2 },
> + { 2, 62 },
> + { 42, 2 },
> + { 42, 62 },
> + { 82, 2 }
> +};
> +
> +static float triangle_fan_vertices[][2] = {
> + { 2, 2 },
> + { 2, 62 },
> + { 32, 47 },
> + { 52, 27 },
> + { 57, 12 }
> +};
> +
> +static float quads_vertices[][2] = {
> + { 2, 2 },
> + { 2, 62 },
> + { 62, 62 },
> + { 62, 2 },
> + { 102, 2 },
> + { 102, 62 },
> + { 162, 62 },
> + { 162, 2 }
> +};
> +
> +static float quad_strip_vertices[][2] = {
> + { 2, 2 },
> + { 2, 62 },
> + { 62, 2 },
> + { 62, 62 },
> + { 122, 2 },
> + { 122, 62 }
> +};
> +
> +static float polygon_vertices[][2] = {
> + { 12, 2 },
> + { 2, 42 },
> + { 32, 62 },
> + { 62, 42 },
> + { 52, 2 }
> +};
> +
> +static const char *vstext =
> + "#version 130\n"
> + "uniform vec2 vertex_offset;\n"
> + "in vec2 vertex;\n"
> + "in vec4 smooth_color;\n"
> + "in vec4 flat_color;\n"
> + "out vec2 vertex_varying;\n"
> + "out vec4 smooth_color_varying;\n"
> + "flat out vec4 flat_color_varying;\n"
> + "\n"
> + "void main()\n"
> + "{\n"
> + " gl_Position = vec4(vertex + vertex_offset, 0, 128.0);\n"
> + " vertex_varying = vertex;\n"
> + " smooth_color_varying = smooth_color;\n"
> + " flat_color_varying = flat_color;\n"
> + "}\n";
> +
> +static const char *fstext =
> + "#version 130\n"
> + "uniform bool use_flat_color;\n"
> + "in vec4 smooth_color_varying;\n"
> + "flat in vec4 flat_color_varying;\n"
> + "\n"
> + "void main()\n"
> + "{\n"
> + " vec4 color = use_flat_color ? flat_color_varying\n"
> + " : smooth_color_varying;\n"
> + " if (!gl_FrontFacing)\n"
> + " color *= 0.5;\n"
> + " gl_FragColor = color;\n"
> + "}\n";
> +
> +static const char *varyings[] = {
> + "vertex_varying", "smooth_color_varying", "flat_color_varying"
> +};
> +
> +static void
> +initialize_shader_and_xfb()
> +{
> + GLuint vs, fs;
> +
> + piglit_require_GLSL_version(130);
> + piglit_require_transform_feedback();
> + vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
> + fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
> + normal_prog = piglit_CreateProgram();
> + piglit_AttachShader(normal_prog, vs);
> + piglit_AttachShader(normal_prog, fs);
> + piglit_LinkProgram(normal_prog);
> + if (!piglit_link_check_status(normal_prog)) {
> + piglit_report_result(PIGLIT_FAIL);
> + }
> + xfb_prog = piglit_CreateProgram();
> + piglit_AttachShader(xfb_prog, vs);
> + piglit_AttachShader(xfb_prog, fs);
> + piglit_TransformFeedbackVaryings(xfb_prog, 3, varyings,
> + GL_INTERLEAVED_ATTRIBS);
> + piglit_LinkProgram(xfb_prog);
> + if (!piglit_link_check_status(xfb_prog)) {
> + piglit_report_result(PIGLIT_FAIL);
> + }
> + glGenBuffers(1,&xfb_buf);
> + glFrontFace(GL_CW);
> + piglit_check_gl_error(0, PIGLIT_FAIL);
> +}
> +
> +static void
> +setup_vertex_shader_inputs(GLuint prog)
> +{
> + GLint vertex_index = glGetAttribLocation(prog, "vertex");
> + GLint smooth_color_index = glGetAttribLocation(prog, "smooth_color");
> + GLint flat_color_index = glGetAttribLocation(prog, "flat_color");
> +
> + glVertexAttribPointer(vertex_index, 2, GL_FLOAT, GL_FALSE,
> + sizeof(verts[0]),&verts[0].vertex);
> + glVertexAttribPointer(smooth_color_index, 4, GL_FLOAT, GL_FALSE,
> + sizeof(verts[0]),&verts[0].smooth_color);
> + glVertexAttribPointer(flat_color_index, 4, GL_FLOAT, GL_FALSE,
> + sizeof(verts[0]),&verts[0].flat_color);
> + glEnableVertexAttribArray(vertex_index);
> + glEnableVertexAttribArray(smooth_color_index);
> + glEnableVertexAttribArray(flat_color_index);
> + piglit_check_gl_error(0, PIGLIT_FAIL);
> +}
> +
> +static void
> +initialize_vertex_shader_inputs()
> +{
> + unsigned i;
> +
> + if (monochrome) {
> + for (i = 1; i< ARRAY_SIZE(vertex_colors); ++i) {
> + vertex_colors[i][0] = 1.0;
> + vertex_colors[i][1] = 1.0;
> + vertex_colors[i][2] = 1.0;
> + vertex_colors[i][3] = 1.0;
> + }
> + }
> +
> + for (i = 0; i< num_input_vertices; ++i) {
> + memcpy(verts[i].vertex, vertex_positions[i],
> + sizeof(verts[i].vertex));
> + memcpy(verts[i].smooth_color, vertex_colors[i+1],
> + sizeof(verts[i].smooth_color));
> + memcpy(verts[i].flat_color, vertex_colors[i+1],
> + sizeof(verts[i].flat_color));
> + }
> +}
> +
> +/**
> + * Determine how many vertices were output by transform feedback by
> + * seeing which elements of the transform feedback buffer have been
> + * changed from their zero-initialized value.
> + */
> +static unsigned
> +count_output_vertices(struct vertex_data *vertices)
> +{
> + struct vertex_data zero_initialized;
> + unsigned i;
> +
> + memset(&zero_initialized, 0, sizeof(zero_initialized));
> +
> + for (i = 0; i< BUFFER_SIZE; ++i) {
> + if (memcmp(&vertices[i],&zero_initialized,
> + sizeof(zero_initialized)) == 0)
> + break;
> + }
> + return i;
> +}
> +
> +/**
> + * Check that two strips of the window match. Strips are numbered
> + * from the top from 0 to 3.
> + */
> +static GLboolean
> +match_strips(int reference, int compare)
> +{
> + GLfloat *reference_image =
> + malloc(piglit_width * (piglit_height / 4) * 4 * sizeof(float));
> + int reference_offset = (3 - reference) * (piglit_height / 4);
> + int compare_offset = (3 - compare) * (piglit_height / 4);
> + glReadPixels(0, reference_offset, piglit_width, piglit_height / 4,
> + GL_RGBA, GL_FLOAT, reference_image);
> + GLboolean result =
> + piglit_probe_image_rgba(0, compare_offset, piglit_width,
> + piglit_height / 4, reference_image);
> + free(reference_image);
> + return result;
> +}
> +
> +static void
> +draw(GLuint prog, bool use_xfb, float y_offset, GLenum mode,
> + unsigned num_vertices)
> +{
> + float vertex_offset[2] = { -82.0, y_offset };
> + struct vertex_data buffer[BUFFER_SIZE];
> +
> + piglit_UseProgram(prog);
> + setup_vertex_shader_inputs(prog);
> + piglit_Uniform2fv(piglit_GetUniformLocation(prog, "vertex_offset"),
> + 1, vertex_offset);
> + piglit_Uniform1i(piglit_GetUniformLocation(prog, "use_flat_color"),
> + use_flat_color);
> + glBindBuffer(GL_ARRAY_BUFFER, 0);
> + if (use_xfb) {
> + glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buf);
> + /* Initialize the buffer with 0 so that we will be
> + * able to identify membory that was not overwitten by
> + * the transform feedback.
> + */
> + memset(buffer, 0, sizeof(buffer));
> + glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(buffer),
> + buffer, GL_STREAM_READ);
> + piglit_BindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0,
> + xfb_buf);
> + piglit_BeginTransformFeedback(xfb_mode);
> + }
> + glDrawArrays(mode, 0, num_vertices);
> + if (use_xfb)
> + piglit_EndTransformFeedback();
> + piglit_check_gl_error(0, PIGLIT_FAIL);
> +}
> +
> +static void
> +print_usage_and_exit(char *prog_name)
> +{
> + printf("Usage: %s<draw_mode> <shade_mode>\n"
> + " where<draw_mode> is one of:\n"
> + " points\n"
> + " lines\n"
> + " line_loop\n"
> + " line_strip\n"
> + " triangles\n"
> + " triangle_strip\n"
> + " triangle_fan\n"
> + " quads\n"
> + " quad_strip\n"
> + " polygon\n"
> + " and<shade_mode> is one of:\n"
> + " monochrome\n"
> + " smooth\n"
> + " flat_first\n"
> + " flat_last\n", prog_name);
> + exit(1);
> +}
> +
> +void
> +piglit_init(int argc, char **argv)
> +{
> + /* Interpret command line args */
> + if (argc != 3)
> + print_usage_and_exit(argv[0]);
> + if (strcmp(argv[1], "points") == 0) {
> + draw_mode = GL_POINTS;
> + is_deprecated_draw_mode = GL_FALSE;
> + xfb_mode = GL_POINTS;
> + num_input_vertices = 4;
> + expected_num_output_vertices = 4;
> + vertex_positions = points_vertices;
> + } else if (strcmp(argv[1], "lines") == 0) {
> + draw_mode = GL_LINES;
> + is_deprecated_draw_mode = GL_FALSE;
> + xfb_mode = GL_LINES;
> + num_input_vertices = 4;
> + expected_num_output_vertices = 4;
> + vertex_positions = lines_vertices;
> + } else if (strcmp(argv[1], "line_loop") == 0) {
> + draw_mode = GL_LINE_LOOP;
> + is_deprecated_draw_mode = GL_FALSE;
> + xfb_mode = GL_LINES;
> + num_input_vertices = 4;
> + expected_num_output_vertices = 8;
> + vertex_positions = line_loop_vertices;
> + } else if (strcmp(argv[1], "line_strip") == 0) {
> + draw_mode = GL_LINE_STRIP;
> + is_deprecated_draw_mode = GL_FALSE;
> + xfb_mode = GL_LINES;
> + num_input_vertices = 4;
> + expected_num_output_vertices = 6;
> + vertex_positions = line_strip_vertices;
> + } else if (strcmp(argv[1], "triangles") == 0) {
> + draw_mode = GL_TRIANGLES;
> + is_deprecated_draw_mode = GL_FALSE;
> + xfb_mode = GL_TRIANGLES;
> + num_input_vertices = 6;
> + expected_num_output_vertices = 6;
> + vertex_positions = triangles_vertices;
> + } else if (strcmp(argv[1], "triangle_strip") == 0) {
> + draw_mode = GL_TRIANGLE_STRIP;
> + is_deprecated_draw_mode = GL_FALSE;
> + xfb_mode = GL_TRIANGLES;
> + num_input_vertices = 5;
> + expected_num_output_vertices = 9;
> + vertex_positions = triangle_strip_vertices;
> + } else if (strcmp(argv[1], "triangle_fan") == 0) {
> + draw_mode = GL_TRIANGLE_FAN;
> + is_deprecated_draw_mode = GL_FALSE;
> + xfb_mode = GL_TRIANGLES;
> + num_input_vertices = 5;
> + expected_num_output_vertices = 9;
> + vertex_positions = triangle_fan_vertices;
> + } else if (strcmp(argv[1], "quads") == 0) {
> + draw_mode = GL_QUADS;
> + is_deprecated_draw_mode = GL_TRUE;
> + xfb_mode = GL_TRIANGLES;
> + num_input_vertices = 8;
> + expected_num_output_vertices = 12;
> + vertex_positions = quads_vertices;
> + } else if (strcmp(argv[1], "quad_strip") == 0) {
> + draw_mode = GL_QUAD_STRIP;
> + is_deprecated_draw_mode = GL_TRUE;
> + xfb_mode = GL_TRIANGLES;
> + num_input_vertices = 6;
> + expected_num_output_vertices = 12;
> + vertex_positions = quad_strip_vertices;
> + } else if (strcmp(argv[1], "polygon") == 0) {
> + draw_mode = GL_POLYGON;
> + is_deprecated_draw_mode = GL_TRUE;
> + xfb_mode = GL_TRIANGLES;
> + num_input_vertices = 5;
> + expected_num_output_vertices = 9;
> + vertex_positions = polygon_vertices;
> + } else {
> + print_usage_and_exit(argv[0]);
> + }
> + if (strcmp(argv[2], "monochrome") == 0) {
> + monochrome = GL_TRUE;
> + use_flat_color = GL_FALSE;
> + wireframe = GL_FALSE;
> + } else if (strcmp(argv[2], "smooth") == 0) {
> + monochrome = GL_FALSE;
> + use_flat_color = GL_FALSE;
> + wireframe = GL_FALSE;
> + } else if (strcmp(argv[2], "flat_last") == 0) {
> + monochrome = GL_FALSE;
> + use_flat_color = GL_TRUE;
> + wireframe = GL_FALSE;
> + } else if (strcmp(argv[2], "flat_first") == 0) {
> + monochrome = GL_FALSE;
> + use_flat_color = GL_TRUE;
> + if (piglit_is_extension_supported("GL_EXT_provoking_vertex")) {
> + glProvokingVertexEXT(GL_FIRST_VERTEX_CONVENTION);
> + } else if (piglit_is_extension_supported("GL_ARB_provoking_vertex")) {
> + glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);
> + } else {
> + printf("Test requires GL_EXT_provoking_vertex "
> + "or GL_ARB_provoking_vertex\n");
> + piglit_report_result(PIGLIT_SKIP);
> + }
> + wireframe = GL_FALSE;
> + } else if (strcmp(argv[2], "wireframe") == 0) {
> + monochrome = GL_TRUE;
> + use_flat_color = GL_FALSE;
> + wireframe = GL_TRUE;
> + } else {
> + print_usage_and_exit(argv[0]);
> + }
> +
> + initialize_shader_and_xfb();
> +}
> +
> +enum piglit_result piglit_display(void)
> +{
> + struct vertex_data *readback;
> + unsigned num_output_vertices;
> + GLboolean pass = GL_TRUE;
> + GLboolean warn = GL_FALSE;
> +
> + initialize_vertex_shader_inputs();
> +
> + glClear(GL_COLOR_BUFFER_BIT);
> + if (wireframe)
> + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
> + draw(normal_prog, false, 64.0, draw_mode, num_input_vertices);
> + draw(xfb_prog, true, 0.0, draw_mode, num_input_vertices);
> +
> + pass = match_strips(0, 1)&& pass;
> +
> + readback = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
> + piglit_check_gl_error(0, PIGLIT_FAIL);
> +
> + num_output_vertices = count_output_vertices(readback);
> + if (num_output_vertices != expected_num_output_vertices) {
> + printf("Expected %u output vertices, but got %u\n",
> + expected_num_output_vertices, num_output_vertices);
> + pass = GL_FALSE;
> + }
> +
> + memcpy(verts, readback, sizeof(verts));
> + glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
> +
> + draw(normal_prog, false, -64.0, xfb_mode, num_output_vertices);
> +
> + if (!wireframe) {
> + if (use_flat_color&& is_deprecated_draw_mode)
> + warn = (!match_strips(0, 2)) || warn;
> + else
> + pass = match_strips(0, 2)&& pass;
> + }
> +
> + piglit_present_results();
> +
> + if (!pass)
> + return PIGLIT_FAIL;
> + else if (warn)
> + return PIGLIT_WARN;
> + else
> + return PIGLIT_PASS;
> +}
More information about the Piglit
mailing list