data/gles31/shaders/linkage_geometry_uniform_types.test

   1 group types "Types"
   2
   3         case float
   4                 version 310 es
   5                 desc "uniform of type float"
   6                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
   7                 values
   8                 {
   9                         uniform float val       = -1.25;
  10                         output float out0       = -1.25;
  11                 }
  12                 vertex ""
  13                         #version 310 es
  14                         ${VERTEX_DECLARATIONS}
  15                         void main()
  16                         {
  17                                 ${VERTEX_OUTPUT}
  18                         }
  19                 ""
  20                 geometry ""
  21                         #version 310 es
  22                         ${GEOMETRY_DECLARATIONS}
  23                         out mediump float geo_var;
  24                         void main()
  25                         {
  26                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
  27                                 {
  28                                         geo_var = val;
  29                                         gl_Position = gl_in[ndx].gl_Position;
  30                                         EmitVertex();
  31                                 }
  32                         }
  33                 ""
  34                 fragment ""
  35                         #version 310 es
  36                         precision highp float;
  37                         ${FRAGMENT_DECLARATIONS}
  38                         in mediump float geo_var;
  39                         void main()
  40                         {
  41                                 out0 = geo_var;
  42                                 ${FRAGMENT_OUTPUT}
  43                         }
  44                 ""
  45         end
  46
  47         case vec2
  48                 version 310 es
  49                 desc "uniform of type vec2"
  50                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
  51                 values
  52                 {
  53                         uniform vec2 val        = vec2(-1.25, 1.25);
  54                         output vec2 out0        = vec2(-1.25, 1.25);
  55                 }
  56                 vertex ""
  57                         #version 310 es
  58                         ${VERTEX_DECLARATIONS}
  59                         void main()
  60                         {
  61                                 ${VERTEX_OUTPUT}
  62                         }
  63                 ""
  64                 geometry ""
  65                         #version 310 es
  66                         ${GEOMETRY_DECLARATIONS}
  67                         out mediump vec2 geo_var;
  68                         void main()
  69                         {
  70                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
  71                                 {
  72                                         geo_var = val;
  73                                         gl_Position = gl_in[ndx].gl_Position;
  74                                         EmitVertex();
  75                                 }
  76                         }
  77                 ""
  78                 fragment ""
  79                         #version 310 es
  80                         precision highp float;
  81                         ${FRAGMENT_DECLARATIONS}
  82                         in vec2 geo_var;
  83                         void main()
  84                         {
  85                                 out0 = geo_var;
  86                                 ${FRAGMENT_OUTPUT}
  87                         }
  88                 ""
  89         end
  90
  91         case vec3
  92                 version 310 es
  93                 desc "uniform of type vec3"
  94                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
  95                 values
  96                 {
  97                         uniform vec3 val        = vec3(-25.65, -7.25, 14.21);
  98                         output vec3 out0        = vec3(-25.65, -7.25, 14.21);
  99                 }
 100                 vertex ""
 101                         #version 310 es
 102                         ${VERTEX_DECLARATIONS}
 103                         void main()
 104                         {
 105                                 ${VERTEX_OUTPUT}
 106                         }
 107                 ""
 108                 geometry ""
 109                         #version 310 es
 110                         ${GEOMETRY_DECLARATIONS}
 111                         out mediump vec3 geo_var;
 112                         void main()
 113                         {
 114                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 115                                 {
 116                                         geo_var = val;
 117                                         gl_Position = gl_in[ndx].gl_Position;
 118                                         EmitVertex();
 119                                 }
 120                         }
 121                 ""
 122                 fragment ""
 123                         #version 310 es
 124                         precision highp float;
 125                         ${FRAGMENT_DECLARATIONS}
 126                         in vec3 geo_var;
 127                         void main()
 128                         {
 129                                 out0 = geo_var;
 130                                 ${FRAGMENT_OUTPUT}
 131                         }
 132                 ""
 133         end
 134
 135         case vec4
 136                 version 310 es
 137                 desc "uniform of type vec4"
 138                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 139                 values
 140                 {
 141                         uniform vec4 val        = vec4(-1.25, 1.25, -9.5, -12.2);
 142                         output vec4 out0        = vec4(-1.25, 1.25, -9.5, -12.2);
 143                 }
 144                 vertex ""
 145                         #version 310 es
 146                         ${VERTEX_DECLARATIONS}
 147                         void main()
 148                         {
 149                                 ${VERTEX_OUTPUT}
 150                         }
 151                 ""
 152                 geometry ""
 153                         #version 310 es
 154                         ${GEOMETRY_DECLARATIONS}
 155                         out mediump vec4 geo_var;
 156                         void main()
 157                         {
 158                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 159                                 {
 160                                         geo_var = val;
 161                                         gl_Position = gl_in[ndx].gl_Position;
 162                                         EmitVertex();
 163                                 }
 164                         }
 165                 ""
 166                 fragment ""
 167                         #version 310 es
 168                         precision highp float;
 169                         ${FRAGMENT_DECLARATIONS}
 170                         in vec4 geo_var;
 171                         void main()
 172                         {
 173                                 out0 = geo_var;
 174                                 ${FRAGMENT_OUTPUT}
 175                         }
 176                 ""
 177         end
 178
 179         case mat2
 180                 version 310 es
 181                 desc "uniform of type mat2"
 182                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 183                 values
 184                 {
 185                         uniform mat2 val        = mat2(-1.25, 1.25, -9.5, -12.2);
 186                         output mat2 out0        = mat2(-1.25, 1.25, -9.5, -12.2);
 187                 }
 188                 vertex ""
 189                         #version 310 es
 190                         ${VERTEX_DECLARATIONS}
 191                         void main()
 192                         {
 193                                 ${VERTEX_OUTPUT}
 194                         }
 195                 ""
 196                 geometry ""
 197                         #version 310 es
 198                         ${GEOMETRY_DECLARATIONS}
 199                         out mediump mat2 geo_var;
 200                         void main()
 201                         {
 202                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 203                                 {
 204                                         geo_var = val;
 205                                         gl_Position = gl_in[ndx].gl_Position;
 206                                         EmitVertex();
 207                                 }
 208                         }
 209                 ""
 210                 fragment ""
 211                         #version 310 es
 212                         precision highp float;
 213                         ${FRAGMENT_DECLARATIONS}
 214                         in mat2 geo_var;
 215                         void main()
 216                         {
 217                                 out0 = geo_var;
 218                                 ${FRAGMENT_OUTPUT}
 219                         }
 220                 ""
 221         end
 222
 223         case mat2x3
 224                 version 310 es
 225                 desc "uniform of type mat2x3"
 226                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 227                 values
 228                 {
 229                         uniform mat2x3 val      = [ mat2x3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25) ];
 230                         output mat2x3 out0      = [ mat2x3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25) ];
 231                 }
 232                 vertex ""
 233                         #version 310 es
 234                         ${VERTEX_DECLARATIONS}
 235                         void main()
 236                         {
 237                                 ${VERTEX_OUTPUT}
 238                         }
 239                 ""
 240                 geometry ""
 241                         #version 310 es
 242                         ${GEOMETRY_DECLARATIONS}
 243                         out mediump mat2x3 geo_var;
 244                         void main()
 245                         {
 246                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 247                                 {
 248                                         geo_var = val;
 249                                         gl_Position = gl_in[ndx].gl_Position;
 250                                         EmitVertex();
 251                                 }
 252                         }
 253                 ""
 254                 fragment ""
 255                         #version 310 es
 256                         precision highp float;
 257                         ${FRAGMENT_DECLARATIONS}
 258                         in mat2x3 geo_var;
 259                         void main()
 260                         {
 261                                 out0 = geo_var;
 262                                 ${FRAGMENT_OUTPUT}
 263                         }
 264                 ""
 265         end
 266
 267         case mat2x4
 268                 version 310 es
 269                 desc "uniform of type mat2x4"
 270                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 271                 values
 272                 {
 273                         uniform mat2x4 val      = [ mat2x4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7) ];
 274                         output mat2x4 out0      = [ mat2x4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7) ];
 275                 }
 276                 vertex ""
 277                         #version 310 es
 278                         ${VERTEX_DECLARATIONS}
 279                         void main()
 280                         {
 281                                 ${VERTEX_OUTPUT}
 282                         }
 283                 ""
 284                 geometry ""
 285                         #version 310 es
 286                         ${GEOMETRY_DECLARATIONS}
 287                         out mediump mat2x4 geo_var;
 288                         void main()
 289                         {
 290                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 291                                 {
 292                                         geo_var = val;
 293                                         gl_Position = gl_in[ndx].gl_Position;
 294                                         EmitVertex();
 295                                 }
 296                         }
 297                 ""
 298                 fragment ""
 299                         #version 310 es
 300                         precision highp float;
 301                         ${FRAGMENT_DECLARATIONS}
 302                         in mat2x4 geo_var;
 303                         void main()
 304                         {
 305                                 out0 = geo_var;
 306                                 ${FRAGMENT_OUTPUT}
 307                         }
 308                 ""
 309         end
 310
 311         case mat3x2
 312                 version 310 es
 313                 desc "uniform of type mat3x2"
 314                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 315                 values
 316                 {
 317                         uniform mat3x2 val      = [ mat3x2(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25) ];
 318                         output mat3x2 out0      = [ mat3x2(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25) ];
 319                 }
 320                 vertex ""
 321                         #version 310 es
 322                         ${VERTEX_DECLARATIONS}
 323                         void main()
 324                         {
 325                                 ${VERTEX_OUTPUT}
 326                         }
 327                 ""
 328                 geometry ""
 329                         #version 310 es
 330                         ${GEOMETRY_DECLARATIONS}
 331                         out mediump mat3x2 geo_var;
 332                         void main()
 333                         {
 334                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 335                                 {
 336                                         geo_var = val;
 337                                         gl_Position = gl_in[ndx].gl_Position;
 338                                         EmitVertex();
 339                                 }
 340                         }
 341                 ""
 342                 fragment ""
 343                         #version 310 es
 344                         precision highp float;
 345                         ${FRAGMENT_DECLARATIONS}
 346                         in mat3x2 geo_var;
 347                         void main()
 348                         {
 349                                 out0 = geo_var;
 350                                 ${FRAGMENT_OUTPUT}
 351                         }
 352                 ""
 353         end
 354
 355         case mat3
 356                 version 310 es
 357                 desc "uniform of type mat3"
 358                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 359                 values
 360                 {
 361                         uniform mat3 val        = [ mat3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 9.9) ];
 362                         output mat3 out0        = [ mat3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 9.9) ];
 363                 }
 364                 vertex ""
 365                         #version 310 es
 366                         ${VERTEX_DECLARATIONS}
 367                         void main()
 368                         {
 369                                 ${VERTEX_OUTPUT}
 370                         }
 371                 ""
 372                 geometry ""
 373                         #version 310 es
 374                         ${GEOMETRY_DECLARATIONS}
 375                         out mediump mat3 geo_var;
 376                         void main()
 377                         {
 378                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 379                                 {
 380                                         geo_var = val;
 381                                         gl_Position = gl_in[ndx].gl_Position;
 382                                         EmitVertex();
 383                                 }
 384                         }
 385                 ""
 386                 fragment ""
 387                         #version 310 es
 388                         precision highp float;
 389                         ${FRAGMENT_DECLARATIONS}
 390                         in mat3 geo_var;
 391                         void main()
 392                         {
 393                                 out0 = geo_var;
 394                                 ${FRAGMENT_OUTPUT}
 395                         }
 396                 ""
 397         end
 398
 399         case mat3x4
 400                 version 310 es
 401                 desc "uniform of type mat3x4"
 402                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 403                 values
 404                 {
 405                         uniform mat3x4 val      = [ mat3x4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0) ];
 406                         output mat3x4 out0      = [ mat3x4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0) ];
 407                 }
 408                 vertex ""
 409                         #version 310 es
 410                         ${VERTEX_DECLARATIONS}
 411                         void main()
 412                         {
 413                                 ${VERTEX_OUTPUT}
 414                         }
 415                 ""
 416                 geometry ""
 417                         #version 310 es
 418                         ${GEOMETRY_DECLARATIONS}
 419                         out mediump mat3x4 geo_var;
 420                         void main()
 421                         {
 422                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 423                                 {
 424                                         geo_var = val;
 425                                         gl_Position = gl_in[ndx].gl_Position;
 426                                         EmitVertex();
 427                                 }
 428                         }
 429                 ""
 430                 fragment ""
 431                         #version 310 es
 432                         precision highp float;
 433                         ${FRAGMENT_DECLARATIONS}
 434                         in mat3x4 geo_var;
 435                         void main()
 436                         {
 437                                 out0 = geo_var;
 438                                 ${FRAGMENT_OUTPUT}
 439                         }
 440                 ""
 441         end
 442
 443         case mat4x2
 444                 version 310 es
 445                 desc "uniform of type mat4x2"
 446                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 447                 values
 448                 {
 449                         uniform mat4x2 val      = [ mat4x2(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7) ];
 450                         output mat4x2 out0      = [ mat4x2(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7) ];
 451                 }
 452                 vertex ""
 453                         #version 310 es
 454                         ${VERTEX_DECLARATIONS}
 455                         void main()
 456                         {
 457                                 ${VERTEX_OUTPUT}
 458                         }
 459                 ""
 460                 geometry ""
 461                         #version 310 es
 462                         ${GEOMETRY_DECLARATIONS}
 463                         out mediump mat4x2 geo_var;
 464                         void main()
 465                         {
 466                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 467                                 {
 468                                         geo_var = val;
 469                                         gl_Position = gl_in[ndx].gl_Position;
 470                                         EmitVertex();
 471                                 }
 472                         }
 473                 ""
 474                 fragment ""
 475                         #version 310 es
 476                         precision highp float;
 477                         ${FRAGMENT_DECLARATIONS}
 478                         in mat4x2 geo_var;
 479                         void main()
 480                         {
 481                                 out0 = geo_var;
 482                                 ${FRAGMENT_OUTPUT}
 483                         }
 484                 ""
 485         end
 486
 487         case mat4x3
 488                 version 310 es
 489                 desc "uniform of type mat4x3"
 490                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 491                 values
 492                 {
 493                         uniform mat4x3 val      = [ mat4x3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0) ];
 494                         output mat4x3 out0      = [ mat4x3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0) ];
 495                 }
 496                 vertex ""
 497                         #version 310 es
 498                         ${VERTEX_DECLARATIONS}
 499                         void main()
 500                         {
 501                                 ${VERTEX_OUTPUT}
 502                         }
 503                 ""
 504                 geometry ""
 505                         #version 310 es
 506                         ${GEOMETRY_DECLARATIONS}
 507                         out mediump mat4x3 geo_var;
 508                         void main()
 509                         {
 510                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 511                                 {
 512                                         geo_var = val;
 513                                         gl_Position = gl_in[ndx].gl_Position;
 514                                         EmitVertex();
 515                                 }
 516                         }
 517                 ""
 518                 fragment ""
 519                         #version 310 es
 520                         precision highp float;
 521                         ${FRAGMENT_DECLARATIONS}
 522                         in mat4x3 geo_var;
 523                         void main()
 524                         {
 525                                 out0 = geo_var;
 526                                 ${FRAGMENT_OUTPUT}
 527                         }
 528                 ""
 529         end
 530
 531         case mat4
 532                 version 310 es
 533                 desc "uniform of type mat4"
 534                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 535                 values
 536                 {
 537                         uniform mat4 val        = [ mat4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0, 2.25, 2.25, 22.5, 225.0) ];
 538                         output mat4 out0        = [ mat4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0, 2.25, 2.25, 22.5, 225.0) ];
 539                 }
 540                 vertex ""
 541                         #version 310 es
 542                         ${VERTEX_DECLARATIONS}
 543                         void main()
 544                         {
 545                                 ${VERTEX_OUTPUT}
 546                         }
 547                 ""
 548                 geometry ""
 549                         #version 310 es
 550                         ${GEOMETRY_DECLARATIONS}
 551                         out mediump mat4 geo_var;
 552                         void main()
 553                         {
 554                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 555                                 {
 556                                         geo_var = val;
 557                                         gl_Position = gl_in[ndx].gl_Position;
 558                                         EmitVertex();
 559                                 }
 560                         }
 561                 ""
 562                 fragment ""
 563                         #version 310 es
 564                         precision highp float;
 565                         ${FRAGMENT_DECLARATIONS}
 566                         in mat4 geo_var;
 567                         void main()
 568                         {
 569                                 out0 = geo_var;
 570                                 ${FRAGMENT_OUTPUT}
 571                         }
 572                 ""
 573         end
 574
 575         case int
 576                 version 310 es
 577                 desc "uniform of type int"
 578                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 579                 values
 580                 {
 581                         uniform int val         = 3;
 582                         output int out0         = 3;
 583                 }
 584                 vertex ""
 585                         #version 310 es
 586                         ${VERTEX_DECLARATIONS}
 587                         void main()
 588                         {
 589                                 ${VERTEX_SETUP}
 590                                 ${VERTEX_OUTPUT}
 591                         }
 592                 ""
 593                 geometry ""
 594                         #version 310 es
 595                         ${GEOMETRY_DECLARATIONS}
 596                         flat out mediump int geo_var;
 597                         void main()
 598                         {
 599                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 600                                 {
 601                                         geo_var = val;
 602                                         gl_Position = gl_in[ndx].gl_Position;
 603                                         EmitVertex();
 604                                 }
 605                         }
 606                 ""
 607                 fragment ""
 608                         #version 310 es
 609                         precision highp int;
 610                         ${FRAGMENT_DECLARATIONS}
 611                         flat in int geo_var;
 612                         void main()
 613                         {
 614                                 out0 = geo_var;
 615                                 ${FRAGMENT_OUTPUT}
 616                         }
 617                 ""
 618         end
 619
 620         case ivec2
 621                 version 310 es
 622                 desc "uniform of type ivec2"
 623                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 624                 values
 625                 {
 626                         uniform ivec2 val       = [ ivec2(-25, 25) ];
 627                         output ivec2 out0       = [ ivec2(-25, 25) ];
 628                 }
 629                 vertex ""
 630                         #version 310 es
 631                         ${VERTEX_DECLARATIONS}
 632                         void main()
 633                         {
 634                                 ${VERTEX_SETUP}
 635                                 ${VERTEX_OUTPUT}
 636                         }
 637                 ""
 638                 geometry ""
 639                         #version 310 es
 640                         ${GEOMETRY_DECLARATIONS}
 641                         flat out mediump ivec2 geo_var;
 642                         void main()
 643                         {
 644                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 645                                 {
 646                                         geo_var = val;
 647                                         gl_Position = gl_in[ndx].gl_Position;
 648                                         EmitVertex();
 649                                 }
 650                         }
 651                 ""
 652                 fragment ""
 653                         #version 310 es
 654                         precision highp int;
 655                         ${FRAGMENT_DECLARATIONS}
 656                         flat in ivec2 geo_var;
 657                         void main()
 658                         {
 659                                 out0 = geo_var;
 660                                 ${FRAGMENT_OUTPUT}
 661                         }
 662                 ""
 663         end
 664
 665         case ivec3
 666                 version 310 es
 667                 desc "uniform of type ivec3"
 668                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 669                 values
 670                 {
 671                         uniform ivec3 val       = [ ivec3(-25, 25, -3) ];
 672                         output ivec3 out0       = [ ivec3(-25, 25, -3) ];
 673                 }
 674                 vertex ""
 675                         #version 310 es
 676                         ${VERTEX_DECLARATIONS}
 677                         void main()
 678                         {
 679                                 ${VERTEX_SETUP}
 680                                 ${VERTEX_OUTPUT}
 681                         }
 682                 ""
 683                 geometry ""
 684                         #version 310 es
 685                         ${GEOMETRY_DECLARATIONS}
 686                         flat out mediump ivec3 geo_var;
 687                         void main()
 688                         {
 689                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 690                                 {
 691                                         geo_var = val;
 692                                         gl_Position = gl_in[ndx].gl_Position;
 693                                         EmitVertex();
 694                                 }
 695                         }
 696                 ""
 697                 fragment ""
 698                         #version 310 es
 699                         precision highp int;
 700                         ${FRAGMENT_DECLARATIONS}
 701                         flat in ivec3 geo_var;
 702                         void main()
 703                         {
 704                                 out0 = geo_var;
 705                                 ${FRAGMENT_OUTPUT}
 706                         }
 707                 ""
 708         end
 709
 710         case ivec4
 711                 version 310 es
 712                 desc "uniform of type ivec4"
 713                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 714                 values
 715                 {
 716                         uniform ivec4 val       = [ ivec4(-25, 25, -3, 3) ];
 717                         output ivec4 out0       = [ ivec4(-25, 25, -3, 3) ];
 718                 }
 719                 vertex ""
 720                         #version 310 es
 721                         ${VERTEX_DECLARATIONS}
 722                         void main()
 723                         {
 724                                 ${VERTEX_SETUP}
 725                                 ${VERTEX_OUTPUT}
 726                         }
 727                 ""
 728                 geometry ""
 729                         #version 310 es
 730                         ${GEOMETRY_DECLARATIONS}
 731                         flat out mediump ivec4 geo_var;
 732                         void main()
 733                         {
 734                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 735                                 {
 736                                         geo_var = val;
 737                                         gl_Position = gl_in[ndx].gl_Position;
 738                                         EmitVertex();
 739                                 }
 740                         }
 741                 ""
 742                 fragment ""
 743                         #version 310 es
 744                         precision highp int;
 745                         ${FRAGMENT_DECLARATIONS}
 746                         flat in ivec4 geo_var;
 747                         void main()
 748                         {
 749                                 out0 = geo_var;
 750                                 ${FRAGMENT_OUTPUT}
 751                         }
 752                 ""
 753         end
 754
 755         case uint
 756                 version 310 es
 757                 desc "uniform of type int"
 758                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 759                 values
 760                 {
 761                         uniform uint val                = [ 3 ];
 762                         output uint out0                = [ 3 ];
 763                 }
 764                 vertex ""
 765                         #version 310 es
 766                         ${VERTEX_DECLARATIONS}
 767                         void main()
 768                         {
 769                                 ${VERTEX_SETUP}
 770                                 ${VERTEX_OUTPUT}
 771                         }
 772                 ""
 773                 geometry ""
 774                         #version 310 es
 775                         ${GEOMETRY_DECLARATIONS}
 776                         flat out mediump uint geo_var;
 777                         void main()
 778                         {
 779                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 780                                 {
 781                                         geo_var = val;
 782                                         gl_Position = gl_in[ndx].gl_Position;
 783                                         EmitVertex();
 784                                 }
 785                         }
 786                 ""
 787                 fragment ""
 788                         #version 310 es
 789                         precision highp int;
 790                         ${FRAGMENT_DECLARATIONS}
 791                         flat in uint geo_var;
 792                         void main()
 793                         {
 794                                 out0 = geo_var;
 795                                 ${FRAGMENT_OUTPUT}
 796                         }
 797                 ""
 798         end
 799
 800         case uvec2
 801                 version 310 es
 802                 desc "uniform of type uvec2"
 803                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 804                 values
 805                 {
 806                         uniform uvec2 val       = [ uvec2(16, 17) ];
 807                         output uvec2 out0       = [ uvec2(16, 17) ];
 808                 }
 809                 vertex ""
 810                         #version 310 es
 811                         ${VERTEX_DECLARATIONS}
 812                         void main()
 813                         {
 814                                 ${VERTEX_SETUP}
 815                                 ${VERTEX_OUTPUT}
 816                         }
 817                 ""
 818                 geometry ""
 819                         #version 310 es
 820                         ${GEOMETRY_DECLARATIONS}
 821                         flat out mediump uvec2 geo_var;
 822                         void main()
 823                         {
 824                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 825                                 {
 826                                         geo_var = val;
 827                                         gl_Position = gl_in[ndx].gl_Position;
 828                                         EmitVertex();
 829                                 }
 830                         }
 831                 ""
 832                 fragment ""
 833                         #version 310 es
 834                         precision highp int;
 835                         ${FRAGMENT_DECLARATIONS}
 836                         flat in uvec2 geo_var;
 837                         void main()
 838                         {
 839                                 out0 = geo_var;
 840                                 ${FRAGMENT_OUTPUT}
 841                         }
 842                 ""
 843         end
 844
 845         case uvec3
 846                 version 310 es
 847                 desc "uniform of type uvec3"
 848                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 849                 values
 850                 {
 851                         uniform uvec3 val       = [ uvec3(16, 17, 18) ];
 852                         output uvec3 out0       = [ uvec3(16, 17, 18) ];
 853                 }
 854                 vertex ""
 855                         #version 310 es
 856                         ${VERTEX_DECLARATIONS}
 857                         void main()
 858                         {
 859                                 ${VERTEX_SETUP}
 860                                 ${VERTEX_OUTPUT}
 861                         }
 862                 ""
 863                 geometry ""
 864                         #version 310 es
 865                         ${GEOMETRY_DECLARATIONS}
 866                         flat out mediump uvec3 geo_var;
 867                         void main()
 868                         {
 869                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 870                                 {
 871                                         geo_var = val;
 872                                         gl_Position = gl_in[ndx].gl_Position;
 873                                         EmitVertex();
 874                                 }
 875                         }
 876                 ""
 877                 fragment ""
 878                         #version 310 es
 879                         precision highp int;
 880                         ${FRAGMENT_DECLARATIONS}
 881                         flat in uvec3 geo_var;
 882                         void main()
 883                         {
 884                                 out0 = geo_var;
 885                                 ${FRAGMENT_OUTPUT}
 886                         }
 887                 ""
 888         end
 889
 890         case uvec4
 891                 version 310 es
 892                 desc "uniform of type uvec4"
 893                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 894                 values
 895                 {
 896                         uniform uvec4 val       = [ uvec4(16, 17, 18, 19) ];
 897                         output uvec4 out0       = [ uvec4(16, 17, 18, 19) ];
 898                 }
 899                 vertex ""
 900                         #version 310 es
 901                         ${VERTEX_DECLARATIONS}
 902                         void main()
 903                         {
 904                                 ${VERTEX_SETUP}
 905                                 ${VERTEX_OUTPUT}
 906                         }
 907                 ""
 908                 geometry ""
 909                         #version 310 es
 910                         ${GEOMETRY_DECLARATIONS}
 911                         flat out mediump uvec4 geo_var;
 912                         void main()
 913                         {
 914                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 915                                 {
 916                                         geo_var = val;
 917                                         gl_Position = gl_in[ndx].gl_Position;
 918                                         EmitVertex();
 919                                 }
 920                         }
 921                 ""
 922                 fragment ""
 923                         #version 310 es
 924                         precision highp int;
 925                         ${FRAGMENT_DECLARATIONS}
 926                         flat in uvec4 geo_var;
 927                         void main()
 928                         {
 929                                 out0 = geo_var;
 930                                 ${FRAGMENT_OUTPUT}
 931                         }
 932                 ""
 933         end
 934
 935         case float_struct
 936                 version 310 es
 937                 desc "varying of struct type containing float"
 938                 require extension { "GL_OES_geometry_shader" | "GL_EXT_geometry_shader" } in { geometry }
 939                 values
 940                 {
 941                         uniform float val.val   = [ 2.25 ];
 942                         output float out0               = [ 2.25 ];
 943                 }
 944                 vertex ""
 945                         #version 310 es
 946                         ${VERTEX_DECLARATIONS}
 947                         void main()
 948                         {
 949                                 ${VERTEX_SETUP}
 950                                 ${VERTEX_OUTPUT}
 951                         }
 952                 ""
 953                 geometry ""
 954                         #version 310 es
 955                         ${GEOMETRY_DECLARATIONS}
 956                         struct S { mediump float val; };
 957                         uniform S val;
 958                         out mediump float geo_var;
 959                         void main()
 960                         {
 961                                 for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 962                                 {
 963                                         geo_var = val.val;
 964                                         gl_Position = gl_in[ndx].gl_Position;
 965                                         EmitVertex();
 966                                 }
 967                         }
 968                 ""
 969                 fragment ""
 970                         #version 310 es
 971                         precision mediump float;
 972                         ${FRAGMENT_DECLARATIONS}
 973                         in mediump float geo_var;
 974                         void main()
 975                         {
 976                                 out0 = geo_var;
 977                                 ${FRAGMENT_OUTPUT}
 978                         }
 979                 ""
 980         end
 981 end