glsl: test loop unroll with uint overflow

[piglit.git] / tests / spec / ext_framebuffer_multisample / formats.cpp

/*
 * 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.
 */

/**
 * \file formats.cpp
 *
 * Verify the proper functioning of multisample antialiasing for all
 * possible buffer formats.
 *
 * This test operates by rendering an MSAA image twice: once in a
 * standard RGBA buffer (the behaviour of which is well tested by the
 * other MSAA tests), and once in a buffer with some other format.
 * Then it blits both images to corresponding single-sample buffers
 * and uses glReadPixels to make sure the same image was drawn in both
 * cases (to within the expected tolerance considering the bit depth
 * of the two images).
 *
 * Finally, the images that were compared are drawn on screen to make
 * it easier to diagnose failures.
 *
 * When testing sRGB formats, the reference image is rendered using
 * SRGB8_ALPHA8 format rather than RGBA format (SRGB8_ALPHA8 format is
 * also well tested by the other MSAA tests).
 */

#include "common.h"
#include "../../fbo/fbo-formats.h"
using namespace piglit_util_fbo;
using namespace piglit_util_test_pattern;

PIGLIT_GL_TEST_CONFIG_BEGIN

        config.supports_gl_compat_version = 10;

        config.window_width = 512;
        config.window_height = 256;
        config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
        config.khr_no_error_support = PIGLIT_NO_ERRORS;

PIGLIT_GL_TEST_CONFIG_END

namespace {

const int pattern_width = 256; const int pattern_height = 256;

bool all_samples = false;
int num_samples;
GLint max_samples;

ColorGradientSunburst *test_pattern_vec4;
ColorGradientSunburst *test_pattern_ivec4;
ColorGradientSunburst *test_pattern_uvec4;

struct int_resolve_check_s {
        GLuint prog;
        GLint u_resolve;
        GLint u_msaa;
        GLint u_samples;
} int_resolve_check;

const char int_resolve_check_vs[] =
        "#version 130\n"
        "in vec4 piglit_vertex;\n"
        "void main() {\n"
        "       gl_Position = piglit_vertex;\n"
        "}\n";

/* The OpenGL ES 3.2 and OpenGL 4.4 specs both state:
 *
 *      "If the source formats are integer types or stencil values, a
 *      single sample's value is selected for each pixel."
 *
 * This shader checks exactly that condition, namely that the result of the
 * resolve is exactly one of the sample values in the original image.
 */
const char int_resolve_check_fs[] =
        "#version 130\n"
        "#extension GL_ARB_texture_multisample: require\n"
        "uniform isampler2DMS msaa;\n"
        "uniform isampler2D resolve;\n"
        "uniform int samples;\n"
        "void main() {\n"
        "       gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
        "       const vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
        "       ivec2 pos = ivec2(gl_FragCoord.xy);\n"
        "       ivec4 res = texelFetch(resolve, pos, 0);\n"
        "       for (int s = 0; s < samples; s++) {\n"
        "               if (res == texelFetch(msaa, pos, s)) {\n"
        "                       gl_FragColor = green;\n"
        "                       break;\n"
        "               }\n"
        "       }\n"
        "}\n";

/**
 * This class encapsulates the code necessary to draw the test pattern
 * in either the reference GL_RGBA format or the format under test,
 * downsample it, read the rendered pixels into memory, and draw a
 * visualization of the result.
 */
class PatternRenderer
{
public:
        bool try_setup(GLenum internalformat, bool is_integer);
        void set_piglit_tolerance();
        void set_color_clamping_mode();
        void draw();
        float *read_image(GLenum base_format);

        /**
         * Number of bits in each color channel.  E.g. color_bits[2]
         * == number of bits in blue color channel.
         */
        GLint color_bits[4];

        /**
         * Type of data in the color buffer.  E.g. GL_FLOAT,
         * GL_UNSIGNED_NORMALIZED, or GL_UNSIGNED_INT.
         */
        GLenum component_type;

        /**
         * True if the color buffer uses an sRGB format.
         */
        bool is_srgb;

