On 20 June 2012 19:01, Anuj Phogat <<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"> <div class="im">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. </div>It also includes testing of GL_SAMPLE_ALPHA_TO_COVERAGE with GL_SAMPLE_ALPHA_TO_ONE enabled. V2: Add testing for coverage values which may result in dithering for all sample counts. Dropping the testing for multisample depth buffer. </blockquote><div> This patch is: Reviewed-by: Paul Berry <<a href="mailto:stereotype441@gmail.com">stereotype441@gmail.com</a>> </div> <blockquote class="gmail_quote" style="margin:0pt 0pt 0pt 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"> <div class="im"> Signed-off-by: Anuj Phogat <<a href="mailto:anuj.phogat@gmail.com">anuj.phogat@gmail.com</a>> --- </div>This test fails on AMD's catalyst drivers with GL_SAMPLE_ALPHA_TO_ONE enabled. But as I remember it passed on NVIDIA last time. I will confirm it before pushing the test case. <div class="im"> tests/all.tests | 6 + .../ext_framebuffer_multisample/CMakeLists.gl.txt | 1 + </div> .../sample-alpha-to-coverage.cpp | 412 ++++++++++++++++++++ 3 files changed, 419 insertions(+), 0 deletions(-) <div class="im"> create mode 100644 tests/spec/ext_framebuffer_multisample/sample-alpha-to-coverage.cpp diff --git a/tests/all.tests b/tests/all.tests </div>index 5fdc9e7..6745037 100644 --- a/tests/all.tests +++ b/tests/all.tests @@ -1391,6 +1391,12 @@ for num_samples in (2, 4, 8, 16, 32): <div class="im"> test_name) ext_framebuffer_multisample[test_name] = PlainExecTest(executable) +for num_samples in (2, 4, 8, 16, 32): </div>+ test_name = ' '.join(['sample-alpha-to-coverage', str(num_samples)]) <div class="im">+ 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 </div>index c746328..c6566be 100644 --- a/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt +++ b/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt @@ -29,6 +29,7 @@ piglit_add_executable (ext_framebuffer_multisample-renderbuffer-samples renderbu <div class="im"> 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 </div>index 0000000..540396b --- /dev/null +++ b/tests/spec/ext_framebuffer_multisample/sample-alpha-to-coverage.cpp @@ -0,0 +1,412 @@ <div><div class="h5">+/* + * 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 + * </div></div>+ * Verify GL_SAMPLE_ALPHA_TO_COVERAGE with multisample FBO. + * + * This test operates by drawing a test pattern to multisample_fbo with <div class="im">+ * GL_SAMPLE_ALPHA_TO_COVERAGE disabled. + * </div>+ * Blit the multisample_fbo to top half of window system framebuffer. This + * is used as reference image to visually compare the difference caused by + * sample alpha to coverage value. <div class="im">+ * + * Compute the expected color values based on the coverage value used to + * draw the test pattern. + * </div>+ * Clear the multisample framebuffer to a unique color. Draw the same test + * pattern 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 bottom half of window system framebuffer. This is our + * test image. + * + * Probe the rectangles in bottom half of window system framebuffer and + * compare with expected color values. OpenGL 3.0 specification intends + * to allow (but not require) the implementation to produce a dithering + * effect when the coverage value is not a strict multiple of 1/num_samples. + * We will skip computing expected values and probing for such rectangles. + * They are drawn just to look for dithering by human inspection. + * + * Repeat the above testing with GL_SAMPLE_ALPHA_TO_ONE enabled / disabled. + * when both GL_SAMPLE_ALPHA_TO_ONE and GL_SAMPLE_ALPHA_TO_COVERAGE are + * enabled, GL_SAMPLE_ALPHA_TO_COVERAGE takes effect first. i.e. the + * coverage value is computed from the alpha value before the alpha value + * is changed to 1. + * + * Note: glSampleCoverage() takes effect in the graphics pipeline before + * the point where the output of the fragment shader is split into the + * various buffers. So it's very likely that if glSampleCoverage() works + * properly for color buffers, it will work properly for depth and stencil + * buffers too. <div class="im">+ * + * Author: Anuj Phogat <<a href="mailto:anuj.phogat@gmail.com">anuj.phogat@gmail.com</a>> + */ + +int piglit_width = 512; int piglit_height = 256; </div>+int piglit_window_mode = GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA ; +const int pattern_width = 512; const int pattern_height = 128; <div class="im">+ +static Fbo ms_fbo, resolve_fbo; </div>+static GLbitfield buffer_to_test; + +static float *coverage = NULL; +static float *color = NULL; +static float *expected = NULL; + +static int num_samples; +static int num_rects; +static int prog; +static int color_loc; +static int depth_loc; + +static const float bg_color[4] = { 0.4, 0.6, 0.0, 0.8 }; <div><div class="h5">+ +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) +{ </div></div>+ glUseProgram(prog); <div class="im">+ glClearColor(bg_color[0], bg_color[1], + bg_color[2], bg_color[3]); + glClear(buffer_to_test); + </div>+ if (sample_alpha_to_coverage) + glEnable (GL_SAMPLE_ALPHA_TO_COVERAGE); + + if (sample_alpha_to_one) + glEnable (GL_SAMPLE_ALPHA_TO_ONE); + + unsigned int indices[6] = {0, 1, 2, 0, 2, 3}; + + for (int i = 0; i < num_rects; ++i) { + + float vertex_data[4][2] = { + { 0.0f + i * (pattern_width / num_rects), 0.0f }, + { 0.0f + i * (pattern_width / num_rects), pattern_height }, + { (i + 1.0f) * (pattern_width / num_rects), pattern_height }, + { (i + 1.0f) * (pattern_width / num_rects), 0.0f } }; <div class="im">+ + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, </div>+ sizeof(vertex_data[0]), <div class="im">+ (void *) vertex_data); + </div>+ glUniform4fv(color_loc, 1, (color + i * 4)); + glUniform1f(depth_loc, 0.0f); + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, + (void *) indices); <div class="im">+ } + 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) +{ </div>+ printf("Usage: %s <num_samples>\n", prog_name); <div class="im">+ piglit_report_result(PIGLIT_FAIL); +} + +void +compute_expected(bool sample_alpha_to_one) +{ + int i, j; + </div>+ /* Sample alpha to coverage doesn't affect single sample FBO */ + if(num_samples == 0) { + for(i = 0; i < 4; i++) + expected[i] = color[i]; + return; + } <div class="im">+ + /* Fragment's alpha value is directly used as coverage value */ </div>+ for (i = 0; i < num_rects; i++) + coverage[i] = color[i * 4 + 3]; <div class="im">+ + /* 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) { </div>+ for (i = 0; i < num_rects; i++) { + + float samples_used = coverage[i] * num_samples; + /* Exepected color values are computed only for integer + * number of samples_used + */ + if(samples_used == (int)samples_used) { + + for(j =0; j < 4; j++) + expected[i * 4 + j] = + color[i * 4 + j] * coverage[i] + <div class="im">+ bg_color[j] * (1 - coverage[i]); + + if (sample_alpha_to_one) </div>+ expected[i * 4 + 3] = + 1.0 * coverage[i] + <div class="im">+ bg_color[3] * (1 - coverage[i]); + } + } + } </div>+} + +bool +probe_framebuffer_color(bool sample_alpha_to_one) <div class="im">+{ + bool result = true; </div>+ glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + + for (int i = 0; i < num_rects; i++) { + float samples_used = coverage[i] * num_samples; + + /* Only probe rectangles with coverage value which is a strict + * multiple of 1 / num_samples. + */ + if(samples_used == (int)samples_used) { + result = piglit_probe_rect_rgba( + i * (pattern_width / num_rects), + 0, + pattern_width / num_rects, + pattern_height, + expected + i * 4) <div class="im">+ && result; + } + } </div><div class="im">+ return result; +} + +bool +test_sample_alpha_to_coverage(bool sample_alpha_to_one) +{ + bool result = true; + compute_expected(sample_alpha_to_one); + </div><div class="im">+ /* Draw test pattern in multisample ms_fbo with </div>+ * GL_SAMPLE_ALPHA_TO_COVERAGE enabled <div class="im">+ */ + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ms_fbo.handle); </div>+ draw_pattern(true /* sample_alpha_to_coverage */ , sample_alpha_to_one); <div class="im">+ + /* 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); + </div>+ /* Blit resolve_fbo to the bottom half of window system framebuffer. <div class="im">+ * 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); + </div>+ /* Probe the bottom half of default framebuffer and compare to the <div class="im">+ * expected values */ + if (buffer_to_test == GL_COLOR_BUFFER_BIT) </div>+ result = probe_framebuffer_color(sample_alpha_to_one) && result; <div class="im">+ + result = piglit_check_gl_error(GL_NO_ERROR) && result; + return result; +} + </div>+void +allocate_data_arrays(void) +{ + /* Draw 2N + 1 rectangles for N samples, each with a unique color + * and coverage value + */ + num_rects = 2 * num_samples + 1; + + /* Allocate data arrays based on number of samples used */ + color = (float *) malloc(num_rects * 4 * sizeof(float)); + coverage = (float *) malloc(num_rects * sizeof(float)); + expected = (float *) malloc(num_rects * 4 * sizeof(float)); + + for(int i = 0; i < num_rects; i++) { + /* Randomly select color for each rectangle */ + color[i * 4 + 0] = (rand() % 1000) * .001; + color[i * 4 + 1] = (rand() % 1000) * .001; + color[i * 4 + 2] = (rand() % 1000) * .001; + /* Alpha value will be used as coverage */ + color[i * 4 + 3] = i * (1.0 / (2 * num_samples)); + } +} + +void +free_data_arrays(void) +{ + if(color != NULL) { + free(color); + color = NULL; + } + if(coverage != NULL) { + free(coverage); + coverage = NULL; + } + if(expected != NULL) { + free(expected); + expected = NULL; <div class="im">+ } +} + +void +piglit_init(int argc, char **argv) +{ </div>+ int samples; + if (argc < 2) <div class="im">+ print_usage_and_exit(argv[0]); + { + char *endptr = NULL; </div>+ samples = strtol(argv[1], &endptr, 0); <div class="im">+ 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); + </div>+ /* Skip the test if samples > GL_MAX_SAMPLES */ <div class="im">+ GLint max_samples; + glGetIntegerv(GL_MAX_SAMPLES, &max_samples); + </div>+ if (samples > max_samples) + piglit_report_result(PIGLIT_SKIP); + + /* Setup frame buffer objects with required configuration */ + ms_fbo.setup(FboConfig(samples, pattern_width, pattern_height)); + resolve_fbo.setup(FboConfig(0, pattern_width, pattern_height)); + + if (!piglit_check_gl_error(GL_NO_ERROR)) { + printf("Error setting up frame buffer objects\n"); + piglit_report_result(PIGLIT_FAIL); + } + + /* Query the number of samples used in ms_fbo. OpenGL implementation + * may create FBO with more samples per pixel than what is requested. + */ + glBindRenderbuffer(GL_RENDERBUFFER, ms_fbo.color_rb); + glGetRenderbufferParameteriv(GL_RENDERBUFFER, + GL_RENDERBUFFER_SAMPLES, + &num_samples); <div class="im">+ + buffer_to_test = GL_COLOR_BUFFER_BIT; </div>+ shader_compile(); <div class="im">+} + +enum piglit_result +piglit_display() +{ + bool pass = true; </div>+ allocate_data_arrays(); + + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); <div class="im">+ glClearColor(0.0, 0.0, 0.0, 1.0); </div>+ glClear(buffer_to_test); <div class="im">+ + /* Draw test pattern in multisample ms_fbo with </div>+ * GL_SAMPLE_ALPHA_TO_COVERAGE disabled. + */ <div class="im">+ glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ms_fbo.handle); + ms_fbo.set_viewport(); </div>+ draw_pattern(false /* sample_alpha_to_coverage */, + false /* sample_alpha_to_one */ ); + + /* Blit ms_fbo to the top half of window system framebuffer. This + * is our reference image to visually compare the effect of MSAA + * with sample alpha to coverage. <div class="im">+ */ + glBindFramebuffer(GL_READ_FRAMEBUFFER, ms_fbo.handle); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); + glBlitFramebuffer(0, 0, </div>+ pattern_width, pattern_height, + 0, pattern_height, + pattern_width, 2 * pattern_height, + buffer_to_test, GL_NEAREST); + + /* Test with sample_alpha_to_one = false */ + pass = test_sample_alpha_to_coverage(false) && pass; + + /* Test sample alpha to coverage with sample_alpha_to_one = true */ + pass = test_sample_alpha_to_coverage(true) && pass; + + /* Free the memory allocated for data arrays */ + free_data_arrays(); <div class="HOEnZb"><div class="h5">+ + if (!piglit_automatic && + buffer_to_test != GL_DEPTH_BUFFER_BIT) + piglit_present_results(); + + return pass ? PIGLIT_PASS : PIGLIT_FAIL; +} -- 1.7.7.6 </div></div></blockquote></div>