glsl-1.10/built-in-uniform-state: don't test Infs due to undefined behavior

[piglit.git] / tests / spec / glsl-1.10 / execution / built-in-uniform-state.c

/*
 * Copyright © 2017 Fabian Bieler
 *
 * 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 built-in-uniform-state.c:  Access uniform state in GLSL
 *
 * Set uniform state with the OpenGL API and access it in GLSL shaders.
 */

#include "piglit-util-gl.h"

PIGLIT_GL_TEST_CONFIG_BEGIN

        config.supports_gl_compat_version = 20;
        config.window_visual = PIGLIT_GL_VISUAL_RGB;
        config.khr_no_error_support = PIGLIT_NO_ERRORS;

PIGLIT_GL_TEST_CONFIG_END

#ifdef _WIN32
#define SRAND(x) srand(x)
#define DRAND() ((float)rand() / RAND_MAX)
#else
#define SRAND(x) srand48(x)
#define DRAND() drand48()
#endif

static const char *vs_text =
        "void main() {\n"
        "   gl_Position = gl_Vertex;\n"
        "}\n";
static const char *fs_float =
        "void main() {\n"
        "   float epsilon = 1.0 / 256.0;\n"
        "   vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
        "   vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
        "   float a = %s;\n"
        "   float b = %f;\n"
        "   gl_FragColor = abs(a - b) < epsilon ? green : red;\n"
        "}\n";
static const char *fs_vec3 =
        "void main() {\n"
        "   vec3 epsilon = vec3(1.0 / 256.0);\n"
        "   vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
        "   vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
        "   vec3 a = %s;\n"
        "   vec3 b = vec3(%f, %f, %f);\n"
        "   gl_FragColor = all(lessThan(abs(a - b), epsilon)) ? green : red;\n"
        "}\n";
static const char *fs_vec4 =
        "void main() {\n"
        "   vec4 epsilon = vec4(1.0 / 256.0);\n"
        "   vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
        "   vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
        "   vec4 a = %s;\n"
        "   vec4 b = vec4(%f, %f, %f, %f);\n"
        "   gl_FragColor = all(lessThan(abs(a - b), epsilon)) ? green : red;\n"
        "}\n";

/**
 * Check that the built-in shader uniform \name of type \type is equal to \val
 *
 * Since we also test for derived state involving floating point computation
 * don't test for strict equality but rather only check if the uniform's
 * components are within and espilon of their expected values.
 */
static bool
check_shader_builtin_(const GLenum type, const float *val, const char *name)
{
        char *fs_text;
        const float green[3] = {0.0, 1.0, 0.0};

        switch (type) {
        case GL_FLOAT:
                asprintf(&fs_text, fs_float, name, *val);
                break;
        case GL_FLOAT_VEC3:
                asprintf(&fs_text, fs_vec3, name, val[0], val[1], val[2]);
                break;
        case GL_FLOAT_VEC4:
                asprintf(&fs_text, fs_vec4, name, val[0], val[1], val[2],
                         val[3]);
                break;
        default:
                assert(0);
        }

        const GLuint program = piglit_build_simple_program(vs_text, fs_text);
        free(fs_text);
        glUseProgram(program);
        glDeleteProgram(program);
        glClear(GL_COLOR_BUFFER_BIT);
        piglit_draw_rect(-1, -1, 2, 2);

        if (piglit_probe_pixel_rgb_silent(piglit_width / 2, piglit_height / 2,
                                          green, NULL))
                return true;
        printf("Failed uniform: '%s'.\n", name);
        return false;
}

/**
 * printf-like version of function above.
 */
static bool
check_shader_builtin(const GLenum type, const float *val, const char *format,
                     ...) PRINTFLIKE(3, 4);
static bool
check_shader_builtin(const GLenum type, const float *val, const char *format,
                     ...)
{
        char *name;
        va_list ap;

        va_start(ap, format);
        vasprintf(&name, format, ap);
        va_end(ap);

        const bool r = check_shader_builtin_(type, val, name);
        free(name);
        return r;
}

static void
normalize(float *v)
{
        const float norm = sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
        for (int i = 0; i < 3; ++i)
                v[i] /= norm;
}