        /**
         * ColorGradientSunburst object that will be used to draw the
         * test pattern.
         */
        ColorGradientSunburst *test_pattern;

        /**
         * Color offset that will be used to draw the test pattern.
         */
        float color_offset;

        /**
         * Color scale factor that will be used to draw the test
         * pattern.
         */
        float color_scale;

        /**
         * Color clamping setting that should be used for this test.
         * Normally GL_FIXED_ONLY (the default setting) works fine,
         * however the GL spec mandates that signed normalized formats
         * be clamped to [0, 1] when in GL_FIXED_ONLY mode.  So when
         * testing signed normalized formats, this is GL_FALSE.
         */
        GLenum color_clamping_mode;

        Fbo fbo_msaa;
        Fbo fbo_downsampled;
};


/**
 * Try to set up the necessary framebuffers to render to the given
 * MSAA format.  Return false if one or more of the framebuffers is
 * incomplete.
 */
bool
PatternRenderer::try_setup(GLenum internalformat, bool is_integer)
{
        FboConfig config_downsampled(0, pattern_width, pattern_height);
        config_downsampled.color_internalformat = internalformat;

        if (is_integer) {
                config_downsampled.color_format = GL_RGBA_INTEGER;
                config_downsampled.num_rb_attachments = 0;
                config_downsampled.num_tex_attachments = 1;
                config_downsampled.use_rect = false;
        }

        FboConfig config_msaa = config_downsampled;
        config_msaa.num_samples = num_samples;

        if (!(fbo_downsampled.try_setup(config_downsampled) &&
              fbo_msaa.try_setup(config_msaa)))
                return false;

        glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_downsampled.handle);
        glGetFramebufferAttachmentParameteriv(
                GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, &color_bits[0]);
        glGetFramebufferAttachmentParameteriv(
                GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, &color_bits[1]);
        glGetFramebufferAttachmentParameteriv(
                GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, &color_bits[2]);
        glGetFramebufferAttachmentParameteriv(
                GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, &color_bits[3]);
        glGetFramebufferAttachmentParameteriv(
                GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE,
                (GLint *) &component_type);

        piglit_get_luminance_intensity_bits(internalformat, color_bits);

        int num_bits = 0;
        for (int i = 0; i < 4 && !num_bits; i++)
                num_bits = color_bits[i];
        if (!num_bits) {
                printf("Red, green, blue, and alpha sizes are all zero.\n");
                return false;
        }

        color_clamping_mode = GL_FIXED_ONLY;
        switch (component_type) {
        case GL_INT:
                assert(test_pattern_ivec4);
                test_pattern = test_pattern_ivec4;
                color_offset = 1.0 - pow(2.0, num_bits - 1);
                color_scale = -2.0 * color_offset;
                break;
        case GL_UNSIGNED_INT:
                assert(test_pattern_uvec4);
                test_pattern = test_pattern_uvec4;
                color_scale = pow(2.0, num_bits) - 1.0;
                color_offset = 0.0;
                break;
        case GL_UNSIGNED_NORMALIZED:
                test_pattern = test_pattern_vec4;
                color_offset = 0.0;
                color_scale = 1.0;
                break;
        case GL_FLOAT:
                /* Test floating point formats to a (rather arbitrary)
                 * range of [-10.0, 10.0], to make sure no extraneous
                 * clamping occurs.  Exception: GL_R11F_G11F_B10F_EXT
                 * and GL_RGB9_E5_EXT are unsigned, so they are tested
                 * to a range of [0.0, 10.0].
                 */
                test_pattern = test_pattern_vec4;
                if (internalformat == GL_R11F_G11F_B10F_EXT ||
                    internalformat == GL_RGB9_E5_EXT) {
                        color_offset = 0.0;
                        color_scale = 10.0;
                } else {
                        color_offset = -10.0;
                        color_scale = 20.0;
                }
                break;
        case GL_SIGNED_NORMALIZED:
                test_pattern = test_pattern_vec4;
                color_offset = -1.0;
                color_scale = 2.0;
                color_clamping_mode = GL_FALSE;
                break;
        default:
                printf("Unrecognized component type: %s\n",
                       piglit_get_gl_enum_name(component_type));
                piglit_report_result(PIGLIT_FAIL);
        }

