tests/shaders/gpu_shader4_attribs.c

   1 /*
   2  * Copyright (c) 2010 VMware, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NON-INFRINGEMENT.  IN NO EVENT SHALL VMWARE AND/OR THEIR SUPPLIERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 /**
  26  * Test GL_EXT_gpu_shader4's vertex attribute and uniform functions.
  27  * Brian Paul
  28  * 27 Oct 2010
  29  */
  30
  31
  32
  33 #include "piglit-util-gl.h"
  34
  35 PIGLIT_GL_TEST_CONFIG_BEGIN
  36
  37         config.supports_gl_compat_version = 10;
  38
  39         config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
  40
  41 PIGLIT_GL_TEST_CONFIG_END
  42
  43 static const char *TestName = "texture-integer";
  44 static const GLuint Index = 3;
  45 static GLuint Program;
  46
  47
  48 #define UNSIGNED 0
  49 #define SIGNED 1
  50
  51
  52 static GLboolean
  53 check_error(const char *file, int line)
  54 {
  55    GLenum err = glGetError();
  56    if (err) {
  57       fprintf(stderr, "%s: error 0x%x at %s:%d\n", TestName, err, file, line);
  58       return GL_TRUE;
  59    }
  60    return GL_FALSE;
  61 }
  62
  63
  64
  65 static void
  66 gen_values(GLint values[4], GLuint size, int sign)
  67 {
  68    assert(size >= 1 && size <=4 );
  69
  70    if (sign == SIGNED) {
  71       /* [-100, 100] */
  72       values[0] = rand() % 201 - 100;
  73       values[1] = rand() % 201 - 100;
  74       values[2] = rand() % 201 - 100;
  75       values[3] = rand() % 201 - 100;
  76    }
  77    else {
  78       /* [0, 255] */
  79       values[0] = rand() % 255;
  80       values[1] = rand() % 255;
  81       values[2] = rand() % 255;
  82       values[3] = rand() % 255;
  83    }
  84    if (size < 4)
  85       values[3] = 1;
  86    if (size < 3)
  87       values[2] = 0;
  88    if (size < 2)
  89       values[1] = 0;
  90 }
  91
  92
  93 static GLboolean
  94 check_attrib(const GLint expected[4], int sign, const char *func)
  95 {
  96    if (sign == SIGNED) {
  97       GLint vals[4];
  98       glGetVertexAttribIivEXT(Index, GL_CURRENT_VERTEX_ATTRIB_ARB, vals);
  99       if (expected[0] != vals[0] ||
 100           expected[1] != vals[1] ||
 101           expected[2] != vals[2] ||
 102           expected[3] != vals[3]) {
 103          fprintf(stderr, "%s: %s failed\n", TestName, func);
 104          fprintf(stderr, "  Expected: %d, %d, %d, %d\n",
 105                  expected[0], expected[1], expected[2], expected[3]);
 106          fprintf(stderr, "  Found:    %d, %d, %d, %d\n",
 107                  vals[0], vals[1], vals[2], vals[3]);
 108          return GL_FALSE;
 109       }
 110    }
 111    else {
 112       GLuint vals[4];
 113       glGetVertexAttribIuivEXT(Index, GL_CURRENT_VERTEX_ATTRIB_ARB, vals);
 114       if (expected[0] != vals[0] ||
 115           expected[1] != vals[1] ||
 116           expected[2] != vals[2] ||
 117           expected[3] != vals[3]) {
 118          fprintf(stderr, "%s: %s failed\n", TestName, func);
 119          fprintf(stderr, "  Expected: %d, %d, %d, %d\n",
 120                  expected[0], expected[1], expected[2], expected[3]);
 121          fprintf(stderr, "  Found:    %u, %u, %u, %u\n",
 122                  vals[0], vals[1], vals[2], vals[3]);
 123          return GL_FALSE;
 124       }
 125    }
 126    return GL_TRUE;
 127 }
 128
 129
 130
 131 static GLboolean
 132 test_attrib_funcs(void)
 133 {
 134    GLint vals[4];
 135
 136    gen_values(vals, 1, SIGNED);
 137    glVertexAttribI1iEXT(Index, vals[0]);
 138    if (!check_attrib(vals, SIGNED, "glVertexAttribI1iEXT"))
 139       return GL_FALSE;
 140
 141    gen_values(vals, 2, SIGNED);
 142    glVertexAttribI2iEXT(Index, vals[0], vals[1]);
 143    if (!check_attrib(vals, SIGNED, "glVertexAttribI2iEXT"))
 144       return GL_FALSE;
 145
 146    gen_values(vals, 3, SIGNED);
 147    glVertexAttribI3iEXT(Index, vals[0], vals[1], vals[2]);
 148    if (!check_attrib(vals, SIGNED, "glVertexAttribI3iEXT"))
 149       return GL_FALSE;
 150
 151    gen_values(vals, 4, SIGNED);
 152    glVertexAttribI4iEXT(Index, vals[0], vals[1], vals[2], vals[3]);
 153    if (!check_attrib(vals, SIGNED, "glVertexAttribI4iEXT"))
 154       return GL_FALSE;
 155
 156
 157    gen_values(vals, 1, SIGNED);
 158    glVertexAttribI1ivEXT(Index, vals);
 159    if (!check_attrib(vals, SIGNED, "glVertexAttribI1ivEXT"))
 160       return GL_FALSE;
 161
 162    gen_values(vals, 2, SIGNED);
 163    glVertexAttribI2ivEXT(Index, vals);
 164    if (!check_attrib(vals, SIGNED, "glVertexAttribI2ivEXT"))
 165       return GL_FALSE;
 166
 167    gen_values(vals, 3, SIGNED);
 168    glVertexAttribI3ivEXT(Index, vals);
 169    if (!check_attrib(vals, SIGNED, "glVertexAttribI3ivEXT"))
 170       return GL_FALSE;
 171
 172    gen_values(vals, 4, SIGNED);
 173    glVertexAttribI4ivEXT(Index, vals);
 174    if (!check_attrib(vals, SIGNED, "glVertexAttribI4ivEXT"))
 175       return GL_FALSE;
 176
 177
 178    gen_values(vals, 1, UNSIGNED);
 179    glVertexAttribI1uiEXT(Index, vals[0]);
 180    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI1uiEXT"))
 181       return GL_FALSE;
 182
 183    gen_values(vals, 2, UNSIGNED);
 184    glVertexAttribI2uiEXT(Index, vals[0], vals[1]);
 185    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI2uiEXT"))
 186       return GL_FALSE;
 187
 188    gen_values(vals, 3, UNSIGNED);
 189    glVertexAttribI3uiEXT(Index, vals[0], vals[1], vals[2]);
 190    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI3uiEXT"))
 191       return GL_FALSE;
 192
 193    gen_values(vals, 4, UNSIGNED);
 194    glVertexAttribI4uiEXT(Index, vals[0], vals[1], vals[2], vals[3]);
 195    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI4uiEXT"))
 196       return GL_FALSE;
 197
 198
 199    gen_values(vals, 1, UNSIGNED);
 200    glVertexAttribI1uivEXT(Index, (GLuint *) vals);
 201    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI1uivEXT"))
 202       return GL_FALSE;
 203
 204    gen_values(vals, 2, UNSIGNED);
 205    glVertexAttribI2uivEXT(Index, (GLuint *) vals);
 206    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI2uivEXT"))
 207       return GL_FALSE;
 208
 209    gen_values(vals, 3, UNSIGNED);
 210    glVertexAttribI3uivEXT(Index, (GLuint *) vals);
 211    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI3uivEXT"))
 212       return GL_FALSE;
 213
 214    gen_values(vals, 4, UNSIGNED);
 215    glVertexAttribI4uivEXT(Index, (GLuint *) vals);
 216    if (!check_attrib(vals, UNSIGNED, "glVertexAttribI4uivEXT"))
 217       return GL_FALSE;
 218
 219    {
 220       GLbyte bvals[4];
 221       gen_values(vals, 4, SIGNED);
 222       bvals[0] = vals[0];
 223       bvals[1] = vals[1];
 224       bvals[2] = vals[2];
 225       bvals[3] = vals[3];
 226       glVertexAttribI4bvEXT(Index, bvals);
 227       if (!check_attrib(vals, SIGNED, "glVertexAttribI4bvEXT"))
 228          return GL_FALSE;
 229    }
 230
 231    {
 232       GLshort svals[4];
 233       gen_values(vals, 4, SIGNED);
 234       svals[0] = vals[0];
 235       svals[1] = vals[1];
 236       svals[2] = vals[2];
 237       svals[3] = vals[3];
 238       glVertexAttribI4svEXT(Index, svals);
 239       if (!check_attrib(vals, SIGNED, "glVertexAttribI4svEXT"))
 240          return GL_FALSE;
 241    }
 242
 243    {
 244       GLubyte bvals[4];
 245       gen_values(vals, 4, UNSIGNED);
 246       bvals[0] = vals[0];
 247       bvals[1] = vals[1];
 248       bvals[2] = vals[2];
 249       bvals[3] = vals[3];
 250       glVertexAttribI4ubvEXT(Index, bvals);
 251       if (!check_attrib(vals, UNSIGNED, "glVertexAttribI4ubvEXT"))
 252          return GL_FALSE;
 253    }
 254
 255    {
 256       GLushort svals[4];
 257       gen_values(vals, 4, UNSIGNED);
 258       svals[0] = vals[0];
 259       svals[1] = vals[1];
 260       svals[2] = vals[2];
 261       svals[3] = vals[3];
 262       glVertexAttribI4usvEXT(Index, svals);
 263       if (!check_attrib(vals, UNSIGNED, "glVertexAttribI4usvEXT"))
 264          return GL_FALSE;
 265    }
 266
 267    return GL_TRUE;
 268 }
 269
 270
 271
 272 static GLboolean
 273 check_uniform(const GLint expected[4], GLuint size, int sign,
 274               GLint loc, const char *func)
 275 {
 276    if (sign == SIGNED) {
 277       GLint vals[4];
 278       glGetUniformivARB(Program, loc, vals);
 279       if (size < 4)
 280          vals[3] = 1;
 281       if (size < 3)
 282          vals[2] = 0;
 283       if (size < 2)
 284          vals[1] = 0;
 285       if (expected[0] != vals[0] ||
 286           expected[1] != vals[1] ||
 287           expected[2] != vals[2] ||
 288           expected[3] != vals[3]) {
 289          fprintf(stderr, "%s: %s failed\n", TestName, func);
 290          fprintf(stderr, "  Expected: %d, %d, %d, %d\n",
 291                  expected[0], expected[1], expected[2], expected[3]);
 292          fprintf(stderr, "  Found:    %d, %d, %d, %d\n",
 293                  vals[0], vals[1], vals[2], vals[3]);
 294          return GL_FALSE;
 295       }
 296    }
 297    else {
 298       GLuint vals[4];
 299       glGetUniformuivEXT(Program, loc, vals);
 300       if (size < 4)
 301          vals[3] = 1;
 302       if (size < 3)
 303          vals[2] = 0;
 304       if (size < 2)
 305          vals[1] = 0;
 306       if (expected[0] != vals[0] ||
 307           expected[1] != vals[1] ||
 308           expected[2] != vals[2] ||
 309           expected[3] != vals[3]) {
 310          fprintf(stderr, "%s: %s failed\n", TestName, func);
 311          fprintf(stderr, "  Expected: %d, %d, %d, %d\n",
 312                  expected[0], expected[1], expected[2], expected[3]);
 313          fprintf(stderr, "  Found:    %u, %u, %u, %u\n",
 314                  vals[0], vals[1], vals[2], vals[3]);
 315          return GL_FALSE;
 316       }
 317    }
 318    return GL_TRUE;
 319 }
 320
 321
 322 static GLboolean
 323 test_uniform_funcs(void)
 324 {
 325    static const char *signedFragText =
 326       "uniform int value1; \n"
 327       "uniform ivec2 value2; \n"
 328       "uniform ivec3 value3; \n"
 329       "uniform ivec4 value4; \n"
 330       "void main() \n"
 331       "{ \n"
 332       "   vec4 t = vec4(value4); \n"
 333       "   t += vec4(value3, 0.0); \n"
 334       "   t += vec4(value2, 0.0, 0.0); \n"
 335       "   t += vec4(value1, 0.0, 0.0, 0.0); \n"
 336       " gl_FragColor = 0.01 * t; \n"
 337       "} \n";
 338
 339    static const char *unsignedFragText =
 340       "#extension GL_EXT_gpu_shader4: enable \n"
 341       "uniform unsigned int value1; \n"
 342       "uniform uvec2 value2; \n"
 343       "uniform uvec3 value3; \n"
 344       "uniform uvec4 value4; \n"
 345       "void main() \n"
 346       "{ \n"
 347       "   vec4 t = vec4(value4); \n"
 348       "   t += vec4(value3, 0.0); \n"
 349       "   t += vec4(value2, 0.0, 0.0); \n"
 350       "   t += vec4(value1, 0.0, 0.0, 0.0); \n"
 351       " gl_FragColor = 0.01 * t; \n"
 352       "} \n";
 353
 354
 355    GLint vals[4], loc1, loc2, loc3, loc4;
 356    GLuint shader;
 357
 358    /*
 359     * Signed integer tests.
 360     */
 361    shader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, signedFragText);
 362    assert(shader);
 363
 364    Program = piglit_link_simple_program(0, shader);
 365    assert(Program);
 366
 367    glUseProgram(Program);
 368    check_error(__FILE__, __LINE__);
 369
 370    loc1 = glGetUniformLocation(Program, "value1");
 371    assert(loc1 >= 0);
 372
 373    loc2 = glGetUniformLocation(Program, "value2");
 374    assert(loc2 >= 0);
 375
 376    loc3 = glGetUniformLocation(Program, "value3");
 377    assert(loc3 >= 0);
 378
 379    loc4 = glGetUniformLocation(Program, "value4");
 380    assert(loc4 >= 0);
 381
 382    check_error(__FILE__, __LINE__);
 383
 384    gen_values(vals, 1, SIGNED);
 385    glUniform1iARB(loc1, vals[0]);
 386    if (!check_uniform(vals, 1, SIGNED, loc1, "glUniform1iARB"))
 387       return GL_FALSE;
 388
 389    gen_values(vals, 2, SIGNED);
 390    glUniform2iARB(loc2, vals[0], vals[1]);
 391    if (!check_uniform(vals, 2, SIGNED, loc2, "glUniform2iARB"))
 392       return GL_FALSE;
 393
 394    gen_values(vals, 3, SIGNED);
 395    glUniform3iARB(loc3, vals[0], vals[1], vals[2]);
 396    if (!check_uniform(vals, 3, SIGNED, loc3, "glUniform3iARB"))
 397       return GL_FALSE;
 398
 399    gen_values(vals, 4, SIGNED);
 400    glUniform4iARB(loc4, vals[0], vals[1], vals[2], vals[3]);
 401    if (!check_uniform(vals, 4, SIGNED, loc4, "glUniform4iARB"))
 402       return GL_FALSE;
 403
 404
 405    /*
 406     * Unsigned integer tests.
 407     */
 408    shader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, unsignedFragText);
 409    assert(shader);
 410
 411    Program = piglit_link_simple_program(0, shader);
 412    assert(Program);
 413
 414    glUseProgram(Program);
 415    check_error(__FILE__, __LINE__);
 416
 417    loc1 = glGetUniformLocation(Program, "value1");
 418    assert(loc1 >= 0);
 419
 420    loc2 = glGetUniformLocation(Program, "value2");
 421    assert(loc2 >= 0);
 422
 423    loc3 = glGetUniformLocation(Program, "value3");
 424    assert(loc3 >= 0);
 425
 426    loc4 = glGetUniformLocation(Program, "value4");
 427    assert(loc4 >= 0);
 428
 429    check_error(__FILE__, __LINE__);
 430
 431    gen_values(vals, 1, UNSIGNED);
 432    glUniform1uiEXT(loc1, vals[0]);
 433    if (!check_uniform(vals, 1, UNSIGNED, loc1, "glUniform1uiEXT"))
 434       return GL_FALSE;
 435
 436    gen_values(vals, 2, UNSIGNED);
 437    glUniform2uiEXT(loc2, vals[0], vals[1]);
 438    if (!check_uniform(vals, 2, UNSIGNED, loc2, "glUniform2uiEXT"))
 439       return GL_FALSE;
 440
 441    gen_values(vals, 3, UNSIGNED);
 442    glUniform3uiEXT(loc3, vals[0], vals[1], vals[2]);
 443    if (!check_uniform(vals, 3, UNSIGNED, loc3, "glUniform3uiEXT"))
 444       return GL_FALSE;
 445
 446    gen_values(vals, 4, UNSIGNED);
 447    glUniform4uiEXT(loc4, vals[0], vals[1], vals[2], vals[3]);
 448    if (!check_uniform(vals, 4, UNSIGNED, loc4, "glUniform4uiEXT"))
 449       return GL_FALSE;
 450
 451    return GL_TRUE;
 452 }
 453
 454
 455 /** Check which datatypes are accepted by glVertexAttribIPointer() */
 456 static GLboolean
 457 test_attrib_array(void)
 458 {
 459    static const GLenum goodTypes[] = {
 460       GL_BYTE, GL_UNSIGNED_BYTE,
 461       GL_SHORT, GL_UNSIGNED_SHORT,
 462       GL_INT, GL_UNSIGNED_INT
 463    };
 464    static const GLenum badTypes[] = {
 465       GL_FLOAT, GL_DOUBLE, GL_HALF_FLOAT_ARB, GL_BGRA
 466    };
 467    GLint i;
 468    GLubyte data[100];
 469    GLuint index = 1;
 470    GLint size = 4;
 471    GLsizei stride = 0;
 472    GLenum err;
 473
 474    /* clear any prev errors */
 475    while (glGetError() != GL_NO_ERROR)
 476       ;
 477
 478    /* These should not generate a GL error */
 479    for (i = 0; i < ARRAY_SIZE(goodTypes); i++) {
 480       glVertexAttribIPointerEXT(index, size, goodTypes[i], stride, data);
 481       err = glGetError();
 482       if (err != GL_NO_ERROR) {
 483          fprintf(stderr,
 484                  "%s: glVertexAttribIPointer(type=0x%x) generated error 0x%x\n",
 485                  TestName, goodTypes[i], err);
 486          return GL_FALSE;
 487       }
 488    }
 489
 490    for (i = 0; i < ARRAY_SIZE(badTypes); i++) {
 491       glVertexAttribIPointerEXT(index, size, badTypes[i], stride, data);
 492       err = glGetError();
 493       if (err != GL_INVALID_ENUM) {
 494          fprintf(stderr,
 495                  "%s: glVertexAttribIPointer(type=0x%x) failed to generate "
 496                  "GL_INVALID_ENUM\n",
 497                  TestName, badTypes[i]);
 498          return GL_FALSE;
 499       }
 500    }
 501
 502    return GL_TRUE;
 503 }
 504
 505
 506 enum piglit_result
 507 piglit_display(void)
 508 {
 509    if (!test_attrib_funcs())
 510       return PIGLIT_FAIL;
 511
 512    if (!test_uniform_funcs())
 513       return PIGLIT_FAIL;
 514
 515    if (!test_attrib_array())
 516       return PIGLIT_FAIL;
 517
 518    return PIGLIT_PASS;
 519 }
 520
 521
 522 void
 523 piglit_init(int argc, char **argv)
 524 {
 525    piglit_require_extension("GL_EXT_gpu_shader4");
 526
 527    piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
 528 }