src/mesa/shader/slang/library/slang_common_builtin.gc

   1
   2 //
   3 // TODO:
   4 // - implement texture1D, texture2D, texture3D, textureCube,
   5 // - implement shadow1D, shadow2D,
   6 // - implement noise1, noise2, noise3, noise4,
   7 //
   8
   9 //
  10 // From Shader Spec, ver. 1.10, rev. 59
  11 //
  12
  13 const int gl_MaxLights = 8;
  14 const int gl_MaxClipPlanes = 6;
  15 const int gl_MaxTextureUnits = 8;
  16 const int gl_MaxTextureCoords = 8;
  17 const int gl_MaxVertexAttribs = 16;
  18 const int gl_MaxVertexUniformComponents = 512;
  19 const int gl_MaxVaryingFloats = 32;
  20 const int gl_MaxVertexTextureImageUnits = 0;
  21 const int gl_MaxCombinedTextureImageUnits = 2;
  22 const int gl_MaxTextureImageUnits = 2;
  23 const int gl_MaxFragmentUniformComponents = 64;
  24 const int gl_MaxDrawBuffers = 1;
  25
  26 uniform mat4 gl_ModelViewMatrix;
  27 uniform mat4 gl_ProjectionMatrix;
  28 uniform mat4 gl_ModelViewProjectionMatrix;
  29 uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];
  30
  31 uniform mat3 gl_NormalMatrix;
  32
  33 uniform mat4 gl_ModelViewMatrixInverse;
  34 uniform mat4 gl_ProjectionMatrixInverse;
  35 uniform mat4 gl_ModelViewProjectionMatrixInverse;
  36 uniform mat4 gl_TextureMatrixInverse[gl_MaxTextureCoords];
  37
  38 uniform mat4 gl_ModelViewMatrixTranspose;
  39 uniform mat4 gl_ProjectionMatrixTranspose;
  40 uniform mat4 gl_ModelViewProjectionMatrixTranspose;
  41 uniform mat4 gl_TextureMatrixTranspose[gl_MaxTextureCoords];
  42
  43 uniform mat4 gl_ModelViewMatrixInverseTranspose;
  44 uniform mat4 gl_ProjectionMatrixInverseTranspose;
  45 uniform mat4 gl_ModelViewProjectionMatrixInverseTranspose;
  46 uniform mat4 gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];
  47
  48 uniform float gl_NormalScale;
  49
  50 struct gl_DepthRangeParameters {
  51     float near;
  52     float far;
  53     float diff;
  54 };
  55
  56 uniform gl_DepthRangeParameters gl_DepthRange;
  57
  58 uniform vec4 gl_ClipPlane[gl_MaxClipPlanes];
  59
  60 struct gl_PointParameters {
  61     float size;
  62     float sizeMin;
  63     float sizeMax;
  64     float fadeThresholdSize;
  65     float distanceConstantAttenuation;
  66     float distanceLinearAttenuation;
  67     float distanceQuadraticAttenuation;
  68 };
  69
  70 uniform gl_PointParameters gl_Point;
  71
  72 struct gl_MaterialParameters {
  73     vec4 emission;
  74     vec4 ambient;
  75     vec4 diffuse;
  76     vec4 specular;
  77     float shininess;
  78 };
  79
  80 uniform gl_MaterialParameters gl_FrontMaterial;
  81 uniform gl_MaterialParameters gl_BackMaterial;
  82
  83 struct gl_LightSourceParameters {
  84     vec4 ambient;
  85     vec4 diffuse;
  86     vec4 specular;
  87     vec4 position;
  88     vec4 halfVector;
  89     vec3 spotDirection;
  90     float spotExponent;
  91     float spotCutoff;
  92     float spotCosCutoff;
  93     float constantAttenuation;
  94     float linearAttenuation;
  95     float quadraticAttenuation;
  96 };
  97
  98 uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];
  99
 100 struct gl_LightModelParameters {
 101     vec4 ambient;
 102 };
 103
 104 uniform gl_LightModelParameters gl_LightModel;
 105
 106 struct gl_LightModelProducts {
 107     vec4 sceneColor;
 108 };
 109
 110 uniform gl_LightModelProducts gl_FrontLightModelProduct;
 111 uniform gl_LightModelProducts gl_BackLightModelProduct;
 112
 113 struct gl_LightProducts {
 114     vec4 ambient;
 115     vec4 diffuse;
 116     vec4 specular;
 117 };
 118
 119 uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];
 120 uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];
 121
 122 uniform vec4 gl_TextureEnvColor[gl_MaxTextureImageUnits];
 123 uniform vec4 gl_EyePlaneS[gl_MaxTextureCoords];
 124 uniform vec4 gl_EyePlaneT[gl_MaxTextureCoords];
 125 uniform vec4 gl_EyePlaneR[gl_MaxTextureCoords];
 126 uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoords];
 127 uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoords];
 128 uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoords];
 129 uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoords];
 130 uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoords];
 131
 132 struct gl_FogParameters {
 133     vec4 color;
 134     float density;
 135     float start;
 136     float end;
 137     float scale;
 138 };
 139
 140 uniform gl_FogParameters gl_Fog;
 141
 142 //
 143 // 8.1 Angle and Trigonometry Functions
 144 //
 145
 146 float radians (float deg) {
 147     return 3.141593 * deg / 180.0;
 148 }
 149
 150 vec2 radians (vec2 deg) {
 151     return vec2 (3.141593) * deg / vec2 (180.0);
 152 }
 153
 154 vec3 radians (vec3 deg) {
 155     return vec3 (3.141593) * deg / vec3 (180.0);
 156 }
 157
 158 vec4 radians (vec4 deg) {
 159     return vec4 (3.141593) * deg / vec4 (180.0);
 160 }
 161
 162 float degrees (float rad) {
 163     return 180.0 * rad / 3.141593;
 164 }
 165
 166 vec2 degrees (vec2 rad) {
 167     return vec2 (180.0) * rad / vec2 (3.141593);
 168 }
 169
 170 vec3 degrees (vec3 rad) {
 171     return vec3 (180.0) * rad / vec3 (3.141593);
 172 }
 173
 174 vec4 degrees (vec4 rad) {
 175     return vec4 (180.0) * rad / vec4 (3.141593);
 176 }
 177
 178 float sin (float angle) {
 179     float x;
 180     __asm float_sine x, angle;
 181     return x;
 182 }
 183
 184 vec2 sin (vec2 angle) {
 185     vec2 u;
 186     u.x = sin (angle.x);
 187     u.y = sin (angle.y);
 188     return u;
 189 }
 190
 191 vec3 sin (vec3 angle) {
 192     vec3 u;
 193     u.x = sin (angle.x);
 194     u.y = sin (angle.y);
 195     u.z = sin (angle.z);
 196     return u;
 197 }
 198
 199 vec4 sin (vec4 angle) {
 200     vec4 u;
 201     u.x = sin (angle.x);
 202     u.y = sin (angle.y);
 203     u.z = sin (angle.z);
 204     u.w = sin (angle.w);
 205     return u;
 206 }
 207
 208 float cos (float angle) {
 209     return sin (angle + 1.5708);
 210 }
 211
 212 vec2 cos (vec2 angle) {
 213     vec2 u;
 214     u.x = cos (angle.x);
 215     u.y = cos (angle.y);
 216     return u;
 217 }
 218
 219 vec3 cos (vec3 angle) {
 220     vec3 u;
 221     u.x = cos (angle.x);
 222     u.y = cos (angle.y);
 223     u.z = cos (angle.z);
 224     return u;
 225 }
 226
 227 vec4 cos (vec4 angle) {
 228     vec4 u;
 229     u.x = cos (angle.x);
 230     u.y = cos (angle.y);
 231     u.z = cos (angle.z);
 232     u.w = cos (angle.w);
 233     return u;
 234 }
 235
 236 float tan (float angle) {
 237     return sin (angle) / cos (angle);
 238 }
 239
 240 vec2 tan (vec2 angle) {
 241     vec2 u;
 242     u.x = tan (angle.x);
 243     u.y = tan (angle.y);
 244     return u;
 245 }
 246
 247 vec3 tan (vec3 angle) {
 248     vec3 u;
 249     u.x = tan (angle.x);
 250     u.y = tan (angle.y);
 251     u.z = tan (angle.z);
 252     return u;
 253 }
 254
 255 vec4 tan (vec4 angle) {
 256     vec4 u;
 257     u.x = tan (angle.x);
 258     u.y = tan (angle.y);
 259     u.z = tan (angle.z);
 260     u.w = tan (angle.w);
 261     return u;
 262 }
 263
 264 float asin (float x) {
 265     float y;
 266     __asm float_arcsine y, x;
 267     return y;
 268 }
 269
 270 vec2 asin (vec2 v) {
 271     vec2 u;
 272     u.x = asin (v.x);
 273     u.y = asin (v.y);
 274     return u;
 275 }
 276
 277 vec3 asin (vec3 v) {
 278     vec3 u;
 279     u.x = asin (v.x);
 280     u.y = asin (v.y);
 281     u.z = asin (v.z);
 282     return u;
 283 }
 284
 285 vec4 asin (vec4 v) {
 286     vec4 u;
 287     u.x = asin (v.x);
 288     u.y = asin (v.y);
 289     u.z = asin (v.z);
 290     u.w = asin (v.w);
 291     return u;
 292 }
 293
 294 float acos (float x) {
 295     return 1.5708 - asin (x);
 296 }
 297
 298 vec2 acos (vec2 v) {
 299     vec2 u;
 300     u.x = acos (v.x);
 301     u.y = acos (v.y);
 302     return u;
 303 }
 304
 305 vec3 acos (vec3 v) {
 306     vec3 u;
 307     u.x = acos (v.x);
 308     u.y = acos (v.y);
 309     u.z = acos (v.z);
 310     return u;
 311 }
 312
 313 vec4 acos (vec4 v) {
 314     vec4 u;
 315     u.x = acos (v.x);
 316     u.y = acos (v.y);
 317     u.z = acos (v.z);
 318     u.w = acos (v.w);
 319     return u;
 320 }
 321
 322 float atan (float y_over_x) {
 323     float z;
 324     __asm float_arctan z, y_over_x;
 325     return z;
 326 }
 327
 328 vec2 atan (vec2 y_over_x) {
 329     vec2 u;
 330     u.x = atan (y_over_x.x);
 331     u.y = atan (y_over_x.y);
 332     return u;
 333 }
 334
 335 vec3 atan (vec3 y_over_x) {
 336     vec3 u;
 337     u.x = atan (y_over_x.x);
 338     u.y = atan (y_over_x.y);
 339     u.z = atan (y_over_x.z);
 340     return u;
 341 }
 342
 343 vec4 atan (vec4 y_over_x) {
 344     vec4 u;
 345     u.x = atan (y_over_x.x);
 346     u.y = atan (y_over_x.y);
 347     u.z = atan (y_over_x.z);
 348     u.w = atan (y_over_x.w);
 349     return u;
 350 }
 351
 352 float atan (float y, float x) {
 353     float z;
 354         z = atan (y / x);
 355     if (x < 0.0)
 356         {
 357                 if (y < 0.0)
 358                         return z - 3.141593;
 359                 return z + 3.141593;
 360         }
 361         return z;
 362 }
 363
 364 vec2 atan (vec2 u, vec2 v) {
 365     vec2 t;
 366     t.x = atan (u.x, v.x);
 367     t.y = atan (u.y, v.y);
 368     return t;
 369 }
 370
 371 vec3 atan (vec3 u, vec3 v) {
 372     vec3 t;
 373     t.x = atan (u.x, v.x);
 374     t.y = atan (u.y, v.y);
 375     t.z = atan (u.z, v.z);
 376     return t;
 377 }
 378
 379 vec4 atan (vec4 u, vec4 v) {
 380     vec4 t;
 381     t.x = atan (u.x, v.x);
 382     t.y = atan (u.y, v.y);
 383     t.z = atan (u.z, v.z);
 384     t.w = atan (u.w, v.w);
 385     return t;
 386 }
 387
 388 //
 389 // 8.2 Exponential Functions
 390 //
 391
 392 float pow (float x, float y) {
 393     float p;
 394     __asm float_power p, x, y;
 395     return p;
 396 }
 397
 398 vec2 pow (vec2 v, vec2 u) {
 399     vec2 t;
 400     t.x = pow (v.x, u.x);
 401     t.y = pow (v.y, u.y);
 402     return t;
 403 }
 404
 405 vec3 pow (vec3 v, vec3 u) {
 406     vec3 t;
 407     t.x = pow (v.x, u.x);
 408     t.y = pow (v.y, u.y);
 409     t.z = pow (v.z, u.z);
 410     return t;
 411 }
 412
 413 vec4 pow (vec4 v, vec4 u) {
 414     vec4 t;
 415     t.x = pow (v.x, u.x);
 416     t.y = pow (v.y, u.y);
 417     t.z = pow (v.z, u.z);
 418     t.w = pow (v.w, u.w);
 419     return t;
 420 }
 421
 422 float exp (float x) {
 423     return pow (2.71828183, x);
 424 }
 425
 426 vec2 exp (vec2 v) {
 427     return pow (vec2 (2.71828183), v);
 428 }
 429
 430 vec3 exp (vec3 v) {
 431     return pow (vec3 (2.71828183), v);
 432 }
 433
 434 vec4 exp (vec4 v) {
 435     return pow (vec4 (2.71828183), v);
 436 }
 437
 438 float log2 (float x) {
 439     float y;
 440     __asm float_log2 y, x;
 441     return y;
 442 }
 443
 444 vec2 log2 (vec2 v) {
 445     vec2 u;
 446     u.x = log2 (v.x);
 447     u.y = log2 (v.y);
 448     return u;
 449 }
 450
 451 vec3 log2 (vec3 v) {
 452     vec3 u;
 453     u.x = log2 (v.x);
 454     u.y = log2 (v.y);
 455     u.z = log2 (v.z);
 456     return u;
 457 }
 458
 459 vec4 log2 (vec4 v) {
 460     vec4 u;
 461     u.x = log2 (v.x);
 462     u.y = log2 (v.y);
 463     u.z = log2 (v.z);
 464     u.w = log2 (v.w);
 465     return u;
 466 }
 467
 468 float log (float x) {
 469     return log2 (x) / log2 (2.71828183);
 470 }
 471
 472 vec2 log (vec2 v) {
 473     return log2 (v) / log2 (vec2 (2.71828183));
 474 }
 475
 476 vec3 log (vec3 v) {
 477     return log2 (v) / log2 (vec3 (2.71828183));
 478 }
 479
 480 vec4 log (vec4 v) {
 481     return log2 (v) / log2 (vec4 (2.71828183));
 482 }
 483
 484 float exp2 (float x) {
 485     return pow (2.0, x);
 486 }
 487
 488 vec2 exp2 (vec2 v) {
 489     return pow (vec2 (2.0), v);
 490 }
 491
 492 vec3 exp2 (vec3 v) {
 493     return pow (vec3 (2.0), v);
 494 }
 495
 496 vec4 exp2 (vec4 v) {
 497     return pow (vec4 (2.0), v);
 498 }
 499
 500 float sqrt (float x) {
 501     return pow (x, 0.5);
 502 }
 503
 504 vec2 sqrt (vec2 v) {
 505     return pow (v, vec2 (0.5));
 506 }
 507
 508 vec3 sqrt (vec3 v) {
 509     return pow (v, vec3 (0.5));
 510 }
 511
 512 vec4 sqrt (vec4 v) {
 513     return pow (v, vec4 (0.5));
 514 }
 515
 516 float inversesqrt (float x) {
 517     return 1.0 / sqrt (x);
 518 }
 519
 520 vec2 inversesqrt (vec2 v) {
 521     return vec2 (1.0) / sqrt (v);
 522 }
 523
 524 vec3 inversesqrt (vec3 v) {
 525     return vec3 (1.0) / sqrt (v);
 526 }
 527
 528 vec4 inversesqrt (vec4 v) {
 529     return vec4 (1.0) / sqrt (v);
 530 }
 531
 532 //
 533 // 8.3 Common Functions
 534 //
 535
 536 float abs (float x) {
 537     return x >= 0.0 ? x : -x;
 538 }
 539
 540 vec2 abs (vec2 v) {
 541         vec2 u;
 542         u.x = abs (v.x);
 543         u.y = abs (v.y);
 544     return u;
 545 }
 546
 547 vec3 abs (vec3 v) {
 548     vec3 u;
 549         u.x = abs (v.x);
 550         u.y = abs (v.y);
 551         u.z = abs (v.z);
 552     return u;
 553 }
 554
 555 vec4 abs (vec4 v) {
 556     vec4 u;
 557         u.x = abs (v.x);
 558         u.y = abs (v.y);
 559         u.z = abs (v.z);
 560         u.w = abs (v.w);
 561     return u;
 562 }
 563
 564 float sign (float x) {
 565     return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : 0.0;
 566 }
 567
 568 vec2 sign (vec2 v) {
 569     vec2 u;
 570         u.x = sign (v.x);
 571         u.y = sign (v.y);
 572     return u;
 573 }
 574
 575 vec3 sign (vec3 v) {
 576     vec3 u;
 577         u.x = sign (v.x);
 578         u.y = sign (v.y);
 579         u.z = sign (v.z);
 580     return u;
 581 }
 582
 583 vec4 sign (vec4 v) {
 584     vec4 u;
 585         u.x = sign (v.x);
 586         u.y = sign (v.y);
 587         u.z = sign (v.z);
 588         u.w = sign (v.w);
 589     return u;
 590 }
 591
 592 float floor (float x) {
 593     float y;
 594         __asm float_floor y, x;
 595         return y;
 596 }
 597
 598 vec2 floor (vec2 v) {
 599     vec2 u;
 600         u.x = floor (v.x);
 601         u.y = floor (v.y);
 602     return u;
 603 }
 604
 605 vec3 floor (vec3 v) {
 606     vec3 u;
 607         u.x = floor (v.x);
 608         u.y = floor (v.y);
 609         u.z = floor (v.z);
 610     return u;
 611 }
 612
 613 vec4 floor (vec4 v) {
 614     vec4 u;
 615         u.x = floor (v.x);
 616         u.y = floor (v.y);
 617         u.z = floor (v.z);
 618         u.w = floor (v.w);
 619     return u;
 620 }
 621
 622 float ceil (float x) {
 623     float y;
 624         __asm float_ceil y, x;
 625         return y;
 626 }
 627
 628 vec2 ceil (vec2 v) {
 629     vec2 u;
 630         u.x = ceil (v.x);
 631         u.y = ceil (v.y);
 632     return u;
 633 }
 634
 635 vec3 ceil (vec3 v) {
 636     vec3 u;
 637         u.x = ceil (v.x);
 638         u.y = ceil (v.y);
 639         u.z = ceil (v.z);
 640     return u;
 641 }
 642
 643 vec4 ceil (vec4 v) {
 644     vec4 u;
 645         u.x = ceil (v.x);
 646         u.y = ceil (v.y);
 647         u.z = ceil (v.z);
 648         u.w = ceil (v.w);
 649     return u;
 650 }
 651
 652 float fract (float x) {
 653     return x - floor (x);
 654 }
 655
 656 vec2 fract (vec2 v) {
 657     return v - floor (v);
 658 }
 659
 660 vec3 fract (vec3 v) {
 661     return v - floor (v);
 662 }
 663
 664 vec4 fract (vec4 v) {
 665     return v - floor (v);
 666 }
 667
 668 float mod (float x, float y) {
 669     return x - y * floor (x / y);
 670 }
 671
 672 vec2 mod (vec2 v, float u) {
 673     return v - u * floor (v / u);
 674 }
 675
 676 vec3 mod (vec3 v, float u) {
 677     return v - u * floor (v / u);
 678 }
 679
 680 vec4 mod (vec4 v, float u) {
 681     return v - u * floor (v / u);
 682 }
 683
 684 vec2 mod (vec2 v, vec2 u) {
 685     return v - u * floor (v / u);
 686 }
 687
 688 vec3 mod (vec3 v, vec3 u) {
 689     return v - u * floor (v / u);
 690 }
 691
 692 vec4 mod (vec4 v, vec4 u) {
 693     return v - u * floor (v / u);
 694 }
 695
 696 float min (float x, float y) {
 697     return x < y ? x : y;
 698 }
 699
 700 vec2 min (vec2 v, vec2 u) {
 701     vec2 t;
 702         t.x = min (v.x, u.x);
 703         t.y = min (v.y, u.y);
 704         return t;
 705 }
 706
 707 vec3 min (vec3 v, vec3 u) {
 708     vec3 t;
 709         t.x = min (v.x, u.x);
 710         t.y = min (v.y, u.y);
 711         t.z = min (v.z, u.z);
 712         return t;
 713 }
 714
 715 vec4 min (vec4 v, vec4 u) {
 716     vec4 t;
 717         t.x = min (v.x, u.x);
 718         t.y = min (v.y, u.y);
 719         t.z = min (v.z, u.z);
 720         t.w = min (v.w, u.w);
 721         return t;
 722 }
 723
 724 vec2 min (vec2 v, float y) {
 725     return min (v, vec2 (y));
 726 }
 727
 728 vec3 min (vec3 v, float y) {
 729     return min (v, vec3 (y));
 730 }
 731
 732 vec4 min (vec4 v, float y) {
 733     return min (v, vec4 (y));
 734 }
 735
 736 float max (float x, float y) {
 737     return x < y ? y : x;
 738 }
 739
 740 vec2 max (vec2 v, vec2 u) {
 741     vec2 t;
 742         t.x = max (v.x, u.x);
 743         t.y = max (v.y, u.y);
 744         return t;
 745 }
 746
 747 vec3 max (vec3 v, vec3 u) {
 748     vec3 t;
 749         t.x = max (v.x, u.x);
 750         t.y = max (v.y, u.y);
 751         t.z = max (v.z, u.z);
 752         return t;
 753 }
 754
 755 vec4 max (vec4 v, vec4 u) {
 756     vec4 t;
 757         t.x = max (v.x, u.x);
 758         t.y = max (v.y, u.y);
 759         t.z = max (v.z, u.z);
 760         t.w = max (v.w, u.w);
 761         return t;
 762 }
 763
 764 vec2 max (vec2 v, float y) {
 765     return max (v, vec2 (y));
 766 }
 767
 768 vec3 max (vec3 v, float y) {
 769     return max (v, vec3 (y));
 770 }
 771
 772 vec4 max (vec4 v, float y) {
 773     return max (v, vec4 (y));
 774 }
 775
 776 float clamp (float x, float minVal, float maxVal) {
 777     return min (max (x, minVal), maxVal);
 778 }
 779
 780 vec2 clamp (vec2 x, float minVal, float maxVal) {
 781     return min (max (x, minVal), maxVal);
 782 }
 783
 784 vec3 clamp (vec3 x, float minVal, float maxVal) {
 785     return min (max (x, minVal), maxVal);
 786 }
 787
 788 vec4 clamp (vec4 x, float minVal, float maxVal) {
 789     return min (max (x, minVal), maxVal);
 790 }
 791
 792 vec2 clamp (vec2 x, vec2 minVal, vec2 maxVal) {
 793     return min (max (x, minVal), maxVal);
 794 }
 795
 796 vec3 clamp (vec3 x, vec3 minVal, vec3 maxVal) {
 797     return min (max (x, minVal), maxVal);
 798 }
 799
 800 vec4 clamp (vec4 x, vec4 minVal, vec4 maxVal) {
 801     return min (max (x, minVal), maxVal);
 802 }
 803
 804 float mix (float x, float y, float a) {
 805     return x * (1.0 - a) + y * a;
 806 }
 807
 808 vec2 mix (vec2 x, vec2 y, float a) {
 809     return x * (1.0 - a) + y * a;
 810 }
 811
 812 vec3 mix (vec3 x, vec3 y, float a) {
 813     return x * (1.0 - a) + y * a;
 814 }
 815
 816 vec4 mix (vec4 x, vec4 y, float a) {
 817     return x * (1.0 - a) + y * a;
 818 }
 819
 820 vec2 mix (vec2 x, vec2 y, vec2 a) {
 821     return x * (1.0 - a) + y * a;
 822 }
 823
 824 vec3 mix (vec3 x, vec3 y, vec3 a) {
 825     return x * (1.0 - a) + y * a;
 826 }
 827
 828 vec4 mix (vec4 x, vec4 y, vec4 a) {
 829     return x * (1.0 - a) + y * a;
 830 }
 831
 832 float step (float edge, float x) {
 833     return x < edge ? 0.0 : 1.0;
 834 }
 835
 836 vec2 step (vec2 edge, vec2 v) {
 837     vec2 u;
 838         u.x = step (edge.x, v.x);
 839         u.y = step (edge.y, v.y);
 840         return u;
 841 }
 842
 843 vec3 step (vec3 edge, vec3 v) {
 844     vec3 u;
 845         u.x = step (edge.x, v.x);
 846         u.y = step (edge.y, v.y);
 847         u.z = step (edge.z, v.z);
 848         return u;
 849 }
 850
 851 vec4 step (vec4 edge, vec4 v) {
 852     vec4 u;
 853         u.x = step (edge.x, v.x);
 854         u.y = step (edge.y, v.y);
 855         u.z = step (edge.z, v.z);
 856         u.w = step (edge.w, v.w);
 857         return u;
 858 }
 859
 860 vec2 step (float edge, vec2 v) {
 861     return step (vec2 (edge), v);
 862 }
 863
 864 vec3 step (float edge, vec3 v) {
 865     return step (vec3 (edge), v);
 866 }
 867
 868 vec4 step (float edge, vec4 v) {
 869     return step (vec4 (edge), v);
 870 }
 871
 872 float smoothstep (float edge0, float edge1, float x) {
 873     float t;
 874         t = clamp ((x - edge0) / (edge1 - edge0), 0.0, 1.0);
 875     return t * t * (3.0 - 2.0 * t);
 876 }
 877
 878 vec2 smoothstep (vec2 edge0, vec2 edge1, vec2 v) {
 879     vec2 u;
 880         u.x = smoothstep (edge0.x, edge1.x, v.x);
 881         u.y = smoothstep (edge0.y, edge1.y, v.y);
 882         return u;
 883 }
 884
 885 vec3 smoothstep (vec3 edge0, vec3 edge1, vec3 v) {
 886     vec3 u;
 887         u.x = smoothstep (edge0.x, edge1.x, v.x);
 888         u.y = smoothstep (edge0.y, edge1.y, v.y);
 889         u.z = smoothstep (edge0.z, edge1.z, v.z);
 890         return u;
 891 }
 892
 893 vec4 smoothstep (vec4 edge0, vec4 edge1, vec4 v) {
 894     vec4 u;
 895         u.x = smoothstep (edge0.x, edge1.x, v.x);
 896         u.y = smoothstep (edge0.y, edge1.y, v.y);
 897         u.z = smoothstep (edge0.z, edge1.z, v.z);
 898         u.w = smoothstep (edge0.w, edge1.w, v.w);
 899         return u;
 900 }
 901
 902 vec2 smoothstep (float edge0, float edge1, vec2 v) {
 903     vec2 u;
 904         u.x = smoothstep (edge0, edge1, v.x);
 905         u.y = smoothstep (edge0, edge1, v.y);
 906         return u;
 907 }
 908
 909 vec3 smoothstep (float edge0, float edge1, vec3 v) {
 910     vec3 u;
 911         u.x = smoothstep (edge0, edge1, v.x);
 912         u.y = smoothstep (edge0, edge1, v.y);
 913         u.z = smoothstep (edge0, edge1, v.z);
 914         return u;
 915 }
 916
 917 vec4 smoothstep (float edge0, float edge1, vec4 v) {
 918     vec4 u;
 919         u.x = smoothstep (edge0, edge1, v.x);
 920         u.y = smoothstep (edge0, edge1, v.y);
 921         u.z = smoothstep (edge0, edge1, v.z);
 922         u.w = smoothstep (edge0, edge1, v.w);
 923         return u;
 924 }
 925
 926 //
 927 // 8.4 Geometric Functions
 928 //
 929
 930 float dot (float x, float y) {
 931     return x * y;
 932 }
 933
 934 float dot (vec2 v, vec2 u) {
 935     return v.x * u.x + v.y * u.y;
 936 }
 937
 938 float dot (vec3 v, vec3 u) {
 939     return v.x * u.x + v.y * u.y + v.z * u.z;
 940 }
 941
 942 float dot (vec4 v, vec4 u) {
 943     return v.x * u.x + v.y * u.y + v.z * u.z + v.w * u.w;
 944 }
 945
 946 float length (float x) {
 947     return sqrt (dot (x, x));
 948 }
 949
 950 float length (vec2 v) {
 951     return sqrt (dot (v, v));
 952 }
 953
 954 float length (vec3 v) {
 955     return sqrt (dot (v, v));
 956 }
 957
 958 float length (vec4 v) {
 959     return sqrt (dot (v, v));
 960 }
 961
 962 float distance (float x, float y) {
 963     return length (x - y);
 964 }
 965
 966 float distance (vec2 v, vec2 u) {
 967     return length (v - u);
 968 }
 969
 970 float distance (vec3 v, vec3 u) {
 971     return length (v - u);
 972 }
 973
 974 float distance (vec4 v, vec4 u) {
 975     return length (v - u);
 976 }
 977
 978 vec3 cross (vec3 v, vec3 u) {
 979     vec3 t;
 980     t.x = v.y * u.z - u.y * v.z;
 981     t.y = v.z * u.x - u.z * v.x;
 982     t.z = v.x * u.y - u.x * v.y;
 983     return t;
 984 }
 985
 986 float normalize (float x) {
 987     return 1.0;
 988 }
 989
 990 vec2 normalize (vec2 v) {
 991     return v / length (v);
 992 }
 993
 994 vec3 normalize (vec3 v) {
 995     return v / length (v);
 996 }
 997
 998 vec4 normalize (vec4 v) {
 999     return v / length (v);
1000 }
1001
1002 float faceforward (float N, float I, float Nref) {
1003     return dot (Nref, I) < 0.0 ? N : -N;
1004 }
1005
1006 vec2 faceforward (vec2 N, vec2 I, vec2 Nref) {
1007     return dot (Nref, I) < 0.0 ? N : -N;
1008 }
1009
1010 vec3 faceforward (vec3 N, vec3 I, vec3 Nref) {
1011     return dot (Nref, I) < 0.0 ? N : -N;
1012 }
1013
1014 vec4 faceforward (vec4 N, vec4 I, vec4 Nref) {
1015     return dot (Nref, I) < 0.0 ? N : -N;
1016 }
1017
1018 float reflect (float I, float N) {
1019     return I - 2.0 * dot (N, I) * N;
1020 }
1021
1022 vec2 reflect (vec2 I, vec2 N) {
1023     return I - 2.0 * dot (N, I) * N;
1024 }
1025
1026 vec3 reflect (vec3 I, vec3 N) {
1027     return I - 2.0 * dot (N, I) * N;
1028 }
1029
1030 vec4 reflect (vec4 I, vec4 N) {
1031     return I - 2.0 * dot (N, I) * N;
1032 }
1033
1034 float refract (float I, float N, float eta) {
1035     float k;
1036         k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
1037     if (k < 0.0)
1038         return 0.0;
1039     return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
1040 }
1041
1042 vec2 refract (vec2 I, vec2 N, float eta) {
1043     float k;
1044         k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
1045     if (k < 0.0)
1046         return 0.0;
1047     return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
1048 }
1049
1050 vec3 refract (vec3 I, vec3 N, float eta) {
1051     float k;
1052         k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
1053     if (k < 0.0)
1054         return 0.0;
1055     return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
1056 }
1057
1058 vec4 refract (vec4 I, vec4 N, float eta) {
1059     float k;
1060         k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
1061     if (k < 0.0)
1062         return 0.0;
1063     return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
1064 }
1065
1066 //
1067 // 8.5 Matrix Functions
1068 //
1069
1070 mat2 matrixCompMult (mat2 m, mat2 n) {
1071     mat2 o;
1072     o[0] = m[0] * n[0];
1073     o[1] = m[1] * n[1];
1074     return o;
1075 }
1076
1077 mat3 matrixCompMult (mat3 m, mat3 n) {
1078     mat3 o;
1079     o[0] = m[0] * n[0];
1080     o[1] = m[1] * n[1];
1081     o[2] = m[2] * n[2];
1082     return o;
1083 }
1084
1085 mat4 matrixCompMult (mat4 m, mat4 n) {
1086     mat4 o;
1087     o[0] = m[0] * n[0];
1088     o[1] = m[1] * n[1];
1089     o[2] = m[2] * n[2];
1090     o[3] = m[3] * n[3];
1091     return o;
1092 }
1093
1094 //
1095 // 8.6 Vector Relational Functions
1096 //
1097
1098 bvec2 lessThan (vec2 v, vec2 u) {
1099         bvec2 b;
1100         b.x = v.x < u.x;
1101         b.y = v.y < u.y;
1102         return b;
1103 }
1104
1105 bvec3 lessThan (vec3 v, vec3 u) {
1106     bvec3 b;
1107         b.x = v.x < u.x;
1108         b.y = v.y < u.y;
1109         b.z = v.z < u.z;
1110         return b;
1111 }
1112
1113 bvec4 lessThan (vec4 v, vec4 u) {
1114     bvec4 b;
1115         b.x = v.x < u.x;
1116         b.y = v.y < u.y;
1117         b.z = v.z < u.z;
1118         b.w = v.w < u.w;
1119         return b;
1120 }
1121
1122 bvec2 lessThan (ivec2 v, ivec2 u) {
1123     bvec2 b;
1124         b.x = v.x < u.x;
1125         b.y = v.y < u.y;
1126         return b;
1127 }
1128
1129 bvec3 lessThan (ivec3 v, ivec3 u) {
1130     bvec3 b;
1131         b.x = v.x < u.x;
1132         b.y = v.y < u.y;
1133         b.z = v.z < u.z;
1134         return b;
1135 }
1136
1137 bvec4 lessThan (ivec4 v, ivec4 u) {
1138     bvec4 b;
1139         b.x = v.x < u.x;
1140         b.y = v.y < u.y;
1141         b.z = v.z < u.z;
1142         b.w = v.w < u.w;
1143         return b;
1144 }
1145
1146 bvec2 lessThanEqual (vec2 v, vec2 u) {
1147     bvec2 b;
1148         b.x = v.x <= u.x;
1149         b.y = v.y <= u.y;
1150         return b;
1151 }
1152
1153 bvec3 lessThanEqual (vec3 v, vec3 u) {
1154     bvec3 b;
1155         b.x = v.x <= u.x;
1156         b.y = v.y <= u.y;
1157         b.z = v.z <= u.z;
1158         return b;
1159 }
1160
1161 bvec4 lessThanEqual (vec4 v, vec4 u) {
1162     bvec4 b;
1163         b.x = v.x <= u.x;
1164         b.y = v.y <= u.y;
1165         b.z = v.z <= u.z;
1166         b.w = v.w <= u.w;
1167         return b;
1168 }
1169
1170 bvec2 lessThanEqual (ivec2 v, ivec2 u) {
1171     bvec2 b;
1172         b.x = v.x <= u.x;
1173         b.y = v.y <= u.y;
1174         return b;
1175 }
1176
1177 bvec3 lessThanEqual (ivec3 v, ivec3 u) {
1178     bvec3 b;
1179         b.x = v.x <= u.x;
1180         b.y = v.y <= u.y;
1181         b.z = v.z <= u.z;
1182         return b;
1183 }
1184
1185 bvec4 lessThanEqual (ivec4 v, ivec4 u) {
1186     bvec4 b;
1187         b.x = v.x <= u.x;
1188         b.y = v.y <= u.y;
1189         b.z = v.z <= u.z;
1190         b.w = v.w <= u.w;
1191         return b;
1192 }
1193
1194 bvec2 greaterThan (vec2 v, vec2 u) {
1195     bvec2 b;
1196         b.x = v.x > u.x;
1197         b.y = v.y > u.y;
1198         return b;
1199 }
1200
1201 bvec3 greaterThan (vec3 v, vec3 u) {
1202     bvec3 b;
1203         b.x = v.x > u.x;
1204         b.y = v.y > u.y;
1205         b.z = v.z > u.z;
1206         return b;
1207 }
1208
1209 bvec4 greaterThan (vec4 v, vec4 u) {
1210     bvec4 b;
1211         b.x = v.x > u.x;
1212         b.y = v.y > u.y;
1213         b.z = v.z > u.z;
1214         b.w = v.w > u.w;
1215         return b;
1216 }
1217
1218 bvec2 greaterThan (ivec2 v, ivec2 u) {
1219     bvec2 b;
1220         b.x = v.x > u.x;
1221         b.y = v.y > u.y;
1222         return b;
1223 }
1224
1225 bvec3 greaterThan (ivec3 v, ivec3 u) {
1226     bvec3 b;
1227         b.x = v.x > u.x;
1228         b.y = v.y > u.y;
1229         b.z = v.z > u.z;
1230         return b;
1231 }
1232
1233 bvec4 greaterThan (ivec4 v, ivec4 u) {
1234     bvec4 b;
1235         b.x = v.x > u.x;
1236         b.y = v.y > u.y;
1237         b.z = v.z > u.z;
1238         b.w = v.w > u.w;
1239         return b;
1240 }
1241
1242 bvec2 greaterThanEqual (vec2 v, vec2 u) {
1243     bvec2 b;
1244         b.x = v.x >= u.x;
1245         b.y = v.y >= u.y;
1246         return b;
1247 }
1248
1249 bvec3 greaterThanEqual (vec3 v, vec3 u) {
1250     bvec3 b;
1251         b.x = v.x >= u.x;
1252         b.y = v.y >= u.y;
1253         b.z = v.z >= u.z;
1254         return b;
1255 }
1256
1257 bvec4 greaterThanEqual (vec4 v, vec4 u) {
1258     bvec4 b;
1259         b.x = v.x >= u.x;
1260         b.y = v.y >= u.y;
1261         b.z = v.z >= u.z;
1262         b.w = v.w >= u.w;
1263         return b;
1264 }
1265
1266 bvec2 greaterThanEqual (ivec2 v, ivec2 u) {
1267     bvec2 b;
1268         b.x = v.x >= u.x;
1269         b.y = v.y >= u.y;
1270         return b;
1271 }
1272
1273 bvec3 greaterThanEqual (ivec3 v, ivec3 u) {
1274     bvec3 b;
1275         b.x = v.x >= u.x;
1276         b.y = v.y >= u.y;
1277         b.z = v.z >= u.z;
1278         return b;
1279 }
1280
1281 bvec4 greaterThanEqual (ivec4 v, ivec4 u) {
1282     bvec4 b;
1283         b.x = v.x >= u.x;
1284         b.y = v.y >= u.y;
1285         b.z = v.z >= u.z;
1286         b.w = v.w >= u.w;
1287         return b;
1288 }
1289
1290 bvec2 equal (vec2 v, vec2 u) {
1291     bvec2 b;
1292         b.x = v.x == u.x;
1293         b.y = v.y == u.y;
1294         return b;
1295 }
1296
1297 bvec3 equal (vec3 v, vec3 u) {
1298     bvec3 b;
1299         b.x = v.x == u.x;
1300         b.y = v.y == u.y;
1301         b.z = v.z == u.z;
1302         return b;
1303 }
1304
1305 bvec4 equal (vec4 v, vec4 u) {
1306     bvec4 b;
1307         b.x = v.x == u.x;
1308         b.y = v.y == u.y;
1309         b.z = v.z == u.z;
1310         b.w = v.w == u.w;
1311         return b;
1312 }
1313
1314 bvec2 equal (ivec2 v, ivec2 u) {
1315     bvec2 b;
1316         b.x = v.x == u.x;
1317         b.y = v.y == u.y;
1318         return b;
1319 }
1320
1321 bvec3 equal (ivec3 v, ivec3 u) {
1322     bvec3 b;
1323         b.x = v.x == u.x;
1324         b.y = v.y == u.y;
1325         b.z = v.z == u.z;
1326         return b;
1327 }
1328
1329 bvec4 equal (ivec4 v, ivec4 u) {
1330     bvec4 b;
1331         b.x = v.x == u.x;
1332         b.y = v.y == u.y;
1333         b.z = v.z == u.z;
1334         b.w = v.w == u.w;
1335         return b;
1336 }
1337
1338 bvec2 notEqual (vec2 v, vec2 u) {
1339     bvec2 b;
1340         b.x = v.x != u.x;
1341         b.y = v.y != u.y;
1342         return b;
1343 }
1344
1345 bvec3 notEqual (vec3 v, vec3 u) {
1346     bvec3 b;
1347         b.x = v.x != u.x;
1348         b.y = v.y != u.y;
1349         b.z = v.z != u.z;
1350         return b;
1351 }
1352
1353 bvec4 notEqual (vec4 v, vec4 u) {
1354     bvec4 b;
1355         b.x = v.x != u.x;
1356         b.y = v.y != u.y;
1357         b.z = v.z != u.z;
1358         b.w = v.w != u.w;
1359         return b;
1360 }
1361
1362 bvec2 notEqual (ivec2 v, ivec2 u) {
1363     bvec2 b;
1364         b.x = v.x != u.x;
1365         b.y = v.y != u.y;
1366         return b;
1367 }
1368
1369 bvec3 notEqual (ivec3 v, ivec3 u) {
1370     bvec3 b;
1371         b.x = v.x != u.x;
1372         b.y = v.y != u.y;
1373         b.z = v.z != u.z;
1374         return b;
1375 }
1376
1377 bvec4 notEqual (ivec4 v, ivec4 u) {
1378     bvec4 b;
1379         b.x = v.x != u.x;
1380         b.y = v.y != u.y;
1381         b.z = v.z != u.z;
1382         b.w = v.w != u.w;
1383         return b;
1384 }
1385
1386 bool any (bvec2 v) {
1387     return v.x || v.y;
1388 }
1389
1390 bool any (bvec3 v) {
1391     return v.x || v.y || v.z;
1392 }
1393
1394 bool any (bvec4 v) {
1395     return v.x || v.y || v.z || v.w;
1396 }
1397
1398 bool all (bvec2 v) {
1399     return v.x && v.y;
1400 }
1401
1402 bool all (bvec3 v) {
1403     return v.x && v.y && v.z;
1404 }
1405
1406 bool all (bvec4 v) {
1407     return v.x && v.y && v.z && v.w;
1408 }
1409
1410 bvec2 not (bvec2 v) {
1411         bvec2 u;
1412         u.x = !v.x;
1413         u.y = !v.y;
1414     return u;
1415 }
1416
1417 bvec3 not (bvec3 v) {
1418     bvec3 u;
1419         u.x = !v.x;
1420         u.y = !v.y;
1421         u.z = !v.z;
1422     return u;
1423 }
1424
1425 bvec4 not (bvec4 v) {
1426     bvec4 u;
1427         u.x = !v.x;
1428         u.y = !v.y;
1429         u.z = !v.z;
1430         u.w = !v.w;
1431     return u;
1432 }
1433
1434 //
1435 // 8.7 Texture Lookup Functions
1436 //
1437
1438 vec4 texture1D (sampler1D sampler, float coord) {
1439     // XXX:
1440     return vec4 (0.0);
1441 }
1442
1443 vec4 texture1DProj (sampler1D sampler, vec2 coord) {
1444     return texture1D (sampler, coord.s / coord.t);
1445 }
1446
1447 vec4 texture1DProj (sampler1D sampler, vec4 coord) {
1448     return texture1D (sampler, coord.s / coord.q);
1449 }
1450
1451 vec4 texture2D (sampler2D sampler, vec2 coord) {
1452     // XXX:
1453     return vec4 (0.0);
1454 }
1455
1456 vec4 texture2DProj (sampler2D sampler, vec3 coord) {
1457     vec2 u;
1458     u.s = coord.s / coord.p;
1459     u.t = coord.t / coord.p;
1460     return texture2D (sampler, u);
1461 }
1462
1463 vec4 texture2DProj (sampler2D sampler, vec4 coord) {
1464     vec2 u;
1465     u.s = coord.s / coord.q;
1466     u.t = coord.t / coord.q;
1467     return texture2D (sampler, u);
1468 }
1469
1470 vec4 texture3D (sampler3D sampler, vec3 coord) {
1471     // XXX:
1472     return vec4 (0.0);
1473 }
1474
1475 vec4 texture3DProj (sampler3D sampler, vec4 coord) {
1476     vec3 u;
1477     u.s = coord.s / coord.q;
1478     u.t = coord.t / coord.q;
1479     u.p = coord.p / coord.q;
1480     return texture3D (sampler, u);
1481 }
1482
1483 vec4 textureCube (samplerCube sampler, vec3 coord) {
1484     // XXX:
1485     return vec4 (0.0);
1486 }
1487
1488 vec4 shadow1D (sampler1DShadow sampler, vec3 coord) {
1489     // XXX:
1490     return vec4 (0.0);
1491 }
1492
1493 vec4 shadow2D (sampler2DShadow sampler, vec3 coord) {
1494     // XXX:
1495     return vec4 (0.0);
1496 }
1497
1498 vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord) {
1499     vec3 u;
1500     u.s = coord.s / coord.q;
1501     u.t = 0.0;
1502     u.p = coord.p / coord.q;
1503     return shadow1D (sampler, u);
1504 }
1505
1506 vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord) {
1507     vec3 u;
1508     u.s = coord.s / coord.q;
1509     u.t = coord.t / coord.q;
1510     u.p = coord.p / coord.q;
1511     return shadow2D (sampler, u);
1512 }
1513
1514 //
1515 // 8.9 Noise Functions
1516 //
1517
1518 float noise1 (float x) {
1519     // XXX:
1520     return 0.0;
1521 }
1522
1523 float noise1 (vec2 x) {
1524     // XXX:
1525     return 0.0;
1526 }
1527
1528 float noise1 (vec3 x) {
1529     // XXX:
1530     return 0.0;
1531 }
1532
1533 float noise1 (vec4 x) {
1534     // XXX:
1535     return 0.0;
1536 }
1537
1538 vec2 noise2 (float x) {
1539     // XXX:
1540     return vec2 (0.0);
1541 }
1542
1543 vec2 noise2 (vec2 x) {
1544     // XXX:
1545     return vec2 (0.0);
1546 }
1547
1548 vec2 noise2 (vec3 x) {
1549     // XXX:
1550     return vec2 (0.0);
1551 }
1552
1553 vec2 noise2 (vec4 x) {
1554     // XXX:
1555     return vec2 (0.0);
1556 }
1557
1558 vec3 noise3 (float x) {
1559     // XXX:
1560     return vec3 (0.0);
1561 }
1562
1563 vec3 noise3 (vec2 x) {
1564     // XXX:
1565     return vec3 (0.0);
1566 }
1567
1568 vec3 noise3 (vec3 x) {
1569     // XXX:
1570     return vec3 (0.0);
1571 }
1572
1573 vec3 noise3 (vec4 x) {
1574     // XXX:
1575     return vec3 (0.0);
1576 }
1577
1578 vec4 noise4 (float x) {
1579     // XXX:
1580     return vec4 (0.0);
1581 }
1582
1583 vec4 noise4 (vec2 x) {
1584     // XXX:
1585     return vec4 (0.0);
1586 }
1587
1588 vec4 noise4 (vec3 x) {
1589     // XXX:
1590     return vec4 (0.0);
1591 }
1592
1593 vec4 noise4 (vec4 x) {
1594     // XXX:
1595     return vec4 (0.0);
1596 }
1597