        GLint color_encoding;
        glGetFramebufferAttachmentParameteriv(
                GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &color_encoding);
        is_srgb = color_encoding == GL_SRGB;

        return true;
}


/**
 * Return the number of mantissa bits available in an n-bit floating
 * point format.
 */
int
get_mantissa_bits(int n)
{
        switch (n) {
        case 32: return 23;
        case 16: return 10;
        case 11: return 6;
        case 10: return 5;
        case 0: return 0; /* Unused channel */
        default:
                printf("Unrecognized floating point format (%d bits)\n", n);
                piglit_report_result(PIGLIT_FAIL);
                return 0;
        }
}


/**
 * Set the piglit tolerance appropriately based on the number of bits
 * in each channel.
 */
void PatternRenderer::set_piglit_tolerance()
{
        int tolerance_bits[4];

        for (int i = 0; i < 4; ++i) {
                int bits = color_bits[i];
                if (component_type == GL_FLOAT) {
                        /* We only want to count mantissa bits for the
                         * purpose of setting the test tolerance.
                         */
                        bits = get_mantissa_bits(bits);
                }
                if (bits == 0) {
                        /* For channels that have 0 bits, test to 8
                         * bits precision so we can verify that the
                         * blit puts in the appropriate value.
                         */
                        tolerance_bits[i] = 8;
                } else if (bits > 8) {
                        /* For channels that have >8 bits, test to 8
                         * bits precision because we only use an 8-bit
                         * reference image.
                         */
                        tolerance_bits[i] = 8;
                } else {
                        tolerance_bits[i] = bits;
                }
        }

        piglit_set_tolerance_for_bits(tolerance_bits[0], tolerance_bits[1],
                                      tolerance_bits[2], tolerance_bits[3]);
}


/**
 * Set up the appropriate color clamping mode for testing this format.
 */
void
PatternRenderer::set_color_clamping_mode()
{
        glClampColor(GL_CLAMP_FRAGMENT_COLOR, color_clamping_mode);
        glClampColor(GL_CLAMP_READ_COLOR, color_clamping_mode);
}


/**
 * Draw the test pattern into the MSAA framebuffer, and then blit it
 * to the downsampled FBO to force an MSAA resolve.
 */
void
PatternRenderer::draw()
{
        /* Draw into the MSAA fbo */
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_msaa.handle);
        fbo_msaa.set_viewport();
        set_color_clamping_mode();
        test_pattern->draw_with_scale_and_offset(TestPattern::no_projection,
                                                 color_scale, color_offset);

        /* Blit to the downsampled fbo, forcing the image to be downsampled */
        glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_msaa.handle);
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_downsampled.handle);
        glBlitFramebuffer(0, 0, pattern_width, pattern_height,
                          0, 0, pattern_width, pattern_height,
                          GL_COLOR_BUFFER_BIT, GL_NEAREST);
}


/**
 * Return the integer base format corresponding to a given base
 * format.
 */
GLenum
integer_base_format(GLenum base_format)
{
        switch (base_format) {
        case GL_RED:
                return GL_RED_INTEGER_EXT;
        case GL_RG:
                return GL_RG_INTEGER;
        case GL_RGB:
                return GL_RGB_INTEGER;
        case GL_RGBA:
                return GL_RGBA_INTEGER;
        case GL_ALPHA:
                return GL_ALPHA_INTEGER;
        case GL_LUMINANCE:
                return GL_LUMINANCE_INTEGER_EXT;
        case GL_LUMINANCE_ALPHA:
                return GL_LUMINANCE_ALPHA_INTEGER_EXT;
        default:
                printf("Unexpected integer base_format: %s\n",
                       piglit_get_gl_enum_name(base_format));
                piglit_report_result(PIGLIT_FAIL);
                return 0;
        }
}


