[Piglit] [PATCH] Add test to verify glSampleCoverage with multisample fbo
Anuj Phogat
anuj.phogat at gmail.com
Mon Jun 4 12:27:09 PDT 2012
This test varifies that the coverage value set by glSampleCoverage() decides
the number of samples in multisample buffer covered by an incoming fragment,
which will receive the fragment data.
Note:
This test passes for color buffer but fails for depth buffer on AMD's catalyst
drivers. Depth buffer is not modified even if the incoming multisample fragment
passes the depth test and has a coverage = 1.0.
On NVIDIA test fails for both color and depth buffers. rgb components are computed
by combining the sample colors differently. I couldn't figure out the formula
they used to combine the sample colors. Alpha component is simple average of
sample alpha values. Probably, I can just probe the alpha values to make the test
pass on both NVIDIA and AMD. Any suggestions?
Signed-off-by: Anuj Phogat <anuj.phogat at gmail.com>
---
tests/all.tests | 7 +
.../ext_framebuffer_multisample/CMakeLists.gl.txt | 1 +
.../sample-coverage.cpp | 347 ++++++++++++++++++++
3 files changed, 355 insertions(+), 0 deletions(-)
create mode 100644 tests/spec/ext_framebuffer_multisample/sample-coverage.cpp
diff --git a/tests/all.tests b/tests/all.tests
index 93716a8..0acb2e5 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -1373,6 +1373,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-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 155190f..a764a81 100644
--- a/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt
+++ b/tests/spec/ext_framebuffer_multisample/CMakeLists.gl.txt
@@ -24,6 +24,7 @@ piglit_add_executable (ext_framebuffer_multisample-polygon-smooth common.cpp pol
piglit_add_executable (ext_framebuffer_multisample-renderbuffer-samples renderbuffer-samples.c)
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-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-coverage.cpp b/tests/spec/ext_framebuffer_multisample/sample-coverage.cpp
new file mode 100644
index 0000000..3cb4384
--- /dev/null
+++ b/tests/spec/ext_framebuffer_multisample/sample-coverage.cpp
@@ -0,0 +1,347 @@
+/*
+ * 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-coverage.cpp
+ *
+ * This test operates by clearing the multisample framebuffer to a unique
+ * color (bg_color).
+ *
+ * Draws a test pattern with GL_SAMPLE_COVERAGE disabled and blits it
+ * in to right half of window system framebuffer. This is used as reference
+ * image to see the visual difference caused by the sample coverage value.
+ *
+ * Draws the same test pattern for the second time in multisample buffer with
+ * GL_SAMPLE_COVERAGE enabled. Blits it in to left half of window system
+ * framebuffer. This is the test image.
+ *
+ * Compute the expected color values based on the coverage value used to draw
+ * the test pattern.
+ *
+ * To verify that GL_SAMPLE_COVERGE works as expected, probe the left half of
+ * window syetem framebuffer and compare to the expected color values.
+ *
+ * Author: Anuj Phogat <anuj.phogat at gmail.com>
+ */
+
+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;
+static GLint num_samples;
+static float expected[4][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 coverage[4] =
+ {0.0, 0.25, 0.75, 1.0};
+
+static const float color[4][4] = {
+ /* Red */
+ {1.0, 0.0, 0.0, 1.0},
+ /* Green */
+ {0.0, 1.0, 0.0, 0.50},
+ /* Yellow */
+ {1.0, 1.0, 0.0, 0.75},
+ /* Cyan */
+ {0.0, 1.0, 1.0, 0.45} };
+
+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_coverage)
+{
+ 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);
+ glClear(buffer_to_test);
+ if (sample_coverage)
+ glEnable (GL_SAMPLE_COVERAGE);
+
+ glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_data[0]),
+ (void *) vertex_data);
+
+ for (int i = 0; i < 4; ++i) {
+ if (sample_coverage)
+ glSampleCoverage (coverage[i], GL_FALSE);
+ glUniform4fv(color_loc, 1, color[i]);
+ glUniform1f(depth_loc, depth[i]);
+ glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT,
+ (void *) (indices + 6 * i));
+
+ printf("coverage = %f\n", coverage[i]);
+ }
+ if (sample_coverage)
+ glDisable (GL_SAMPLE_COVERAGE);
+}
+
+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(void)
+{
+ int i;
+ /* 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++) {
+ expected[i][0] = color[i][0] * coverage[i] +
+ bg_color[0] * (1 - coverage[i]);
+ expected[i][1] = color[i][1] * coverage[i] +
+ bg_color[1] * (1 - coverage[i]);
+ expected[i][2] = color[i][2] * coverage[i] +
+ bg_color[2] * (1 - coverage[i]);
+ expected[i][3] = color[i][3] * 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;
+ }
+ }
+}
+
+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);
+ glClear(GL_COLOR_BUFFER_BIT);
+ 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.init(num_samples, pattern_width, pattern_height,
+ true /* combine_depth_stencil */,
+ false /* attach_texture */);
+
+ glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ms_fbo.handle);
+ if (strcmp(argv[2], "color") == 0) {
+ buffer_to_test = GL_COLOR_BUFFER_BIT;
+ glClearColor(bg_color[0], bg_color[1],
+ bg_color[2], bg_color[3]);
+ } 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]);
+ }
+
+ compute_expected();
+ shader_compile();
+}
+
+enum piglit_result
+piglit_display()
+{
+ bool pass = true;
+
+ /* 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);
+
+ /* 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);
+
+ /* Now draw test pattern in mulisample ms_fbo with GL_SAMPLE_COVERAGE
+ * enabled
+ */
+ glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ms_fbo.handle);
+ draw_pattern(true);
+
+ /* Blit ms_fbo to the left half of window system framebuffer. This
+ * is the test image.
+ */
+ glBindFramebuffer(GL_READ_FRAMEBUFFER, ms_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 */
+ glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+
+ if (buffer_to_test == GL_COLOR_BUFFER_BIT) {
+ pass = piglit_probe_rect_rgba(0,
+ 0,
+ pattern_width / 4,
+ pattern_height,
+ expected[0])
+ && pass;
+ pass = piglit_probe_rect_rgba(pattern_width / 4,
+ 0,
+ pattern_width / 4,
+ pattern_height,
+ expected[1])
+ && pass;
+ pass = piglit_probe_rect_rgba(pattern_width / 2,
+ 0,
+ pattern_width / 4,
+ pattern_height,
+ expected[2])
+ && pass;
+ pass = piglit_probe_rect_rgba(3 * pattern_width / 4,
+ 0,
+ pattern_width / 4,
+ pattern_height,
+ expected[3])
+ && pass;
+ }
+ else if (buffer_to_test == GL_DEPTH_BUFFER_BIT) {
+ pass = piglit_probe_rect_depth(0,
+ 0,
+ pattern_width / 4,
+ pattern_height,
+ expected[0][0])
+ && pass;
+ /*Skip probing polygons which are drawn with coverage
+ * value between 0.0 and 1.0
+ */
+ pass = piglit_probe_rect_depth(3 * pattern_width / 4,
+ 0,
+ pattern_width / 4,
+ pattern_height,
+ expected[0][3])
+ && pass;
+ }
+
+ pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
+
+ if (!piglit_automatic &&
+ buffer_to_test != GL_DEPTH_BUFFER_BIT)
+ piglit_present_results();
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
--
1.7.7.6
More information about the Piglit
mailing list