On 8 June 2012 14:45, <<a href="mailto:anuj.phogat@gmail.com" target="_blank">anuj.phogat@gmail.com</a>> wrote: <div class="gmail_quote"><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> From: Anuj Phogat <<a href="mailto:anuj.phogat@gmail.com">anuj.phogat@gmail.com</a>> This test varifies that with GL_SAMPLE_ALPHA_TO_COVERAGE enabled, the coverage value is set by fragment alpha value. Coverage value decides the number of samples in multisample buffer covered by an incoming fragment, which receive the fragment data. It also includes testing of sample alpha to coverage with GL_SAMPLE_ALPHA_TO_ONE enabled/disabled. Note: Test fails for depth buffer on NVIDIA's proprietary drivers. Depth buffer is not modified even if the incoming multisample fragment passes the depth test and has a coverage = 1.0. </blockquote><div> Most of my comments from the previous patch apply to this patch as well. </div><blockquote class="gmail_quote" style="margin:0pt 0pt 0pt 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"> Signed-off-by: Anuj Phogat <<a href="mailto:anuj.phogat@gmail.com">anuj.phogat@gmail.com</a>> --- tests/all.tests | 7 + .../ext_framebuffer_multisample/CMakeLists.gl.txt | 1 + .../sample-alpha-to-coverage.cpp | 375 ++++++++++++++++++++ 3 files changed, 383 insertions(+), 0 deletions(-) create mode 100644 tests/spec/ext_framebuffer_multisample/sample-alpha-to-coverage.cpp diff --git a/tests/all.tests b/tests/all.tests index a52b745..0e531b8 100644 --- a/tests/all.tests +++ b/tests/all.tests @@ -1393,6 +1393,13 @@ for num_samples in (2, 4, 8, 16, 32): test_name) ext_framebuffer_multisample[test_name] = PlainExecTest(executable) +for num_samples in (2, 4, 8, 16, 32): + for buffer_type in ('color', 'depth'): + test_name = ' '.join(['sample-alpha-to-coverage', str(num_samples), buffer_type]) + executable = 'ext_framebuffer_multisample-{0} -auto'.format( + test_name) + ext_framebuffer_multisample[test_name] = PlainExecTest(executable) + ext_framebuffer_object = Group() spec['EXT_framebuffer_object'] = ext_framebuffer_object add_fbo_stencil_tests(ext_framebuffer_object, 'GL_STENCIL_INDEX1') diff --git a/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt b/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt index 17a9571..a6595fa 100644 --- a/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt +++ b/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt @@ -27,6 +27,7 @@ piglit_add_executable (ext_framebuffer_multisample-renderbuffer-samples renderbu piglit_add_executable (ext_framebuffer_multisample-renderbufferstorage-samples renderbufferstorage-samples.c) piglit_add_executable (ext_framebuffer_multisample-samples samples.c) piglit_add_executable (ext_framebuffer_multisample-sample-coverage common.cpp sample-coverage.cpp) +piglit_add_executable (ext_framebuffer_multisample-sample-alpha-to-coverage common.cpp sample-alpha-to-coverage.cpp) piglit_add_executable (ext_framebuffer_multisample-turn-on-off common.cpp turn-on-off.cpp) piglit_add_executable (ext_framebuffer_multisample-unaligned-blit common.cpp unaligned-blit.cpp) piglit_add_executable (ext_framebuffer_multisample-upsample common.cpp upsample.cpp) diff --git a/tests/spec/ext_framebuffer_multisample/sample-alpha-to-coverage.cpp b/tests/spec/ext_framebuffer_multisample/sample-alpha-to-coverage.cpp new file mode 100644 index 0000000..59a365b --- /dev/null +++ b/tests/spec/ext_framebuffer_multisample/sample-alpha-to-coverage.cpp @@ -0,0 +1,375 @@ +/* + * Copyright © 2012 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. + */ + +#include "common.h" + +/** + * \file sample-alpha-to-coverage.cpp + * + * Verify glSampleCoverage() with and without coverage mask invert + * + * This test operates by drawing test pattern in a multisample FBO with + * GL_SAMPLE_ALPHA_TO_COVERAGE disabled. + * + * Blit the multisample_fbo to right half of window system framebuffer. + * This is used as reference image to see the visual difference caused by + * the alpha value. + * + * Compute the expected color values based on the coverage value used to + * draw the test pattern. + * + * Clear the multisample framebuffer to a unique color/depth. Draws + * the same test pattern for the second time in multisample buffer with + * GL_SAMPLE_ALPHA_TO_COVERAGE enabled. Resolve the multisample FBO by + * blitting it to a single sample FBO. Blit the resolve_fbo to left half + * of window system framebuffer. This is the test image. + * + * Probe the left half of window syetem framebuffer and compare with expected + * color values. + * + * Repeat the above testing with GL_SAMPLE_ALPHA_TO_ONE enabled as well. + * + * Author: Anuj Phogat <<a href="mailto:anuj.phogat@gmail.com">anuj.phogat@gmail.com</a>> + */ + +int piglit_width = 512; int piglit_height = 256; +int piglit_window_mode = + GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA | GLUT_DEPTH; +const int pattern_width = 256; const int pattern_height = 256; + +static Fbo ms_fbo, resolve_fbo; +static GLint num_samples; +static float expected[4][4]; +static float coverage[4]; +static GLbitfield buffer_to_test; + +static const float bg_depth = 0.80; +static const float bg_color[4] = + {0.0, 0.0, 1.0, 0.8}; + +static const float depth[4] = + {0.0, 0.25, 0.60, 0.70}; + +static const float color[4][4] = { + /* Red */ + {1.0, 0.0, 0.0, 0.0}, + /* Green */ + {0.0, 1.0, 0.0, 0.25}, + /* Yellow */ + {1.0, 1.0, 0.0, 0.75}, + /* Cyan */ + {0.0, 1.0, 1.0, 1.0} }; + +static GLint prog; +static GLint color_loc; +static GLint depth_loc; + +static const char *vert = + "#version 130\n" + "in vec2 pos;\n" + "uniform float depth;\n" + "void main()\n" + "{\n" + " vec4 eye_pos = gl_ModelViewProjectionMatrix * vec4(pos, 0.0, 1.0);\n" + " gl_Position = vec4(eye_pos.xy, depth, 1.0);\n" + "}\n"; + +static const char *frag = + "#version 130\n" + "uniform vec4 color;\n" + "void main()\n" + "{\n" + " gl_FragColor = color;\n" + "}\n"; + +void +shader_compile() +{ + /* Compile program */ + GLint vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vert); + GLint fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag); + prog = piglit_link_simple_program(vs, fs); + + if (!piglit_link_check_status(prog)) { + piglit_report_result(PIGLIT_FAIL); + } + + glBindAttribLocation(prog, 0, "pos"); + glEnableVertexAttribArray(0); + + /* Set up uniforms */ + glUseProgram(prog); + color_loc = glGetUniformLocation(prog, "color"); + depth_loc = glGetUniformLocation(prog, "depth"); +} + +void +draw_pattern(bool sample_alpha_to_coverage, bool sample_alpha_to_one) +{ + float vertex_data[10][2] = { + { 0, 0 }, + { 0, pattern_height }, + { pattern_width / 4, pattern_height }, + { pattern_width / 4, 0 }, + { pattern_width / 2, pattern_height }, + { pattern_width / 2, 0 }, + { 3 * pattern_width / 4, pattern_height }, + { 3 * pattern_width / 4, 0 }, + { pattern_width, pattern_height }, + { pattern_width, 0 }, + }; + + unsigned int indices[24] = {0, 1, 2, 0, 2, 3, + 3, 2, 4, 3, 4, 5, + 5, 4, 6, 5, 6, 7, + 7, 6, 8, 7, 8, 9}; + glUseProgram(prog); + glClearColor(bg_color[0], bg_color[1], + bg_color[2], bg_color[3]); + glClear(buffer_to_test); + if (sample_alpha_to_coverage) + glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE); + + if (sample_alpha_to_one) + glEnable(GL_SAMPLE_ALPHA_TO_ONE); + + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_data[0]), + (void *) vertex_data); + + for (int i = 0; i < 4; ++i) { + glUniform4fv(color_loc, 1, color[i]); + glUniform1f(depth_loc, depth[i]); + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, + (void *) (indices + 6 * i)); + } + if (sample_alpha_to_coverage) + glDisable (GL_SAMPLE_ALPHA_TO_COVERAGE); + + if (sample_alpha_to_one) + glDisable (GL_SAMPLE_ALPHA_TO_ONE); +} + +void +print_usage_and_exit(char *prog_name) +{ + printf("Usage: %s <num_samples> <buffer_type>\n" + " where <buffer_type> is one of:\n" + " color\n" + " depth\n", + prog_name); + piglit_report_result(PIGLIT_FAIL); +} + +void +compute_expected(bool sample_alpha_to_one) +{ + int i, j; + + /* Fragment's alpha value is directly used as coverage value */ + for (i = 0; i < 4; i++) + coverage[i] = color[i][3]; + + /* Coverage value decides the number of samples in multisample buffer + * covered by an incoming fragment, which will then receive the fragment + * data. When the multisample buffer is resolved it will be blended + * with the background color which will be written to the remaining + * samples. + * Page 254 (page 270 of the PDF) of the OpenGL 3.0 spec says: + * "The method of combination is not specified, though a simple average + * computed independently for each color component is recommended." + */ + if(buffer_to_test == GL_COLOR_BUFFER_BIT) { + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) + expected[i][j] = color[i][j] * coverage[i] + + bg_color[j] * (1 - coverage[i]); + + if (sample_alpha_to_one) + expected[i][3] = 1.0 * coverage[i] + + bg_color[3] * (1 - coverage[i]); + } + } + /* Compute the expected depth values only for coverage = 0.0 and 1.0 */ + else if(buffer_to_test == GL_DEPTH_BUFFER_BIT) { + for (i = 0; i < 4; i++) { + if (coverage[i] == 0.0) + expected[0][i] = bg_depth; + else if (coverage[i] == 1.0) + expected[0][i] = depth[i] < bg_depth ? + depth[i] : bg_depth; + } + } +} + +bool +probe_framebuffer_color(void) +{ + bool result = true; + glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + for (int i = 0; i < 4; i++) { + result = piglit_probe_rect_rgba(i * (pattern_width / 4), + 0, + pattern_width / 4, + pattern_height, + expected[i]) + && result; + } + return result; +} + +bool +probe_framebuffer_depth(void) +{ + bool result = true; + glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + for (int i = 0; i < 4; i++) { + if(coverage[i] == 0.0 || coverage[i] == 1.0) + result = piglit_probe_rect_depth(i * (pattern_width / 4), + 0, + pattern_width / 4, + pattern_height, + expected[0][i]) + && result; + else + /*Skip probing polygons which are drawn with coverage + * value between 0.0 and 1.0 + */ + continue; + } + return result; +} + +bool +test_sample_alpha_to_coverage(bool sample_alpha_to_one) +{ + bool result = true; + compute_expected(sample_alpha_to_one); + /* Now draw test pattern in mulisample ms_fbo with GL_SAMPLE_ALPHA_TO_COVERAGE + * enabled + */ + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ms_fbo.handle); + draw_pattern(true, sample_alpha_to_one); + + /* Blit ms_fbo to resolve_fbo to resolve multisample buffer */ + glBindFramebuffer(GL_READ_FRAMEBUFFER, ms_fbo.handle); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolve_fbo.handle); + glBlitFramebuffer(0, 0, pattern_width, pattern_height, + 0, 0, pattern_width, pattern_height, + buffer_to_test, GL_NEAREST); + + /* Blit resolve_fbo to the left half of window system framebuffer. + * This is the test image. + */ + glBindFramebuffer(GL_READ_FRAMEBUFFER, resolve_fbo.handle); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); + glBlitFramebuffer(0, 0, pattern_width, pattern_height, + 0, 0, pattern_width, pattern_height, + buffer_to_test, GL_NEAREST); + + /* Probe the left half of default framebuffer and compare to the + * expected values */ + if (buffer_to_test == GL_COLOR_BUFFER_BIT) + result = probe_framebuffer_color() && result; + else if (buffer_to_test == GL_DEPTH_BUFFER_BIT) + result = probe_framebuffer_depth() && result; + + result = piglit_check_gl_error(GL_NO_ERROR) && result; + return result; +} + + +void +piglit_init(int argc, char **argv) +{ + if (argc < 3) + print_usage_and_exit(argv[0]); + { + char *endptr = NULL; + num_samples = strtol(argv[1], &endptr, 0); + if (endptr != argv[1] + strlen(argv[1])) + print_usage_and_exit(argv[0]); + } + + piglit_require_gl_version(30); + piglit_ortho_projection(pattern_width, pattern_height, GL_TRUE); + + /* Skip the test if num_samples > GL_MAX_SAMPLES or num_samples = 0 */ + GLint max_samples; + glGetIntegerv(GL_MAX_SAMPLES, &max_samples); + if (num_samples > max_samples || + num_samples == 0) + piglit_report_result(PIGLIT_SKIP); + + ms_fbo.setup(FboConfig(num_samples, pattern_width, pattern_height)); + resolve_fbo.setup(FboConfig(num_samples, pattern_width, pattern_height)); + + if (strcmp(argv[2], "color") == 0) { + buffer_to_test = GL_COLOR_BUFFER_BIT; + } else if (strcmp(argv[2], "depth") == 0) { + buffer_to_test = GL_DEPTH_BUFFER_BIT; + glClearDepth(bg_depth); + glEnable(GL_DEPTH_TEST); + } else + print_usage_and_exit(argv[0]); + + shader_compile(); +} + +enum piglit_result +piglit_display() +{ + bool pass = true; + glClearColor(0.0, 0.0, 0.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT); + + /* Draw test pattern in multisample ms_fbo with GL_POLYGON_SMOOTH + * disabled. + */ + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ms_fbo.handle); + ms_fbo.set_viewport(); + draw_pattern(false, false); + + /* Blit ms_fbo to the right half of window system framebuffer. This + * is a reference image to test MSAA with polygon smooth. + */ + glBindFramebuffer(GL_READ_FRAMEBUFFER, ms_fbo.handle); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); + glBlitFramebuffer(0, 0, pattern_width, pattern_height, + pattern_width, 0, 2 * pattern_width, pattern_height, + buffer_to_test, GL_NEAREST); + + /* Test with GL_SAMPLE_ALPHA_TO_ONE disabled + */ + pass = test_sample_alpha_to_coverage(false /* sample_alpha_to_one */) + && pass; + + /* Test with GL_SAMPLE_ALPHA_TO_ONE enabled */ + pass = test_sample_alpha_to_coverage(true /* sample_alpha_to_one */) + && pass; + + if (!piglit_automatic && + buffer_to_test != GL_DEPTH_BUFFER_BIT) + piglit_present_results(); + + return pass ? PIGLIT_PASS : PIGLIT_FAIL; +} -- 1.7.7.6 _______________________________________________ Piglit mailing list <a href="mailto:Piglit@lists.freedesktop.org">Piglit@lists.freedesktop.org</a> <a href="http://lists.freedesktop.org/mailman/listinfo/piglit" target="_blank">http://lists.freedesktop.org/mailman/listinfo/piglit</a> </blockquote></div>