/**
 * Read the image from the downsampled FBO into a newly allocated
 * array of floats and return it.
 */
float *
PatternRenderer::read_image(GLenum base_format)
{
        unsigned components = piglit_num_components(base_format);
        unsigned array_size = components*pattern_width*pattern_height;
        float *image = (float *) malloc(sizeof(float)*array_size);
        glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_downsampled.handle);
        set_color_clamping_mode();
        if (base_format == GL_INTENSITY) {
                /* GL_INTENSITY is not allowed for ReadPixels so
                 * substitute GL_LUMINANCE.
                 */
                base_format = GL_LUMINANCE;
        }
        if (component_type == GL_INT || component_type == GL_UNSIGNED_INT) {
                int *tmp = (int *) malloc(sizeof(int)*array_size);
                glReadPixels(0, 0, pattern_width, pattern_height,
                             integer_base_format(base_format),
                             component_type, tmp);
                if (component_type == GL_INT) {
                        for (unsigned i = 0; i < array_size; ++i)
                                image[i] = tmp[i];
                } else {
                        for (unsigned i = 0; i < array_size; ++i)
                                image[i] = (unsigned) tmp[i];
                }
                free(tmp);
        } else {
                glReadPixels(0, 0, pattern_width, pattern_height, base_format,
                             GL_FLOAT, image);
        }
        for (unsigned i = 0; i < array_size; ++i)
                image[i] = (image[i] - color_offset) / color_scale;
        return image;
}


/**
 * PatternRenderer used to render the image under test.
 */
PatternRenderer test_renderer;


/**
 * PatternRenderer used to render the reference image (in GL_RGBA
 * format).
 */
PatternRenderer ref_renderer;


/**
 * Transform the reference image (which is in GL_RGBA format) to an
 * expected image for a given base internal format, using the the
 * transformation described in the GL 3.0 spec, table 3.15 (Conversion
 * from RGBA, depth, and stencil pixel components to internal texture,
 * table, or filter components).  In short, the mapping is as follows:
 *
 * base_internal_format  mapping
 * GL_ALPHA              A -> A
 * GL_LUMINANCE          R -> L
 * GL_LUMINANCE_ALPHA    R,A -> L,A
 * GL_INTENSITY          R -> I
 * GL_RED                R -> R
 * GL_RG                 R,G -> R,G
 * GL_RGB                R,G,B -> R,G,B
 * GL_RGBA               R,G,B,A -> R,G,B,A
 */
float *
compute_expected_image(const float *ref_image, GLenum base_internal_format)
{
        unsigned components = piglit_num_components(base_internal_format);
        unsigned num_pixels = pattern_width*pattern_height;
        unsigned size = sizeof(float)*components*num_pixels;
        float *expected_image = (float *) malloc(size);
        for (unsigned i = 0; i < num_pixels; ++i) {
                float *expected = &expected_image[components*i];
                const float *ref = &ref_image[4*i];
                for (unsigned j = 0; j < components; ++j) {
                        switch (base_internal_format) {
                        case GL_ALPHA:
                                expected[j] = ref[3];
                                break;
                        case GL_LUMINANCE_ALPHA:
                                expected[j] = ref[j ? 3 : 0];
                                break;
                        default:
                                expected[j] = ref[j];
                                break;
                        }
                }
        }
        return expected_image;
}


/**
 * Test a given internal format.
 */
