ext_gpu_shader4: add compiler tests for everything

[piglit.git] / tests / spec / arb_separate_shader_objects / 400-combinations.c

/*
 * Copyright © 2013 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.
 */

/**
 * \file 400-combinations.c
 * Combine 20 vertex shaders and 20 fragment shaders in various ways.
 *
 * Verify that the right shaders are used in the right combinations several
 * ways.
 *
 * * The vertex shader has information baked-in that determines the X position
 *   of the block on the screen.
 *
 * * The fragment shader has information baked-in that determines how the
 *   block is colored.  This is combined with data passed from the vertex
 *   shader.
 *
 * Since data is passed from the vertex shader to the fragment shader, the
 * test can use either rendezvous-by-name (default) or rendezvous-by-location
 * (with --by-location command line parameter).
 */
#include "piglit-util-gl.h"
#include "sso-common.h"

/**
 * Size of each square that will be drawn.
 */
static const unsigned tile_size = 5;

/**
 * Size of the gap between the squares.
 */
static const unsigned border_size = 2;

static GLuint vs_programs[20];
static GLuint fs_programs[20];

PIGLIT_GL_TEST_CONFIG_BEGIN

        config.supports_gl_compat_version = 10;
        config.supports_gl_core_version = 31;

        config.window_width = (tile_size + border_size)
                * ARRAY_SIZE(vs_programs);
        config.window_height = (tile_size + border_size)
                * ARRAY_SIZE(fs_programs);
        config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;

PIGLIT_GL_TEST_CONFIG_END

static GLuint pipe;

static GLuint vao = 0;
static GLuint bo = 0;

struct combination {
        unsigned char row;
        unsigned char col;
};

static struct combination combinations[ARRAY_SIZE(vs_programs)
                                       * ARRAY_SIZE(fs_programs)];

static const char *vs_code =
        "#version %d\n"
        "#extension GL_ARB_separate_shader_objects: require\n"
        "#extension GL_ARB_explicit_attrib_location: require\n"
        "\n"
        "layout(location = 0) in vec4 piglit_vertex;\n"
        "layout(location = 1) in vec3 vertex_color;\n"
        "\n"
        "%s out vec3 %s;\n"
        "\n"
        "const vec4 offset = vec4(%d, 0, 0, 0);\n"
        "\n"
        "uniform mat4 transform;\n"
        "\n"
        "void main()\n"
        "{\n"
        "    gl_Position = transform * (piglit_vertex + offset);\n"
        "    %s = vertex_color;\n"
        "}\n"
        ;

static const char *fs_code =
        "#version %d\n"
        "#extension GL_ARB_separate_shader_objects: require\n"
        "#extension GL_ARB_explicit_attrib_location: enable\n"
        "\n"
        "#if __VERSION__ >= 130\n"
        "layout(location = 0) out vec4 out_color;\n"
        "#else\n"
        "#define out_color gl_FragColor\n"
        "#endif\n"
        "\n"
        "%s in vec3 %s;\n"
        "\n"
        "const vec3 color_offset = vec3(%d, %d, %d);\n"
        "\n"
        "void main()\n"
        "{\n"
        "    out_color = vec4(%s + color_offset, 1.);\n"
        "}\n"
        ;

enum piglit_result
piglit_display(void)
{
        unsigned i;
        unsigned j;

        static const float expected[] = {
                0.0f, 1.0f, 0.0f, 1.0f
        };

        /* This is stored in row-major order.  Note the GL_TRUE parameter to
         * the glProgramUniformMatrix4fv call below.
         */
        const float transform[16] = {
                2.f / piglit_width, 0.0f, 0.0f, -1.0f,
                0.0f, 2.f / piglit_height, 0.0f, -1.0f,
                0.0f, 0.0f, 0.0f,  0.0f,
                0.0f, 0.0f, 0.0f, 1.0f,
        };

        bool pass = true;

        glClearColor(.5f, .5f, .5f, 1.f);
        glClear(GL_COLOR_BUFFER_BIT);

        for (i = 0; i < ARRAY_SIZE(vs_programs); i++) {
                const GLint loc =
                        glGetUniformLocation(vs_programs[i], "transform");

                glProgramUniformMatrix4fv(vs_programs[i], loc, 1, GL_TRUE,
                                          transform);
        }

        glBindProgramPipeline(pipe);

        for (i = 0; i < ARRAY_SIZE(combinations); i++) {
                const unsigned row = combinations[i].row;
                const unsigned col = combinations[i].col;

                glUseProgramStages(pipe, GL_VERTEX_SHADER_BIT,
                                   vs_programs[col]);
                glUseProgramStages(pipe, GL_FRAGMENT_SHADER_BIT,
                                   fs_programs[row]);
                glDrawArrays(GL_TRIANGLE_FAN, row * 4, 4);
        }

        glBindProgramPipeline(0);

        for (i = 0; i < ARRAY_SIZE(vs_programs); i++) {
                for (j = 0; j < ARRAY_SIZE(fs_programs); j++) {
                        const unsigned x = (i * tile_size)
                                + ((i + 1) * border_size);
                        const unsigned y = (j * tile_size)
                                + ((j + 1) * border_size);

                        pass = piglit_probe_rect_rgba(x, y,
                                                      tile_size, tile_size,
                                                      expected)
                                && pass;
                }
        }

        piglit_present_results();
        return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}

#define RED(x)    ((int) (x / 2))
#define GREEN(x)  (-(int) x)
#define BLUE(x)   ((int) (x * 7))

