<div class="gmail_quote">On 16 December 2011 17:03, Ian Romanick <<a href="mailto:idr@freedesktop.org">idr@freedesktop.org</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> <div class="im">On 12/16/2011 03:33 PM, Paul Berry wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> 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. </blockquote> </div> 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. </blockquote><div> </div><div>Weird. Maybe I can have a look when I'm over there on Tuesday. The only thing I can think of at the moment is that maybe the AMD implementation of polygons isn't compatible with transform feedback for some reason, and since polygons are a deprecated drawing mode, they decided that it wasn't worth getting them to work, so they just generate an error instead.</div> <div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div><div class="h5"> --- 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, </div></div> + sizeof(verts[0]),&verts[0].vertex);<div class="im"> + glVertexAttribPointer(smooth_color_index, 4, GL_FLOAT, GL_FALSE, </div> + sizeof(verts[0]),&verts[0].smooth_color);<div class="im"> + glVertexAttribPointer(flat_color_index, 4, GL_FLOAT, GL_FALSE, </div> + sizeof(verts[0]),&verts[0].flat_color);<div><div class="h5"> + 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); + </div></div> + pass = match_strips(0, 1)&& pass;<div class="im"> + + 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) { </div> + if (use_flat_color&& is_deprecated_draw_mode)<div class="im"> + warn = (!match_strips(0, 2)) || warn; + else </div> + pass = match_strips(0, 2)&& pass;<div class="im"> + } + + piglit_present_results(); + + if (!pass) + return PIGLIT_FAIL; + else if (warn) + return PIGLIT_WARN; + else + return PIGLIT_PASS; +} </div></blockquote> </blockquote></div>