enum piglit_result
test_format(const struct format_desc *format)
{
        bool pass = true;

        if (format->internalformat == 3 ||
            format->internalformat == 4) {
                return PIGLIT_SKIP;
        }

        /* Caller messes with the clear color.  Reset it to the
         * default.
         */
        glClearColor(0, 0, 0, 0);

        printf("Testing %s\n", get_format_name(format->internalformat));

        /* Set up the framebuffers for rendering the test image.  This
         * might fail if the format we're testing isn't supported as a
         * render target, and that's ok.
         *
         * Note: in order to be sure we test all formats which the
         * implementations supports as render targets, we try all of
         * them, even formats that the spec doesn't define as
         * color-renderable (e.g. GL_LUMINANCE8, which is supported as
         * a render target format by some drivers even though it's not
         * officially color-renderable).  If we tried to request a
         * color-renderable format and it wasn't supported, we would
         * expect the framebuffer to be incomplete.  If we tried to
         * request a non-color-renderable format and it wasn't
         * supported, we might have received a GL error.  In either
         * case just skip to the next format.
         */
        bool is_integer = (test_sets[test_index].basetype == GL_INT);
        bool setup_success = test_renderer.try_setup(format->internalformat,
                                                     is_integer);
        if (glGetError() != GL_NO_ERROR) {
                printf("Error setting up test renderbuffers\n");
                return PIGLIT_SKIP;
        }
        if (!setup_success) {
                printf("Unsupported framebuffer combination\n");
                return PIGLIT_SKIP;
        }

        /* Set up the framebuffers for rendering the reference image.
         * This shouldn't fail.
         */
        setup_success = ref_renderer.try_setup(test_renderer.is_srgb ?
                                               GL_SRGB8_ALPHA8 : GL_RGBA,
                                               false);
        if (!piglit_check_gl_error(GL_NO_ERROR)) {
                printf("Error setting up reference renderbuffers\n");
                return PIGLIT_FAIL;
        }
        if (!setup_success) {
                printf("Reference framebuffer combination is unsupported\n");
                return PIGLIT_FAIL;
        }

        test_renderer.draw();
        float *test_image =
                test_renderer.read_image(format->base_internal_format);

        if (is_integer) {
                Fbo compare_fbo;
                compare_fbo.setup(FboConfig(0, pattern_width, pattern_height));

                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, compare_fbo.handle);

                glUseProgram(int_resolve_check.prog);
                glUniform1i(int_resolve_check.u_msaa, 0);
                glUniform1i(int_resolve_check.u_resolve, 1);
                glUniform1i(int_resolve_check.u_samples, num_samples);

                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_2D_MULTISAMPLE,
                              test_renderer.fbo_msaa.color_tex[0]);

                glActiveTexture(GL_TEXTURE1);
                glBindTexture(GL_TEXTURE_2D,
                              test_renderer.fbo_downsampled.color_tex[0]);

                glViewport(0, 0, pattern_width, pattern_height);
                piglit_draw_rect(-1.0, -1.0, 2.0, 2.0);

                glBindFramebuffer(GL_READ_FRAMEBUFFER, compare_fbo.handle);

                const float green[] = { 0.0, 1.0, 0.0, 1.0 };
                pass = piglit_probe_rect_rgb(0, 0, pattern_width,
                                             pattern_height, green);

                /* Show both the test image and the check result on screen
                 * so that the user can diagnose problems.
                 */
                glViewport(0, 0, piglit_width, piglit_height);
                piglit_visualize_image(test_image, format->base_internal_format,
                                       pattern_width, pattern_height,
                                       0 /* image_count */,
                                       false /* rhs */);

                glBindFramebuffer(GL_READ_FRAMEBUFFER, compare_fbo.handle);
                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, piglit_winsys_fbo);
                glBlitFramebuffer(0, 0, pattern_width, pattern_height,
                                  pattern_width, 0,
                                  pattern_width * 2, pattern_height,
                                  GL_COLOR_BUFFER_BIT, GL_NEAREST);
        } else {
                /* Draw test and reference images, and read them into memory */
                test_renderer.set_piglit_tolerance();
                ref_renderer.draw();
                float *ref_image = ref_renderer.read_image(GL_RGBA);

                /* Compute the expected image from the reference image */
                float *expected_image =
                        compute_expected_image(ref_image,
                                               format->base_internal_format);

                /* Check that the test image was correct */
                unsigned num_components =
                        piglit_num_components(format->base_internal_format);
                float tolerance[4];
                piglit_compute_probe_tolerance(format->base_internal_format,
                                               tolerance);
                pass = piglit_compare_images_color(0, 0, pattern_width,
                                                   pattern_height,
                                                   num_components, tolerance,
                                                   expected_image, test_image);


                /* Show both the test and expected images on screen so that
                 * the user can diagnose problems. Pass image_count = 0 to
                 * display image without any offset applied to raster position.
                 */
                glViewport(0, 0, piglit_width, piglit_height);
                piglit_visualize_image(test_image, format->base_internal_format,
                                       pattern_width, pattern_height,
                                       0 /* image_count */,
                                       false /* rhs */);
                piglit_visualize_image(expected_image,
                                       format->base_internal_format,
                                       pattern_width, pattern_height,
                                       0 /* image_count */,
                                       true /* rhs */);

                free(ref_image);
                free(expected_image);
        }

        /* Finally, if any error occurred, count that as a failure. */
        pass = piglit_check_gl_error(GL_NO_ERROR) && pass;

        free(test_image);

        return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}