void
piglit_init(int argc, char **argv)
{
        unsigned glsl_version;
        unsigned i;
        unsigned j;
        unsigned idx;
        const char *location;
        const char *vertex_name;
        const char *fragment_name;

        struct vertex {
                float x;
                float y;
                float r;
                float g;
                float b;
        } *vert;

        piglit_require_extension("GL_ARB_separate_shader_objects");
        piglit_require_extension("GL_ARB_explicit_attrib_location");

        if (argc > 1 && strcmp(argv[1], "--by-location") == 0) {
                location = "layout(location = 3)";
                vertex_name = "a";
                fragment_name = "b";
        } else {
                location = "";
                vertex_name = "in_color";
                fragment_name = "in_color";
        }

        glsl_version = pick_a_glsl_version();

        /* Generate the vertex shader programs.  Each vertex shader is
         * hardcoded to select a specific column on the display.
         */
        printf("Generating vertex shaders...\n");
        for (i = 0; i < ARRAY_SIZE(vs_programs); i++) {
                const unsigned base_x = (i * tile_size)
                        + ((i + 1) * border_size);

                char *source = NULL;

                (void)!asprintf(&source, vs_code,
                         glsl_version,
                         location,
                         vertex_name,
                         base_x,
                         vertex_name);

                vs_programs[i] =
                        glCreateShaderProgramv(GL_VERTEX_SHADER, 1,
                                               (const GLchar *const *) &source);
                piglit_link_check_status(vs_programs[i]);

                if (i == 0)
                        puts(source);

                free(source);
        }

        printf("Generating fragment shaders...\n");
        for (i = 0; i < ARRAY_SIZE(fs_programs); i++) {
                char *source = NULL;

                (void)!asprintf(&source, fs_code,
                         glsl_version,
                         location,
                         fragment_name,
                         RED(i), GREEN(i), BLUE(i),
                         fragment_name);

                fs_programs[i] =
                        glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1,
                                               (const GLchar *const *) &source);
                piglit_link_check_status(fs_programs[i]);

                if (i == 3)
                        puts(source);

                free(source);
        }

        glGenProgramPipelines(1, &pipe);

        /* Generate vertex data for the tests.  The row of each block is
         * determined by the vertex data.  The color data for the block comes
         * from the vertex data and the data baked into the fragment shader.
         */
        if (piglit_get_gl_version() >= 30
            || piglit_is_extension_supported("GL_ARB_vertex_array_object")) {
                glGenVertexArrays(1, &vao);
                glBindVertexArray(vao);
        }

        glGenBuffers(1, &bo);
        glBindBuffer(GL_ARRAY_BUFFER, bo);
        glBufferData(GL_ARRAY_BUFFER,
                     sizeof(vert[0]) * 4 * ARRAY_SIZE(fs_programs),
                     NULL, GL_STATIC_DRAW);

        vert = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);

        for (i = 0; i < ARRAY_SIZE(fs_programs); i++) {
                const unsigned base_y = (i * tile_size)
                        + ((i + 1) * border_size);

                vert[(i * 4) + 0].x = 0.f;
                vert[(i * 4) + 0].y = (float) base_y;
                vert[(i * 4) + 0].r = (float) -RED(i);
                vert[(i * 4) + 0].g = (float) 1 - GREEN(i);
                vert[(i * 4) + 0].b = (float) -BLUE(i);

                vert[(i * 4) + 1].x = (float) tile_size;
                vert[(i * 4) + 1].y = (float) base_y;
                vert[(i * 4) + 1].r = (float) -RED(i);
                vert[(i * 4) + 1].g = (float) 1 - GREEN(i);
                vert[(i * 4) + 1].b = (float) -BLUE(i);

                vert[(i * 4) + 2].x = (float) tile_size;
                vert[(i * 4) + 2].y = (float) (base_y + tile_size);
                vert[(i * 4) + 2].r = (float) -RED(i);
                vert[(i * 4) + 2].g = (float) 1 - GREEN(i);
                vert[(i * 4) + 2].b = (float) -BLUE(i);

                vert[(i * 4) + 3].x = 0.f;
                vert[(i * 4) + 3].y = (float) (base_y + tile_size);
                vert[(i * 4) + 3].r = (float) -RED(i);
                vert[(i * 4) + 3].g = (float) 1 - GREEN(i);
                vert[(i * 4) + 3].b = (float) -BLUE(i);
        }

        glUnmapBuffer(GL_ARRAY_BUFFER);

        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(vert[0]),
                              (void *)(intptr_t) offsetof(struct vertex, x));
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vert[0]),
                              (void *)(intptr_t) offsetof(struct vertex, r));
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);

        /* Generate the set of combinations of vertex shader programs and
         * fragment shader programs that will be used together.  This is all
         * the possible combinations.  The next step is to shuffle list so
         * that there's (hopefully) no pattern to the access combination... to
         * uncover driver bugs.
         */
        idx = 0;
        for (i = 0; i < ARRAY_SIZE(vs_programs); i++) {
                for (j = 0; j < ARRAY_SIZE(fs_programs); j++) {
                        combinations[idx].row = j;
                        combinations[idx].col = i;
                        idx++;
                }
        }

        for (i = ARRAY_SIZE(combinations); i > 1; i--) {
                const unsigned j = rand() % i;

                if (j != i - 1) {
                        const struct combination temp = combinations[j];
                        combinations[j] = combinations[i - 1];
                        combinations[i - 1] = temp;
                }
        }
}