static void
random_vec4(float *v)
{
        for (int i = 0; i < 4; ++i)
                v[i] = DRAND();
}

/**
 * Get name fragment used in GLSL for GLenum \pname.
 */
static const char *
enum2glsl(const GLenum pname)
{
        switch (pname) {
        case GL_EMISSION:
                return "emission";
        case GL_AMBIENT:
                return "ambient";
        case GL_DIFFUSE:
                return "diffuse";
        case GL_SPECULAR:
                return "specular";
        case GL_POSITION:
                return "position";
        case GL_SPOT_EXPONENT:
                return "spotExponent";
        case GL_SPOT_CUTOFF:
                return "spotCutoff";
        case GL_CONSTANT_ATTENUATION:
                return "constantAttenuation";
        case GL_LINEAR_ATTENUATION:
                return "linearAttenuation";
        case GL_QUADRATIC_ATTENUATION:
                return "quadraticAttenuation";
        case GL_S:
                return "S";
        case GL_T:
                return "T";
        case GL_R:
                return "R";
        case GL_Q:
                return "Q";
        default:
                assert(!"unexpected pname");
                return "";
        }
}

enum piglit_result
piglit_display(void)
{
        bool pass = true;
        float val[4];

        /* Depth range */
        val[0] = DRAND();
        val[1] = DRAND();
        const float diff = val[1] - val[0];
        glDepthRangef(val[0], val[1]);
        pass = check_shader_builtin(GL_FLOAT, val, "gl_DepthRange.near") &&
               pass;
        pass = check_shader_builtin(GL_FLOAT, &val[1], "gl_DepthRange.far") &&
               pass;
        pass = check_shader_builtin(GL_FLOAT, &diff, "gl_DepthRange.diff") &&
               pass;

        /* Clip planes */
        int max_clip_planes;
        glGetIntegerv(GL_MAX_CLIP_PLANES, &max_clip_planes);
        for (int cp = 0; cp < max_clip_planes; ++cp) {
                double vald[4];
                for (int c = 0; c < 4; ++c)
                        vald[c] = val[c] = DRAND();
                glClipPlane(GL_CLIP_PLANE0 + cp, vald);
                pass = check_shader_builtin(GL_FLOAT_VEC4, val,
                                            "gl_ClipPlane[%d]", cp) &&
                       pass;
        }

        /* Point Size */
        val[0] = DRAND();
        glPointSize(val[0]);
        pass = check_shader_builtin(GL_FLOAT, val, "gl_Point.size") && pass;

        val[0] = DRAND();
        glPointParameterf(GL_POINT_SIZE_MIN, val[0]);
        pass = check_shader_builtin(GL_FLOAT, val, "gl_Point.sizeMin") &&
               pass;

        val[0] = DRAND();
        glPointParameterf(GL_POINT_SIZE_MAX, val[0]);
        pass = check_shader_builtin(GL_FLOAT, val, "gl_Point.sizeMax") &&
               pass;

        val[0] = DRAND();
        glPointParameterf(GL_POINT_FADE_THRESHOLD_SIZE, val[0]);
        pass = check_shader_builtin(GL_FLOAT, val,
                                    "gl_Point.fadeThresholdSize") &&
               pass;

        val[0] = DRAND();
        val[1] = DRAND();
        val[2] = DRAND();
        glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, val);
        pass = check_shader_builtin(GL_FLOAT, &val[0],
                                    "gl_Point.distanceConstantAttenuation") &&
               pass;
        pass = check_shader_builtin(GL_FLOAT, &val[1],
                                    "gl_Point.distanceLinearAttenuation") &&
               pass;
        pass = check_shader_builtin(
                       GL_FLOAT, &val[2],
                       "gl_Point.distanceQuadraticAttenuation") &&
               pass;

        /* Material State */
        for (int s = 0; s < 2; ++s) {
                for (int p = 0; p < 4; ++p) {
                        const GLenum pname[] = {GL_EMISSION, GL_AMBIENT,
                                                GL_DIFFUSE, GL_SPECULAR};

                        random_vec4(val);
                        glMaterialfv(GL_FRONT + s, pname[p], val);
                        pass = check_shader_builtin(GL_FLOAT_VEC4, val,
                                                    "gl_%sMaterial.%s",
                                                    s ? "Back" : "Front",
                                                    enum2glsl(pname[p])) &&
                               pass;
                }

                val[0] = DRAND();
                glMaterialf(GL_FRONT + s, GL_SHININESS, val[0]);
                pass = check_shader_builtin(GL_FLOAT, val,
                                            "gl_%sMaterial.shininess",
                                            s ? "Back" : "Front") &&
                       pass;
        }

        /* Light State */
        int max_lights;
        glGetIntegerv(GL_MAX_LIGHTS, &max_lights);
        for (int l = 0; l < max_lights; ++l) {
                for (int p = 0; p < 4; ++p) {
                        const GLenum pname[] = {GL_AMBIENT, GL_DIFFUSE,
                                                GL_SPECULAR, GL_POSITION};
                        random_vec4(val);
                        glLightfv(GL_LIGHT0 + l, pname[p], val);
                        pass = check_shader_builtin(GL_FLOAT_VEC4, val,
                                                    "gl_LightSource[%d].%s",
                                                    l, enum2glsl(pname[p])) &&
                               pass;
                }

                random_vec4(val);
                glLightfv(GL_LIGHT0 + l, GL_SPOT_DIRECTION, val);
                pass = check_shader_builtin(
                               GL_FLOAT_VEC3, val,
                               "gl_LightSource[%d].spotDirection", l) &&
                       pass;

                for (int p = 0; p < 5; ++p) {
                        const GLenum pname[] = {GL_SPOT_EXPONENT,
                                                GL_SPOT_CUTOFF,
                                                GL_CONSTANT_ATTENUATION,
                                                GL_LINEAR_ATTENUATION,
                                                GL_QUADRATIC_ATTENUATION};
                        val[0] = DRAND();
                        glLightf(GL_LIGHT0 + l, pname[p], val[0]);
                        pass = check_shader_builtin(GL_FLOAT, val,
                                                    "gl_LightSource[%d].%s",
                                                    l, enum2glsl(pname[p])) &&
                               pass;
                }

                val[0] = DRAND() * 90;
                glLightf(GL_LIGHT0 + l, GL_SPOT_CUTOFF, val[0]);
                const float cos_cutoff = cosf(val[0] / 180 * M_PI);
                pass = check_shader_builtin(
                               GL_FLOAT, &cos_cutoff,
                               "gl_LightSource[%d].spotCosCutoff", l) &&
                       pass;

                for (int c = 0; c < 3; ++c)
                        val[c] = DRAND();
                val[3] = 1;
                glLightfv(GL_LIGHT0 + l, GL_POSITION, val);
                normalize(val);
                val[2] += 1;
                normalize(val);
                pass = check_shader_builtin(GL_FLOAT_VEC4, val,
                                            "gl_LightSource[%d].halfVector",
                                            l) &&
                       pass;
        }

        random_vec4(val);
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, val);
        pass = check_shader_builtin(GL_FLOAT_VEC4, val,
                                    "gl_LightModel.ambient") &&
               pass;

        /* Derived state from products of light and material. */
        for (int s = 0; s < 2; ++s) {
                float scene_color[4];

                for (int c = 0; c < 4; ++c)
                        scene_color[c] = val[c] = DRAND();
                glMaterialfv(GL_FRONT + s, GL_AMBIENT, val);
                for (int c = 0; c < 4; ++c)
                        scene_color[c] *= val[c] = DRAND();
                glLightModelfv(GL_LIGHT_MODEL_AMBIENT, val);
                for (int c = 0; c < 4; ++c)
                        scene_color[c] += val[c] = DRAND();
                glMaterialfv(GL_FRONT + s, GL_EMISSION, val);

                /* Page 63 (77 of the PDF) of the OpenGL 2.0 spec says:
                 *
                 *      "The value of A produced by lighting is the alpha
                 *      value associated with d_{cm}."
                 *
                 * I'm not sure if this applies to the scene color, but both
                 * Mesa and the NVIDIA driver do this.
                 */
                random_vec4(val);
                glMaterialfv(GL_FRONT + s, GL_DIFFUSE, val);
                scene_color[3] = val[3];

                pass = check_shader_builtin(
                               GL_FLOAT_VEC4, scene_color,
                               s ? "gl_BackLightModelProduct.sceneColor"
                                 : "gl_FrontLightModelProduct.sceneColor") &&
                       pass;
        }

        for (int s = 0; s < 2; ++s) {
                for (int l = 0; l < max_lights; ++l) {
                        const GLenum pname[] = {GL_AMBIENT, GL_DIFFUSE,
                                                GL_SPECULAR};
                        for (int p = 0; p < 3; ++p) {
                                float light_product[4];
                                for (int c = 0; c < 4; ++c)
                                        light_product[c] = val[c] = DRAND();
                                glLightfv(GL_LIGHT0 + l, pname[p], val);
                                for (int c = 0; c < 4; ++c)
                                        light_product[c] *= val[c] = DRAND();
                                glMaterialfv(GL_FRONT + s, pname[p], val);
                                /* XXX: I have no Idea where the spec says the
                                 * alpha value of the light product is the
                                 * material's alpha value, but both Mesa and
                                 * the NVIDIA driver do this.
                                 */
                                light_product[3] = val[3];

                                pass = check_shader_builtin(
                                               GL_FLOAT_VEC4, light_product,
                                               "gl_%sLightProduct[%d].%s",
                                               s ? "Back" : "Front", l,
                                               enum2glsl(pname[p])) &&
                                       pass;
                        }
                }
        }

        /* Texture Environment and Generation */
        int max_tu;
        glGetIntegerv(GL_MAX_TEXTURE_UNITS, &max_tu);
        int max_tiu;
        glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_tiu);
        const int max_textures = MIN2(max_tu, max_tiu);
        for (int t = 0; t < max_textures; ++t) {
                glActiveTexture(GL_TEXTURE0 + t);

                random_vec4(val);
                glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, val);
                pass = check_shader_builtin(GL_FLOAT_VEC4, val,
                                            "gl_TextureEnvColor[%d]", t) &&
                       pass;
        }

        int max_texture_coords;
        glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);
        for (int t = 0; t < max_texture_coords; ++t) {
                const GLenum coord[] = {GL_S, GL_T, GL_R, GL_Q};
                glActiveTexture(GL_TEXTURE0 + t);

                for (int co = 0; co < 4; ++co) {
                        const GLenum plane[] = {GL_EYE_PLANE,
                                                GL_OBJECT_PLANE};
                        const char *plane_name[] = {"Eye", "Object"};
                        for (int pl = 0; pl < 2; ++pl) {
                                random_vec4(val);
                                glTexGenfv(coord[co], plane[pl], val);
                                pass = check_shader_builtin(
                                               GL_FLOAT_VEC4, val,
                                               "gl_%sPlane%s[%d]",
                                               plane_name[pl],
                                               enum2glsl(coord[co]), t) &&
                                       pass;
                        }
                }
        }

        /* Fog */
        random_vec4(val);
        glFogfv(GL_FOG_COLOR, val);
        pass = check_shader_builtin(GL_FLOAT_VEC4, val, "gl_Fog.color") &&
               pass;

        val[0] = DRAND();

        /* Don't test infinity because shader comparisons with infinity are
         * undefined.
         */
        float fog_scale;
        do {
                val[1] = DRAND();
                val[2] = DRAND();
                fog_scale = 1 / (val[2] - val[1]);
        } while (isinf(fog_scale));

        glFogf(GL_FOG_DENSITY, val[0]);
        pass = check_shader_builtin(GL_FLOAT, val, "gl_Fog.density") && pass;

        glFogf(GL_FOG_START, val[1]);
        pass = check_shader_builtin(GL_FLOAT, &val[1], "gl_Fog.start") &&
               pass;

        glFogf(GL_FOG_END, val[2]);
        pass = check_shader_builtin(GL_FLOAT, &val[2], "gl_Fog.end") && pass;

        pass = check_shader_builtin(GL_FLOAT, &fog_scale, "gl_Fog.scale") &&
               pass;

        return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}

void
piglit_init(int argc, char **argv)
{
        SRAND(17);
}