void
print_usage_and_exit(char *prog_name)
{
        printf("Usage: %s <sample_arg> [test_set]\n"
               "  where <sample_arg> is one of:\n"
               "    <num_samples>: test supplied sample count\n"
               "    all_samples: test all power of 2 samples\n" , prog_name);
        piglit_report_result(PIGLIT_FAIL);
}


extern "C" void
piglit_init(int argc, char **argv)
{
        if (argc < 2 || argc > 3)
                print_usage_and_exit(argv[0]);

        /* First argument (required): num_samples */
        char *endptr = NULL;
        if (streq(argv[1], "all_samples"))
                all_samples = true;
        else {
                num_samples = strtol(argv[1], &endptr, 0);
                if (endptr != argv[1] + strlen(argv[1]))
                        print_usage_and_exit(argv[0]);
        }

        /* Second argument (optional): test_set */
        int test_set = 0; /* Default to core */
        if (argc == 3)
                test_set = fbo_lookup_test_set(argv[2]);

        piglit_require_gl_version(21);
        piglit_require_extension("GL_ARB_framebuffer_object");
        piglit_require_extension("GL_ARB_vertex_array_object");

        /* Skip the test if num_samples > GL_MAX_SAMPLES */
        glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
        if (num_samples > max_samples)
                piglit_report_result(PIGLIT_SKIP);

        fbo_formats_init_test_set(test_set,
                                  GL_TRUE /* print_options */);

        bool is_integer = (test_sets[test_index].basetype == GL_INT);

        test_pattern_vec4 = new ColorGradientSunburst(GL_UNSIGNED_NORMALIZED);
        test_pattern_vec4->compile();
        if (is_integer) {
                piglit_require_gl_version(30);
                piglit_require_extension("GL_ARB_texture_multisample");

                test_pattern_ivec4 = new ColorGradientSunburst(GL_INT);
                test_pattern_ivec4->compile();
                test_pattern_uvec4 = new ColorGradientSunburst(GL_UNSIGNED_INT);
                test_pattern_uvec4->compile();

                int_resolve_check.prog =
                        piglit_build_simple_program(int_resolve_check_vs,
                                                    int_resolve_check_fs);
                glUseProgram(int_resolve_check.prog);
                int_resolve_check.u_resolve =
                        glGetUniformLocation(int_resolve_check.prog, "resolve");
                int_resolve_check.u_msaa =
                        glGetUniformLocation(int_resolve_check.prog, "msaa");
                int_resolve_check.u_samples =
                        glGetUniformLocation(int_resolve_check.prog, "samples");
        }
}

extern "C" enum piglit_result
piglit_display()
{
        piglit_result result = PIGLIT_PASS;
        bool pass = true;

        if (!all_samples) {
                return fbo_formats_display(test_format);
        }

        for (num_samples = 0; num_samples <= max_samples; ) {
                result = fbo_formats_display(test_format);
                printf("Samples = %d, Result = %s\n", num_samples,
                       piglit_result_to_string(result));

                num_samples = num_samples ? num_samples << 1 : num_samples + 2;

                if (result == PIGLIT_SKIP)
                        return result;

                pass = (result == PIGLIT_PASS) && pass;
        }
        return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}

};