From: Marek Olšák <marek.ol...@amd.com>

---
 tests/spec/ext_window_rectangles/render.c | 93 +++++++++++++++--------
 1 file changed, 61 insertions(+), 32 deletions(-)

diff --git a/tests/spec/ext_window_rectangles/render.c 
b/tests/spec/ext_window_rectangles/render.c
index 87435b23c..0062399f0 100644
--- a/tests/spec/ext_window_rectangles/render.c
+++ b/tests/spec/ext_window_rectangles/render.c
@@ -26,20 +26,21 @@
 PIGLIT_GL_TEST_CONFIG_BEGIN
 
        config.supports_gl_compat_version = 30;
        config.supports_gl_es_version = 30;
        config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
 
 PIGLIT_GL_TEST_CONFIG_END
 
 GLint prog, color;
 GLuint fb;
+static int max_rectangles;
 
 enum piglit_result
 piglit_display(void)
 {
        static const float blue[4] = {0, 0, 1, 1};
        static const float green[4] = {0, 1, 0, 1};
        static const int rect[4 * 8] = {
          0, 0, 1, 1,
          2, 0, 1, 1,
          4, 0, 1, 1,
@@ -50,56 +51,82 @@ piglit_display(void)
          2, 2, 1, 1,
        };
 
        bool pass = true;
 
        glBindFramebuffer(GL_FRAMEBUFFER, fb);
        glUseProgram(prog);
 
        glViewport(0, 0, 20, 20);
 
-       glClearColor(0, 0, 1, 1);
-       glClear(GL_COLOR_BUFFER_BIT);
-
-       glWindowRectanglesEXT(GL_EXCLUSIVE_EXT, 8, rect);
-       glUniform4fv(color, 1, green);
-       glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
-       for (int i = 0; i < 20; i++) {
-               for (int j = 0; j < 20; j++) {
-                       // excluded
-                       if ((i == 0 && (j == 0 || j == 2 || j == 4)) ||
-                           (i == 1 && (j == 1 || j == 3 || j == 5)) ||
-                           (i == 2 && (j == 0 || j == 2)))
-                               pass &= piglit_probe_pixel_rgba(j, i, blue);
-                       else
-                               pass &= piglit_probe_pixel_rgba(j, i, green);
+       for (int num_rectangles = 1; num_rectangles <= max_rectangles; 
num_rectangles++) {
+               glClearColor(0, 0, 1, 1);
+               glClear(GL_COLOR_BUFFER_BIT);
+
+               glWindowRectanglesEXT(GL_EXCLUSIVE_EXT, num_rectangles, rect);
+               glUniform4fv(color, 1, green);
+               glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+               bool subresult = true;
+
+               for (int y = 0; y < 20; y++) {
+                       for (int x = 0; x < 20; x++) {
+                               bool excluded = false;
+
+                               for (int i = 0; i < num_rectangles; i++) {
+                                       if (rect[i*4+0] == x &&
+                                           rect[i*4+1] == y) {
+                                               excluded = true;
+                                               break;
+                                       }
+                               }
+                               if (excluded)
+                                       subresult &= piglit_probe_pixel_rgba(x, 
y, blue);
+                               else
+                                       subresult &= piglit_probe_pixel_rgba(x, 
y, green);
+                       }
                }
+               piglit_report_subtest_result(subresult ? PIGLIT_PASS : 
PIGLIT_FAIL,
+                                            "exclusive, num rectangles = %u", 
num_rectangles);
+               pass &= subresult;
        }
 
-       glClearColor(0, 0, 1, 1);
-       glClear(GL_COLOR_BUFFER_BIT);
-
-       glWindowRectanglesEXT(GL_INCLUSIVE_EXT, 8, rect);
-       glUniform4fv(color, 1, green);
-       glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
-       for (int i = 0; i < 20; i++) {
-               for (int j = 0; j < 20; j++) {
-                       // included
-                       if ((i == 0 && (j == 0 || j == 2 || j == 4)) ||
-                           (i == 1 && (j == 1 || j == 3 || j == 5)) ||
-                           (i == 2 && (j == 0 || j == 2)))
-                               pass &= piglit_probe_pixel_rgba(j, i, green);
-                       else
-                               pass &= piglit_probe_pixel_rgba(j, i, blue);
+       for (int num_rectangles = 1; num_rectangles <= max_rectangles; 
num_rectangles++) {
+               glClearColor(0, 0, 1, 1);
+               glClear(GL_COLOR_BUFFER_BIT);
+
+               glWindowRectanglesEXT(GL_INCLUSIVE_EXT, num_rectangles, rect);
+               glUniform4fv(color, 1, green);
+               glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+               bool subresult = true;
+
+               for (int y = 0; y < 20; y++) {
+                       for (int x = 0; x < 20; x++) {
+                               bool included = false;
+
+                               for (int i = 0; i < num_rectangles; i++) {
+                                       if (rect[i*4+0] == x &&
+                                           rect[i*4+1] == y) {
+                                               included = true;
+                                               break;
+                                       }
+                               }
+                               if (included)
+                                       subresult &= piglit_probe_pixel_rgba(x, 
y, green);
+                               else
+                                       subresult &= piglit_probe_pixel_rgba(x, 
y, blue);
+                       }
                }
+               piglit_report_subtest_result(subresult ? PIGLIT_PASS : 
PIGLIT_FAIL,
+                                            "inclusive, num rectangles = %u", 
num_rectangles);
+               pass &= subresult;
        }
 
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, piglit_winsys_fbo);
        glBlitFramebuffer(0, 0, 20, 20,
                          0, 0, piglit_width, piglit_height,
                          GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
        piglit_present_results();
 
        return pass ? PIGLIT_PASS : PIGLIT_FAIL;
@@ -112,20 +139,22 @@ piglit_init(int argc, char **argv)
                /* x   y   z   w */
                { -1, -1, 1.0, 1 },
                {  1, -1, 1.0, 1 },
                { -1,  1, 0.1, 1 },
                {  1,  1, 0.1, 1 }
        };
 
        GLuint bo, rb;
 
        piglit_require_extension("GL_EXT_window_rectangles");
+       glGetIntegerv(GL_MAX_WINDOW_RECTANGLES_EXT, &max_rectangles);
+       assert(max_rectangles <= 8);
 
        prog = piglit_build_simple_program(
 #ifdef PIGLIT_USE_OPENGL
                        "#version 130\n"
 #else
                        "#version 300 es\n"
                        "precision highp float;\n"
 #endif
                        "in vec4 piglit_vertex;\n"
                        "void main() { gl_Position = piglit_vertex; }\n",
-- 
2.17.1

_______________________________________________
Piglit mailing list
Piglit@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/piglit

Reply via email to