Ping I guess?
On Mon, May 7, 2018 at 5:19 PM, Rhys Perry <pendingchao...@gmail.com> wrote: > Changelog: > v2: > - Rebase to handle meta profiles. > > --- > tests/opengl.py | 6 + > tests/quick_gl.py | 7 + > tests/spec/CMakeLists.txt | 1 + > tests/spec/arb_sample_locations/CMakeLists.gl.txt | 11 + > tests/spec/arb_sample_locations/CMakeLists.txt | 1 + > tests/spec/arb_sample_locations/test.c | 290 > ++++++++++++++++++++++ > 6 files changed, 316 insertions(+) > create mode 100644 tests/spec/arb_sample_locations/CMakeLists.gl.txt > create mode 100644 tests/spec/arb_sample_locations/CMakeLists.txt > create mode 100644 tests/spec/arb_sample_locations/test.c > > diff --git a/tests/opengl.py b/tests/opengl.py > index 825e0bf83..46b26b2ac 100644 > --- a/tests/opengl.py > +++ b/tests/opengl.py > @@ -4840,5 +4840,11 @@ with profile.test_list.group_manager( > g(['arb_bindless_texture-uint64_attribs'], 'uint64_attribs') > g(['arb_bindless_texture-uniform'], 'uniform') > > +# Group ARB_sample_locations > +with profile.test_list.group_manager( > + PiglitGLTest, > + grouptools.join('spec', 'ARB_sample_locations')) as g: > + g(['arb_sample_locations'], 'test') > + > if platform.system() is 'Windows': > profile.filters.append(lambda p, _: not p.startswith('glx')) > diff --git a/tests/quick_gl.py b/tests/quick_gl.py > index c6501904c..1f5d4d960 100644 > --- a/tests/quick_gl.py > +++ b/tests/quick_gl.py > @@ -60,6 +60,13 @@ with profile.test_list.group_manager( > with profile.test_list.allow_reassignment: > g(['gl-1.0-blend-func', '--quick'], 'gl-1.0-blend-func') > > +# Set the --quick flag on the GL_ARB_sample_locations test > +with profile.test_list.group_manager( > + PiglitGLTest, > + grouptools.join('spec', 'arb_sample_locations')) as g: > + with profile.test_list.allow_reassignment: > + g(['arb_sample_locations', '--quick'], 'test') > + > # Limit texture size to 512x512 for some texture_multisample tests. > # The default (max supported size) can be pretty slow. > with profile.test_list.group_manager( > diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt > index 405d35a53..941e56805 100644 > --- a/tests/spec/CMakeLists.txt > +++ b/tests/spec/CMakeLists.txt > @@ -45,6 +45,7 @@ add_subdirectory (arb_point_parameters) > add_subdirectory (arb_point_sprite) > add_subdirectory (arb_provoking_vertex) > add_subdirectory (arb_robustness) > +add_subdirectory (arb_sample_locations) > add_subdirectory (arb_sample_shading) > add_subdirectory (arb_sampler_objects) > add_subdirectory (arb_seamless_cube_map) > diff --git a/tests/spec/arb_sample_locations/CMakeLists.gl.txt > b/tests/spec/arb_sample_locations/CMakeLists.gl.txt > new file mode 100644 > index 000000000..c4652699f > --- /dev/null > +++ b/tests/spec/arb_sample_locations/CMakeLists.gl.txt > @@ -0,0 +1,11 @@ > +include_directories( > + ${GLEXT_INCLUDE_DIR} > + ${OPENGL_INCLUDE_PATH} > +) > + > +link_libraries ( > + piglitutil_${piglit_target_api} > + ${OPENGL_gl_LIBRARY} > +) > + > +piglit_add_executable (arb_sample_locations test.c) > diff --git a/tests/spec/arb_sample_locations/CMakeLists.txt > b/tests/spec/arb_sample_locations/CMakeLists.txt > new file mode 100644 > index 000000000..144a306f4 > --- /dev/null > +++ b/tests/spec/arb_sample_locations/CMakeLists.txt > @@ -0,0 +1 @@ > +piglit_include_target_api() > diff --git a/tests/spec/arb_sample_locations/test.c > b/tests/spec/arb_sample_locations/test.c > new file mode 100644 > index 000000000..f83b17894 > --- /dev/null > +++ b/tests/spec/arb_sample_locations/test.c > @@ -0,0 +1,290 @@ > +#include "piglit-util-gl.h" > + > +/** > + * @file test.c > + * > + * This test verifies that GL_ARB_sample_locations is implemented correctly. > + * It does so by retrieving the sample positions using gl_SamplePosition, > + * interpolateAtSample() and a method described in > + * https://mynameismjp.wordpress.com/2010/07/07/msaa-sample-pattern-detector/ > + * which draws a rectangle covering each possible sample location within a > pixel. > + * Each rectangle writes it's position within the pixel, which is then read > + * through a shader. > + * > + * The retrieved sample locations are then tested against expectations. This > is > + * done with various MSAA levels and sample locations. > + * > + * The test can be rather slow by default, but it can be made less > exhaustive by > + * passing the argument --quick. > + * > + * Sample locations are typically represented in this test as 0.4 fixed point > + * integers where 0 is the top. > + */ > + > +/* new_locations in do_test_set() needs to be expanded when this is */ > +#define LOG2_MAX_SAMPLES 5 > +#define MAX_SAMPLES (1<<LOG2_MAX_SAMPLES) > + > +#define WIDTH 4 > +/* the height is 7 pixels to test pixel grid flipping */ > +#define HEIGHT 7 > + > +PIGLIT_GL_TEST_CONFIG_BEGIN > + > + config.supports_gl_core_version = 32; > + > + config.window_width = 200; > + config.window_height = 200; > + config.window_visual = PIGLIT_GL_VISUAL_RGB; > + > +PIGLIT_GL_TEST_CONFIG_END > + > +static bool quick; > + > +static GLuint draw_program; > +static GLuint read_program; > +static GLuint fb_textures[LOG2_MAX_SAMPLES+1]; > +static GLuint fbs[LOG2_MAX_SAMPLES+1]; > + > +static unsigned cur_fb; > +static GLint grid_width, grid_height, samples; > + > +static void > +get_sample_locations(GLubyte *locations, unsigned count, > + unsigned pixel_x, unsigned pixel_y) > +{ > + glViewport(pixel_x, pixel_y, 1, 1); > + glBindFramebuffer(GL_FRAMEBUFFER, fbs[cur_fb]); > + glClearColor(1.0, 1.0, 1.0, 1.0); > + glClear(GL_COLOR_BUFFER_BIT); > + glUseProgram(draw_program); > + for (int x = 0; x < 16; x++) { > + for (int y = 0; y < 16; y++) { > + float left = x/16.0 - (1.0/32.0); > + float bottom = (16-y)/16.0 - (1.0/32.0); > + float width = 1.0 / 16.0; > + float height = 1.0 / 16.0; > + glUniform2f(glGetUniformLocation(draw_program, > "loc"), x/16.0, y/16.0); > + piglit_draw_rect(left, bottom, width, height); > + } > + } > + > + glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, fb_textures[cur_fb]); > + glViewport(0, 0, count, 1); > + glBindFramebuffer(GL_FRAMEBUFFER, 0); > + glClearColor(0.5, 0.5, 0.5, 1.0); > + glClear(GL_COLOR_BUFFER_BIT); > + glUseProgram(read_program); > + glUniform1i(glGetUniformLocation(read_program, "input"), 0); > + glUniform2i(glGetUniformLocation(read_program, "offset"), pixel_x, > pixel_y); > + piglit_draw_rect(0.0, 0.0, 1.0, 1.0); > + > + glReadPixels(0, 0, count, 1, GL_RGBA, GL_UNSIGNED_BYTE, locations); > +} > + > +static enum piglit_result > +test_pixel(const unsigned *expected, unsigned pixel_x, unsigned pixel_y) > +{ > + GLubyte actual_locations[32*4]; > + get_sample_locations(actual_locations, samples, pixel_x, pixel_y); > + > + unsigned grid_x = pixel_x % grid_width; > + unsigned grid_y = pixel_y % grid_height; > + > + for (unsigned i = 0; i < samples; i++) { > + for (unsigned j = 0; j < 3; j++) { > + const char* src = > + (const char*[]){"Uniform", > "gl_SamplePosition", "interpolateAtSample"}[j]; > + unsigned x = actual_locations[i*4+j] & 0xf; > + unsigned y = actual_locations[i*4+j] >> 4; > + unsigned expected_x = expected ? expected[i*2] : 8; > + unsigned expected_y = expected ? expected[i*2+1] : 8; > + > + if (x != expected_x) { > + printf("Expected X coordinate of sample %u to be > %u, got %u from %s (at pixel %u, %u and grid %u, %u)\n", > + i, expected_x, x, src, pixel_x, pixel_y, > grid_x, grid_y); > + return PIGLIT_FAIL; > + } > + > + if (y != expected_y) { > + printf("Expected Y coordinate of sample %u to be > %u, got %u from %s (at pixel %u, %u and grid %u, %u)\n", > + i, expected_y, y, src, pixel_x, pixel_y, > grid_x, grid_y); > + return PIGLIT_FAIL; > + } > + } > + } > + > + return PIGLIT_PASS; > +} > + > +static enum piglit_result > +do_test(const unsigned *locations, unsigned pixel_x, unsigned pixel_y, bool > grid) > +{ > + if (!fbs[cur_fb]) return PIGLIT_SKIP; > + > + glBindFramebuffer(GL_FRAMEBUFFER, fbs[cur_fb]); > + > + GLint table_size; > + glGetIntegerv(GL_SAMPLES, &samples); > + glGetIntegerv(GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB, &grid_width); > + glGetIntegerv(GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB, &grid_height); > + glGetIntegerv(GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB, > &table_size); > + > + unsigned grid_x = pixel_x % grid_width; > + unsigned grid_y = pixel_y % grid_height; > + > + glFramebufferParameteri(GL_FRAMEBUFFER, > GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB, grid); > + glFramebufferParameteri(GL_FRAMEBUFFER, > GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB, 1); > + > + for (GLint i = 0; i < table_size; i++) { > + GLfloat loc[2] = {0.5f, 0.5f}; > + glFramebufferSampleLocationsfvARB(GL_FRAMEBUFFER, i, 1, loc); > + } > + > + for (GLint i = 0; i < samples; i++) { > + GLfloat loc[2] = {locations[i*2] / 16.0f, 1.0f - > locations[i*2+1] / 16.0f}; > + unsigned index = i; > + if (grid) > + index += (grid_y*grid_width+grid_x) * samples; > + glFramebufferSampleLocationsfvARB(GL_FRAMEBUFFER, index, 1, > loc); > + } > + > + enum piglit_result result = PIGLIT_PASS; > + if (quick) { > + piglit_merge_result(&result, test_pixel(locations, grid_x, > grid_y)); > + } else { > + for (unsigned x = 0; x < WIDTH; x++) { > + for (unsigned y = 0; y < HEIGHT; y++) { > + const unsigned *expected = locations; > + unsigned grid_x_2 = x % grid_width; > + unsigned grid_y_2 = y % grid_height; > + if ((grid_x_2 != grid_x || grid_y_2 != > grid_y) && grid) > + expected = NULL; > + piglit_merge_result(&result, > test_pixel(expected, x, y)); > + } > + } > + } > + > + return result; > +} > + > +static enum piglit_result > +do_test_set(unsigned x, unsigned y, bool grid) > +{ > + static const unsigned new_locations[32][2] = { > + {1, 3}, {4, 1}, {2, 5}, {5, 5}, {3, 5}, {5, 2}, {1, 6}, {2, > 6}, > + {7, 2}, {5, 7}, {4, 8}, {2, 8}, {8, 1}, {8, 6}, {8, 3}, {9, > 8}, > + {2, 9}, {9, 3}, {1, 10}, {9, 10}, {10, 1}, {1, 11}, {6, 11}, > {11, 6}, > + {12, 5}, {10, 12}, {8, 13}, {13, 8}, {13, 12}, {6, 13}, {4, > 14}, {14, 8}}; > + enum piglit_result result = do_test(&new_locations[0][0], x, y, grid); > + > + piglit_report_subtest_result(result, "MSAA: %u, X: %u, Y: %u, Grid: > %s", > + 1<<cur_fb, x, y, grid?"true":"false"); > + > + return result; > +} > + > +static void > +create_shader_sources(char *vertex, char *fragment) > +{ > + static const char *fragment_exts = > + "#extension GL_ARB_gpu_shader5 : enable\n" > + "#extension GL_ARB_sample_shading : enable\n"; > + static const char *fragment_main = > + "uniform vec2 loc;\n" > + "in vec2 pos;\n" > + "out vec4 color;\n" > + "float encode_location(in vec2 loc) { return (loc.x*16.0 + > loc.y*256.0) / 255.0; }\n" > + "void main() {\n" > + " color.xyz = vec3(encode_location(loc));\n"; > + static const char *fragment_gl_sample_position = > + "color.y = encode_location(vec2(gl_SamplePosition.x, > 1.0-gl_SamplePosition.y));\n"; > + static const char *fragment_interpolate_at_sample = > + "color.z = encode_location(vec2(interpolateAtSample(pos, > gl_SampleID).x, 1.0-interpolateAtSample(pos, gl_SampleID).y));\n"; > + static const char *vertex_main = > + "in vec2 piglit_vertex;\n" > + "out vec2 pos;\n" > + "void main() { gl_Position = vec4(piglit_vertex*2.0-1.0, 0.0, > 1.0); pos = piglit_vertex; }\n"; > + > + int glsl_major, glsl_minor, glsl_ver; > + bool use_gl_sample_position, use_interpolate_at_sample; > + > + piglit_get_glsl_version(NULL, &glsl_major, &glsl_minor); > + glsl_ver = glsl_major*100 + glsl_minor; > + > + if (glsl_ver>=400) > + use_gl_sample_position = use_interpolate_at_sample = true; > + if (piglit_is_extension_supported("GL_ARB_gpu_shader5")) > + use_interpolate_at_sample = true; > + if (piglit_is_extension_supported("GL_ARB_sample_shading")) > + use_gl_sample_position = true; > + > + sprintf(fragment, "#version %u\n%s", glsl_ver, fragment_exts); > + strcat(fragment, fragment_main); > + if (use_gl_sample_position) > + strcat(fragment, fragment_gl_sample_position); > + if (use_interpolate_at_sample) > + strcat(fragment, fragment_interpolate_at_sample); > + strcat(fragment, "}"); > + > + sprintf(vertex, "#version %u\n%s", glsl_ver, fragment_exts); > + strcat(vertex, vertex_main); > +} > + > +void > +piglit_init(int argc, char **argv) > +{ > + char vertex_source[1024]; > + char fragment_source[1024]; > + piglit_require_extension("GL_ARB_sample_locations"); > + > + if (argc > 1 && strcmp(argv[1], "--quick") == 0) > + quick = true; > + > + create_shader_sources(vertex_source, fragment_source); > + > + draw_program = piglit_build_simple_program(vertex_source, > fragment_source); > + > + read_program = piglit_build_simple_program( > + "#version 150\n" > + "in vec2 piglit_vertex;\n" > + "void main() { gl_Position = > vec4(piglit_vertex*2.0-1.0, 0.0, 1.0); }\n", > + "#version 150\n" > + "uniform sampler2DMS tex;\n" > + "uniform ivec2 offset;\n" > + "out vec4 color;\n" > + "void main() { color = texelFetch(tex, offset, > int(gl_FragCoord.x)); }\n"); > + > + GLint count; > + glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &count); > + if (count > MAX_SAMPLES) > + count = MAX_SAMPLES; > + count = log2u(count) + 1; > + > + glGenTextures(count, fb_textures); > + glGenFramebuffers(count, fbs); > + for (cur_fb = 0; cur_fb < count; cur_fb++) { > + glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, fb_textures[cur_fb]); > + glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1<<cur_fb, > GL_RGBA8, WIDTH, HEIGHT, GL_TRUE); > + glBindFramebuffer(GL_FRAMEBUFFER, fbs[cur_fb]); > + glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, > fb_textures[cur_fb], 0); > + } > +} > + > +enum piglit_result > +piglit_display(void) > +{ > + enum piglit_result result = PIGLIT_PASS; > + for (cur_fb = 0; cur_fb < sizeof(fb_textures)/sizeof(fb_textures[0]); > cur_fb++) { > + for (unsigned x = 0; x < WIDTH; x++) { > + for (unsigned y = 0; y < HEIGHT; y++) { > + piglit_merge_result(&result, do_test_set(x, > y, false)); > + piglit_merge_result(&result, do_test_set(x, > y, true)); > + } > + } > + } > + > + piglit_present_results(); > + > + return result; > +} > -- > 2.14.3 > _______________________________________________ Piglit mailing list Piglit@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/piglit