tests/general/getactiveattrib.c

   1 /*
   2  * Copyright © 2011 Intel Corporation
   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  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * 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, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file getactiveattrib.c
  26  * Verify that glGetActiveAttrib and GL_ACTIVE_ATTRIBUTES return the expected
  27  * values for a variety of shaders.
  28  *
  29  * \author Ian Romanick
  30  */
  31
  32 #include "piglit-util-gl.h"
  33
  34 PIGLIT_GL_TEST_CONFIG_BEGIN
  35
  36         config.supports_gl_compat_version = 10;
  37
  38         config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
  39
  40 PIGLIT_GL_TEST_CONFIG_END
  41
  42 struct attribute {
  43         /** Name of the attribute. */
  44         const char *name;
  45
  46         /**
  47          * This attribute must be active in the linked shader.
  48          *
  49          * Some attributes must be active and some may or may not be active
  50          * (because a clever compiler could optimize them away.  Attributes
  51          * that must not be active should not be listed in
  52          * \c test::attributes.
  53          */
  54         bool must_be_active;
  55
  56         /**
  57          * Expected (array) size of the attribute.
  58          *
  59          * \note
  60          * Attribute arrays aren't added until GLSL 1.50.
  61          */
  62         GLint size;
  63
  64         /** Expected GLSL type of the attribute. */
  65         GLenum type;
  66 };
  67
  68 struct test {
  69         const char *code;
  70
  71         /**
  72          * List of attributes to be checked
  73          *
  74          * \note
  75          * The list is terminated by an attribute with a \c NULL \c name
  76          * pointer.
  77          */
  78         struct attribute attributes[16];
  79 };
  80
  81 static const struct test glsl110_tests[] = {
  82         /* The first group of tests tries all the possible types for vertex
  83          * shader inputs.
  84          */
  85         {
  86                 "attribute float vertex;\n"
  87                 "void main() { gl_Position = vec4(vertex); }",
  88                 {
  89                         { "vertex",    true,  1, GL_FLOAT },
  90                         { NULL, }
  91                 }
  92         },
  93         {
  94                 "attribute vec2 vertex;\n"
  95                 "void main() { gl_Position = vertex.xyxy; }",
  96                 {
  97                         { "vertex",    true,  1, GL_FLOAT_VEC2 },
  98                         { NULL, }
  99                 }
 100         },
 101         {
 102                 "attribute vec3 vertex;\n"
 103                 "void main() { gl_Position = vertex.xyzx; }",
 104                 {
 105                         { "vertex",    true,  1, GL_FLOAT_VEC3 },
 106                         { NULL, }
 107                 }
 108         },
 109         {
 110                 "attribute vec4 vertex;\n"
 111                 "void main() { gl_Position = vertex; }",
 112                 {
 113                         { "vertex",    true,  1, GL_FLOAT_VEC4 },
 114                         { NULL, }
 115                 }
 116         },
 117         {
 118                 "attribute mat2 vertex;\n"
 119                 "void main() { gl_Position = vertex[0].xyxy; }",
 120                 {
 121                         { "vertex",    true,  1, GL_FLOAT_MAT2 },
 122                         { NULL, }
 123                 }
 124         },
 125         {
 126                 "attribute mat3 vertex;\n"
 127                 "void main() { gl_Position = vertex[0].xyzx; }",
 128                 {
 129                         { "vertex",    true,  1, GL_FLOAT_MAT3 },
 130                         { NULL, }
 131                 }
 132         },
 133         {
 134                 "attribute mat4 vertex;\n"
 135                 "void main() { gl_Position = vertex[0]; }",
 136                 {
 137                         { "vertex",    true,  1, GL_FLOAT_MAT4 },
 138                         { NULL, }
 139                 }
 140         },
 141
 142
 143         /* Try using each of the built-in attributes one at a time.  Only the
 144          * first two glMultiTexCoord attributes are checked because that's all
 145          * an implementation is required to support.
 146          */
 147         {
 148                 "void main() { gl_Position = gl_Color; }",
 149                 {
 150                         { "gl_Color",  true,  1, GL_FLOAT_VEC4 },
 151                         { NULL, }
 152                 }
 153         },
 154         {
 155                 "void main() { gl_Position = gl_SecondaryColor; }",
 156                 {
 157                         { "gl_SecondaryColor", true,  1, GL_FLOAT_VEC4 },
 158                         { NULL, }
 159                 }
 160         },
 161         {
 162                 "void main() { gl_Position = gl_Normal.xyzx; }",
 163                 {
 164                         { "gl_Normal", true,  1, GL_FLOAT_VEC3 },
 165                         { NULL, }
 166                 }
 167         },
 168         {
 169                 "void main() { gl_Position = gl_Vertex; }",
 170                 {
 171                         { "gl_Vertex", true,  1, GL_FLOAT_VEC4 },
 172                         { NULL, }
 173                 }
 174         },
 175         {
 176                 "void main() { gl_Position = gl_MultiTexCoord0; }",
 177                 {
 178                         { "gl_MultiTexCoord0", true,  1, GL_FLOAT_VEC4 },
 179                         { NULL, }
 180                 }
 181         },
 182         {
 183                 "void main() { gl_Position = gl_MultiTexCoord1; }",
 184                 {
 185                         { "gl_MultiTexCoord1", true,  1, GL_FLOAT_VEC4 },
 186                         { NULL, }
 187                 }
 188         },
 189         {
 190                 "void main() { gl_Position = vec4(gl_FogCoord); }",
 191                 {
 192                         { "gl_FogCoord", true,  1, GL_FLOAT },
 193                         { NULL, }
 194                 }
 195         },
 196
 197         /* Try various cases of using / not using some user-defined attributes
 198          * and some built-in attributes.
 199          */
 200         {
 201                 "attribute vec4 not_used;\n"
 202                 "void main() { gl_Position = gl_Vertex; }",
 203                 {
 204                         { "gl_Vertex", true,  1, GL_FLOAT_VEC4 },
 205                         { NULL, }
 206                 }
 207         },
 208         {
 209                 "attribute vec4 vertex;\n"
 210                 "void main() { gl_Position = vertex + gl_Vertex; }",
 211                 {
 212                         { "gl_Vertex", true,  1, GL_FLOAT_VEC4 },
 213                         { "vertex",    true,  1, GL_FLOAT_VEC4 },
 214                         { NULL, }
 215                 }
 216         },
 217         {
 218                 "attribute vec4 vertex;\n"
 219                 "void main() {\n"
 220                 "    gl_Position = vertex;\n"
 221                 "    if (false) gl_Position = gl_Vertex;\n"
 222                 "}",
 223                 {
 224                         { "gl_Vertex", false, 1, GL_FLOAT_VEC4 },
 225                         { "vertex",    true,  1, GL_FLOAT_VEC4 },
 226                         { NULL, }
 227                 }
 228         },
 229         {
 230                 "attribute vec4 vertex;\n"
 231                 "attribute vec2 alternate;\n"
 232                 "uniform bool use_alternate;\n"
 233                 "void main() {\n"
 234                 "    gl_Position = vertex;\n"
 235                 "    if (use_alternate) gl_Position = alternate.xyxy;\n"
 236                 "}",
 237                 {
 238                         { "vertex",    true,  1, GL_FLOAT_VEC4 },
 239                         { "alternate", true,  1, GL_FLOAT_VEC2 },
 240                         { NULL, }
 241                 }
 242         },
 243
 244         /* The built-in function ftransform should also mark gl_Vertex as used.
 245          */
 246         {
 247                 "void main() { gl_Position = ftransform(); }",
 248                 {
 249                         { "gl_Vertex", true,  1, GL_FLOAT_VEC4 },
 250                         { NULL, }
 251                 }
 252         },
 253 };
 254
 255 static const struct test glsl120_tests[] = {
 256         /* Try all the possible types for vertex shader inputs.  Note that
 257          * this only checks the types that were added in GLSL 1.20.
 258          *
 259          * Since GLSL 1.20 doesn't add any new built-in attributes, there are
 260          * no other tests added in the GLSL 1.20 group.
 261          */
 262         {
 263                 "#version 120\n"
 264                 "attribute mat2x3 vertex;\n"
 265                 "void main() { gl_Position = vertex[0].xxxx; }",
 266                 {
 267                         { "vertex",    true,  1, GL_FLOAT_MAT2x3 },
 268                         { NULL, }
 269                 }
 270         },
 271         {
 272                 "#version 120\n"
 273                 "attribute mat2x4 vertex;\n"
 274                 "void main() { gl_Position = vertex[0].xxxx; }",
 275                 {
 276                         { "vertex",    true,  1, GL_FLOAT_MAT2x4 },
 277                         { NULL, }
 278                 }
 279         },
 280         {
 281                 "#version 120\n"
 282                 "attribute mat3x2 vertex;\n"
 283                 "void main() { gl_Position = vertex[0].xxxx; }",
 284                 {
 285                         { "vertex",    true,  1, GL_FLOAT_MAT3x2 },
 286                         { NULL, }
 287                 }
 288         },
 289         {
 290                 "#version 120\n"
 291                 "attribute mat3x4 vertex;\n"
 292                 "void main() { gl_Position = vertex[0].xxxx; }",
 293                 {
 294                         { "vertex",    true,  1, GL_FLOAT_MAT3x4 },
 295                         { NULL, }
 296                 }
 297         },
 298         {
 299                 "#version 120\n"
 300                 "attribute mat4x2 vertex;\n"
 301                 "void main() { gl_Position = vertex[0].xxxx; }",
 302                 {
 303                         { "vertex",    true,  1, GL_FLOAT_MAT4x2 },
 304                         { NULL, }
 305                 }
 306         },
 307         {
 308                 "#version 120\n"
 309                 "attribute mat4x3 vertex;\n"
 310                 "void main() { gl_Position = vertex[0].xxxx; }",
 311                 {
 312                         { "vertex",    true,  1, GL_FLOAT_MAT4x3 },
 313                         { NULL, }
 314                 }
 315         },
 316 };
 317
 318 static const struct test glsl130_tests[] = {
 319         /* Try all the possible types for vertex shader inputs.  Note that
 320          * this only checks the types that were added in GLSL 1.30.
 321          *
 322          * Since GLSL 1.30 doesn't add any new built-in attributes, there are
 323          * no other tests added in the GLSL 1.30 group.
 324          */
 325         {
 326                 "#version 130\n"
 327                 "in int vertex;\n"
 328                 "void main() { gl_Position = vec4(vertex); }",
 329                 {
 330                         { "vertex",    true,  1, GL_INT },
 331                         { NULL, }
 332                 }
 333         },
 334         {
 335                 "#version 130\n"
 336                 "in uint vertex;\n"
 337                 "void main() { gl_Position = vec4(vertex); }",
 338                 {
 339                         { "vertex",    true,  1, GL_UNSIGNED_INT },
 340                         { NULL, }
 341                 }
 342         },
 343         {
 344                 "#version 130\n"
 345                 "in ivec2 vertex;\n"
 346                 "void main() { gl_Position = vec4(vertex.x); }",
 347                 {
 348                         { "vertex",    true,  1, GL_INT_VEC2 },
 349                         { NULL, }
 350                 }
 351         },
 352         {
 353                 "#version 130\n"
 354                 "in uvec2 vertex;\n"
 355                 "void main() { gl_Position = vec4(vertex.x); }",
 356                 {
 357                         { "vertex",    true,  1, GL_UNSIGNED_INT_VEC2 },
 358                         { NULL, }
 359                 }
 360         },
 361         {
 362                 "#version 130\n"
 363                 "in ivec3 vertex;\n"
 364                 "void main() { gl_Position = vec4(vertex.x); }",
 365                 {
 366                         { "vertex",    true,  1, GL_INT_VEC3 },
 367                         { NULL, }
 368                 }
 369         },
 370         {
 371                 "#version 130\n"
 372                 "in uvec3 vertex;\n"
 373                 "void main() { gl_Position = vec4(vertex.x); }",
 374                 {
 375                         { "vertex",    true,  1, GL_UNSIGNED_INT_VEC3 },
 376                         { NULL, }
 377                 }
 378         },
 379         {
 380                 "#version 130\n"
 381                 "in ivec4 vertex;\n"
 382                 "void main() { gl_Position = vec4(vertex.x); }",
 383                 {
 384                         { "vertex",    true,  1, GL_INT_VEC4 },
 385                         { NULL, }
 386                 }
 387         },
 388         {
 389                 "#version 130\n"
 390                 "in uvec4 vertex;\n"
 391                 "void main() { gl_Position = vec4(vertex.x); }",
 392                 {
 393                         { "vertex",    true,  1, GL_UNSIGNED_INT_VEC4 },
 394                         { NULL, }
 395                 }
 396         },
 397 };
 398
 399 enum piglit_result
 400 piglit_display(void)
 401 {
 402         return PIGLIT_FAIL;
 403 }
 404
 405 int
 406 find_attrib(const struct attribute *attribs, const char *name)
 407 {
 408         unsigned i;
 409
 410         for (i = 0; attribs[i].name != NULL; i++) {
 411                 if (strcmp(attribs[i].name, name) == 0)
 412                         return (int) i;
 413         }
 414
 415         return -1;
 416 }
 417
 418 #define DUMP_SHADER(code)                                               \
 419         do {                                                            \
 420                 if (!shader_dumped) {                                   \
 421                         fprintf(stderr, "\nFailing shader:\n%s\n\n",    \
 422                                 code);                                  \
 423                         shader_dumped = true;                           \
 424                 }                                                       \
 425         } while (false)
 426
 427 bool
 428 do_test(const struct test *tests, unsigned num_tests)
 429 {
 430         bool pass = true;
 431         unsigned i;
 432
 433         for (i = 0; i < num_tests; i++) {
 434                 GLint vert =
 435                         piglit_compile_shader_text(GL_VERTEX_SHADER,
 436                                                    tests[i].code);
 437                 GLint prog = piglit_link_simple_program(vert, 0);
 438                 GLint num_attr;
 439                 unsigned visited_count[64];
 440                 unsigned j;
 441                 bool shader_dumped = false;
 442
 443                 memset(visited_count, 0, sizeof(visited_count));
 444
 445                 /* From page 93 (page 109 of the PDF) says:
 446                  *
 447                  *     "An attribute variable (either conventional or generic)
 448                  *     is considered active if it is determined by the
 449                  *     compiler and linker that the attribute may be accessed
 450                  *     when the shader is executed. Attribute variables that
 451                  *     are declared in a vertex shader but never used will not
 452                  *     count against the limit. In cases where the compiler
 453                  *     and linker cannot make a conclusive determination, an
 454                  *     attribute will be considered active."
 455                  *
 456                  * Compare the set of active attributes against the list of
 457                  * expected active attributes.
 458                  */
 459                 glGetProgramiv(prog, GL_ACTIVE_ATTRIBUTES, &num_attr);
 460
 461                 for (j = 0; j < num_attr; j++) {
 462                         const struct attribute *attr;
 463                         char name_buf[256];
 464                         int attr_idx;
 465                         GLsizei name_len;
 466                         GLint size;
 467                         GLenum type;
 468
 469                         glGetActiveAttrib(prog, j,
 470                                           sizeof(name_buf),
 471                                           &name_len,
 472                                           &size,
 473                                           &type,
 474                                           name_buf);
 475                         attr_idx = find_attrib(tests[i].attributes, name_buf);
 476
 477                         /* If the named attribute is not in the list for the
 478                          * test, then it must not be active.
 479                          */
 480                         if (attr_idx < 0) {
 481                                 DUMP_SHADER(tests[i].code);
 482                                 fprintf(stderr,
 483                                         "Attribute `%s' should not be active "
 484                                         "but is.\n", name_buf);
 485                                 pass = false;
 486                                 continue;
 487                         }
 488
 489                         attr = &tests[i].attributes[attr_idx];
 490                         if (visited_count[attr_idx] != 0) {
 491                                 DUMP_SHADER(tests[i].code);
 492                                 fprintf(stderr,
 493                                         "Attribute `%s' listed multiple times "
 494                                         "in active list.\n", name_buf);
 495                                 pass = false;
 496                         } else if (attr->size != size) {
 497                                 DUMP_SHADER(tests[i].code);
 498                                 fprintf(stderr,
 499                                         "Attribute `%s' should have size %d, "
 500                                         "but had size %d.\n",
 501                                         name_buf, attr->size, size);
 502                                 pass = false;
 503                         } else if (attr->type != type) {
 504                                 DUMP_SHADER(tests[i].code);
 505                                 fprintf(stderr,
 506                                         "Attribute `%s' should have type "
 507                                         "0x%04x, but had type 0x%04x.\n",
 508                                         name_buf, attr->type, type);
 509                                 pass = false;
 510                         }
 511
 512                         visited_count[attr_idx]++;
 513                 }
 514
 515                 for (j = 0; tests[i].attributes[j].name != NULL; j++) {
 516                         if (tests[i].attributes[j].must_be_active
 517                             && visited_count[j] == 0) {
 518                                 DUMP_SHADER(tests[i].code);
 519                                 fprintf(stderr,
 520                                         "Attribute `%s' should have been "
 521                                         "active but wasn't.\n",
 522                                         tests[i].attributes[j].name);
 523                                 pass = false;
 524                         }
 525                 }
 526         }
 527
 528         return pass;
 529 }
 530
 531 void usage_and_fail(const char *name)
 532 {
 533         fprintf(stderr, "Usage: %s [110|120|130]\n", name);
 534         piglit_report_result(PIGLIT_FAIL);
 535 }
 536
 537 void piglit_init(int argc, char **argv)
 538 {
 539         bool pass = true;
 540         unsigned i;
 541
 542         if (argc == 1) {
 543                 usage_and_fail(argv[0]);
 544         }
 545
 546         piglit_require_vertex_shader();
 547
 548         for (i = 1; i < argc; i++) {
 549                 if (strcmp("110", argv[i]) == 0) {
 550                         pass = do_test(glsl110_tests,
 551                                        ARRAY_SIZE(glsl110_tests))
 552                                 && pass;
 553                 } else if (strcmp("120", argv[i]) == 0) {
 554                         piglit_require_GLSL_version(120);
 555                         pass = do_test(glsl120_tests,
 556                                        ARRAY_SIZE(glsl120_tests))
 557                                 && pass;
 558                 } else if (strcmp("130", argv[i]) == 0) {
 559                         piglit_require_GLSL_version(130);
 560                         pass = do_test(glsl130_tests,
 561                                        ARRAY_SIZE(glsl130_tests))
 562                                 && pass;
 563                 } else {
 564                         usage_and_fail(argv[0]);
 565                 }
 566         }
 567
 568         piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
 569 }