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

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 2006  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 //
  26 // From Shader Spec, ver. 1.10, rev. 59
  27 //
  28
  29 //bp: XXX these will probably go away since the value needs to be
  30 //determined at runtime and may vary from one GLcontext to another...
  31 const int gl_MaxLights = 8;
  32 const int gl_MaxClipPlanes = 6;
  33 const int gl_MaxTextureUnits = 8;
  34 const int gl_MaxTextureCoords = 8;
  35 const int gl_MaxVertexAttribs = 16;
  36 const int gl_MaxVertexUniformComponents = 512;
  37 const int gl_MaxVaryingFloats = 32;
  38 const int gl_MaxVertexTextureImageUnits = 0;
  39 const int gl_MaxCombinedTextureImageUnits = 2;
  40 const int gl_MaxTextureImageUnits = 2;
  41 const int gl_MaxFragmentUniformComponents = 64;
  42 const int gl_MaxDrawBuffers = 1;
  43
  44 uniform mat4 gl_ModelViewMatrix;
  45 uniform mat4 gl_ProjectionMatrix;
  46 uniform mat4 gl_ModelViewProjectionMatrix;
  47 uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];
  48
  49 uniform mat3 gl_NormalMatrix;
  50 uniform mat3 __NormalMatrixTranspose;  // Mesa only
  51
  52 uniform mat4 gl_ModelViewMatrixInverse;
  53 uniform mat4 gl_ProjectionMatrixInverse;
  54 uniform mat4 gl_ModelViewProjectionMatrixInverse;
  55 uniform mat4 gl_TextureMatrixInverse[gl_MaxTextureCoords];
  56
  57 uniform mat4 gl_ModelViewMatrixTranspose;
  58 uniform mat4 gl_ProjectionMatrixTranspose;
  59 uniform mat4 gl_ModelViewProjectionMatrixTranspose;
  60 uniform mat4 gl_TextureMatrixTranspose[gl_MaxTextureCoords];
  61
  62 uniform mat4 gl_ModelViewMatrixInverseTranspose;
  63 uniform mat4 gl_ProjectionMatrixInverseTranspose;
  64 uniform mat4 gl_ModelViewProjectionMatrixInverseTranspose;
  65 uniform mat4 gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];
  66
  67 uniform float gl_NormalScale;
  68
  69 struct gl_DepthRangeParameters {
  70     float near;
  71     float far;
  72     float diff;
  73 };
  74
  75 uniform gl_DepthRangeParameters gl_DepthRange;
  76
  77 uniform vec4 gl_ClipPlane[gl_MaxClipPlanes];
  78
  79 struct gl_PointParameters {
  80     float size;
  81     float sizeMin;
  82     float sizeMax;
  83     float fadeThresholdSize;
  84     float distanceConstantAttenuation;
  85     float distanceLinearAttenuation;
  86     float distanceQuadraticAttenuation;
  87 };
  88
  89 uniform gl_PointParameters gl_Point;
  90
  91 struct gl_MaterialParameters {
  92     vec4 emission;
  93     vec4 ambient;
  94     vec4 diffuse;
  95     vec4 specular;
  96     float shininess;
  97 };
  98
  99 uniform gl_MaterialParameters gl_FrontMaterial;
 100 uniform gl_MaterialParameters gl_BackMaterial;
 101
 102 struct gl_LightSourceParameters {
 103     vec4 ambient;
 104     vec4 diffuse;
 105     vec4 specular;
 106     vec4 position;
 107     vec4 halfVector;
 108     vec3 spotDirection;
 109     float spotExponent;
 110     float spotCutoff;
 111     float spotCosCutoff;
 112     float constantAttenuation;
 113     float linearAttenuation;
 114     float quadraticAttenuation;
 115 };
 116
 117 uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];
 118
 119 struct gl_LightModelParameters {
 120     vec4 ambient;
 121 };
 122
 123 uniform gl_LightModelParameters gl_LightModel;
 124
 125 struct gl_LightModelProducts {
 126     vec4 sceneColor;
 127 };
 128
 129 uniform gl_LightModelProducts gl_FrontLightModelProduct;
 130 uniform gl_LightModelProducts gl_BackLightModelProduct;
 131
 132 struct gl_LightProducts {
 133     vec4 ambient;
 134     vec4 diffuse;
 135     vec4 specular;
 136 };
 137
 138 uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];
 139 uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];
 140
 141 uniform vec4 gl_TextureEnvColor[gl_MaxTextureImageUnits];
 142 uniform vec4 gl_EyePlaneS[gl_MaxTextureCoords];
 143 uniform vec4 gl_EyePlaneT[gl_MaxTextureCoords];
 144 uniform vec4 gl_EyePlaneR[gl_MaxTextureCoords];
 145 uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoords];
 146 uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoords];
 147 uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoords];
 148 uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoords];
 149 uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoords];
 150
 151 struct gl_FogParameters {
 152     vec4 color;
 153     float density;
 154     float start;
 155     float end;
 156     float scale;
 157 };
 158
 159 uniform gl_FogParameters gl_Fog;
 160
 161
 162
 163
 164
 165 //
 166 // 8.1 Angle and Trigonometry Functions
 167 //
 168
 169 //// radians
 170
 171 float radians(const float deg)
 172 {
 173    const float c = 3.1415926 / 180.0;
 174    __asm vec4_multiply __retVal.x, deg, c;
 175 }
 176
 177 vec2 radians(const vec2 deg)
 178 {
 179    const float c = 3.1415926 / 180.0;
 180    __asm vec4_multiply __retVal.xy, deg.xy, c.xx;
 181 }
 182
 183 vec3 radians(const vec3 deg)
 184 {
 185    const float c = 3.1415926 / 180.0;
 186    __asm vec4_multiply __retVal.xyz, deg.xyz, c.xxx;
 187 }
 188
 189 vec4 radians(const vec4 deg)
 190 {
 191    const float c = 3.1415926 / 180.0;
 192    __asm vec4_multiply __retVal, deg, c.xxxx;
 193 }
 194
 195
 196 //// degrees
 197
 198 float degrees(const float rad)
 199 {
 200    const float c = 180.0 / 3.1415926;
 201    __asm vec4_multiply __retVal.x, rad, c;
 202 }
 203
 204 vec2 degrees(const vec2 rad)
 205 {
 206    const float c = 180.0 / 3.1415926;
 207    __asm vec4_multiply __retVal.xy, rad.xy, c.xx;
 208 }
 209
 210 vec3 degrees(const vec3 rad)
 211 {
 212    const float c = 180.0 / 3.1415926;
 213    __asm vec4_multiply __retVal.xyz, rad.xyz, c.xxx;
 214 }
 215
 216 vec4 degrees(const vec4 rad)
 217 {
 218    const float c = 180.0 / 3.1415926;
 219    __asm vec4_multiply __retVal, rad, c.xxxx;
 220 }
 221
 222
 223 //// sin
 224
 225 float sin(const float radians)
 226 {
 227    __asm float_sine __retVal.x, radians;
 228 }
 229
 230 vec2 sin(const vec2 radians)
 231 {
 232    __asm float_sine __retVal.x, radians.x;
 233    __asm float_sine __retVal.y, radians.y;
 234 }
 235
 236 vec3 sin(const vec3 radians)
 237 {
 238    __asm float_sine __retVal.x, radians.x;
 239    __asm float_sine __retVal.y, radians.y;
 240    __asm float_sine __retVal.z, radians.z;
 241 }
 242
 243 vec4 sin(const vec4 radians)
 244 {
 245    __asm float_sine __retVal.x, radians.x;
 246    __asm float_sine __retVal.y, radians.y;
 247    __asm float_sine __retVal.z, radians.z;
 248    __asm float_sine __retVal.w, radians.w;
 249 }
 250
 251
 252 //// cos
 253
 254 float cos(const float radians)
 255 {
 256    __asm float_cosine __retVal.x, radians;
 257 }
 258
 259 vec2 cos(const vec2 radians)
 260 {
 261    __asm float_cosine __retVal.x, radians.x;
 262    __asm float_cosine __retVal.y, radians.y;
 263 }
 264
 265 vec3 cos(const vec3 radians)
 266 {
 267    __asm float_cosine __retVal.x, radians.x;
 268    __asm float_cosine __retVal.y, radians.y;
 269    __asm float_cosine __retVal.z, radians.z;
 270 }
 271
 272 vec4 cos(const vec4 radians)
 273 {
 274    __asm float_cosine __retVal.x, radians.x;
 275    __asm float_cosine __retVal.y, radians.y;
 276    __asm float_cosine __retVal.z, radians.z;
 277    __asm float_cosine __retVal.w, radians.w;
 278 }
 279
 280
 281
 282 //// tan
 283
 284 float tan(const float angle)
 285 {
 286    const float s = sin(angle);
 287    const float c = cos(angle);
 288    return s / c;
 289 }
 290
 291 vec2 tan(const vec2 angle)
 292 {
 293    const vec2 s = sin(angle);
 294    const vec2 c = cos(angle);
 295    return s / c;
 296 }
 297
 298 vec3 tan(const vec3 angle)
 299 {
 300    const vec3 s = sin(angle);
 301    const vec3 c = cos(angle);
 302    return s / c;
 303 }
 304
 305 vec4 tan(const vec4 angle)
 306 {
 307    const vec4 s = sin(angle);
 308    const vec4 c = cos(angle);
 309    return s / c;
 310 }
 311
 312
 313
 314 float asin(const float x)
 315 {
 316    const float a0 = 1.5707288;  // PI/2?
 317    const float a1 = -0.2121144;
 318    const float a2 = 0.0742610;
 319    //const float a3 = -0.0187293;
 320    const float halfPi = 3.1415926 * 0.5;
 321    const float y = abs(x);
 322    // three terms seem to be enough:
 323    __retVal = (halfPi - sqrt(1.0 - y) * (a0 + y * (a1 + a2 * y))) * sign(x);
 324    // otherwise, try four:
 325    //__retVal = (halfPi - sqrt(1.0 - y) * (a0 + y * (a1 + y * (a2 + y * a3)))) * sign(x);
 326 }
 327
 328 vec2 asin(const vec2 v)
 329 {
 330    __retVal.x = asin(v.x);
 331    __retVal.y = asin(v.y);
 332 }
 333
 334 vec3 asin(const vec3 v)
 335 {
 336    __retVal.x = asin(v.x);
 337    __retVal.y = asin(v.y);
 338    __retVal.z = asin(v.z);
 339 }
 340
 341 vec4 asin(const vec4 v)
 342 {
 343    __retVal.x = asin(v.x);
 344    __retVal.y = asin(v.y);
 345    __retVal.z = asin(v.z);
 346    __retVal.w = asin(v.w);
 347 }
 348
 349 float acos(const float x)
 350 {
 351    const float halfPi = 3.1415926 * 0.5;
 352    __retVal = halfPi - asin(x);
 353 }
 354
 355 vec2 acos(const vec2 v)
 356 {
 357    __retVal.x = acos(v.x);
 358    __retVal.y = acos(v.y);
 359 }
 360
 361 vec3 acos(const vec3 v)
 362 {
 363    __retVal.x = acos(v.x);
 364    __retVal.y = acos(v.y);
 365    __retVal.z = acos(v.z);
 366 }
 367
 368 vec4 acos(const vec4 v)
 369 {
 370    __retVal.x = acos(v.x);
 371    __retVal.y = acos(v.y);
 372    __retVal.z = acos(v.z);
 373    __retVal.w = acos(v.w);
 374 }
 375
 376 float atan(const float x)
 377 {
 378    __retVal = asin(x * inversesqrt(x * x + 1.0));
 379 }
 380
 381 vec2 atan(const vec2 y_over_x)
 382 {
 383    __retVal.x = atan(y_over_x.x);
 384    __retVal.y = atan(y_over_x.y);
 385 }
 386
 387 vec3 atan(const vec3 y_over_x)
 388 {
 389    __retVal.x = atan(y_over_x.x);
 390    __retVal.y = atan(y_over_x.y);
 391    __retVal.z = atan(y_over_x.z);
 392 }
 393
 394 vec4 atan(const vec4 y_over_x)
 395 {
 396    __retVal.x = atan(y_over_x.x);
 397    __retVal.y = atan(y_over_x.y);
 398    __retVal.z = atan(y_over_x.z);
 399    __retVal.w = atan(y_over_x.w);
 400 }
 401
 402 float atan(const float y, const float x)
 403 {
 404    float r;
 405    if (abs(x) > 1.0e-4) {
 406       r = atan(y / x);
 407       if (x < 0.0) {
 408          r = r + sign(y) * 3.141593;
 409       }
 410    }
 411    else {
 412       r = sign(y) * 1.5707965;  // pi/2
 413    }
 414    return r;
 415 }
 416
 417 vec2 atan(const vec2 u, const vec2 v)
 418 {
 419    __retVal.x = atan(u.x, v.x);
 420    __retVal.y = atan(u.y, v.y);
 421 }
 422
 423 vec3 atan(const vec3 u, const vec3 v)
 424 {
 425    __retVal.x = atan(u.x, v.x);
 426    __retVal.y = atan(u.y, v.y);
 427    __retVal.z = atan(u.z, v.z);
 428 }
 429
 430 vec4 atan(const vec4 u, const vec4 v)
 431 {
 432    __retVal.x = atan(u.x, v.x);
 433    __retVal.y = atan(u.y, v.y);
 434    __retVal.z = atan(u.z, v.z);
 435    __retVal.w = atan(u.w, v.w);
 436 }
 437
 438
 439 //
 440 // 8.2 Exponential Functions
 441 //
 442
 443 //// pow
 444
 445 float pow(const float a, const float b)
 446 {
 447    __asm float_power __retVal.x, a, b;
 448 }
 449
 450 vec2 pow(const vec2 a, const vec2 b)
 451 {
 452    __asm float_power __retVal.x, a.x, b.x;
 453    __asm float_power __retVal.y, a.y, b.y;
 454 }
 455
 456 vec3 pow(const vec3 a, const vec3 b)
 457 {
 458    __asm float_power __retVal.x, a.x, b.x;
 459    __asm float_power __retVal.y, a.y, b.y;
 460    __asm float_power __retVal.z, a.z, b.z;
 461 }
 462
 463 vec4 pow(const vec4 a, const vec4 b)
 464 {
 465    __asm float_power __retVal.x, a.x, b.x;
 466    __asm float_power __retVal.y, a.y, b.y;
 467    __asm float_power __retVal.z, a.z, b.z;
 468    __asm float_power __retVal.w, a.w, b.w;
 469 }
 470
 471
 472 //// exp
 473
 474 float exp(const float a)
 475 {
 476    const float e = 2.71828;
 477    __asm float_power __retVal, e, a;
 478 }
 479
 480 vec2 exp(const vec2 a)
 481 {
 482    const float e = 2.71828;
 483    __asm float_power __retVal.x, e, a.x;
 484    __asm float_power __retVal.y, e, a.y;
 485 }
 486
 487 vec3 exp(const vec3 a)
 488 {
 489    const float e = 2.71828;
 490    __asm float_power __retVal.x, e, a.x;
 491    __asm float_power __retVal.y, e, a.y;
 492    __asm float_power __retVal.z, e, a.z;
 493 }
 494
 495 vec4 exp(const vec4 a)
 496 {
 497    const float e = 2.71828;
 498    __asm float_power __retVal.x, e, a.x;
 499    __asm float_power __retVal.y, e, a.y;
 500    __asm float_power __retVal.z, e, a.z;
 501    __asm float_power __retVal.w, e, a.w;
 502 }
 503
 504
 505
 506 //// log2
 507
 508 float log2(const float x)
 509 {
 510    __asm float_log2 __retVal.x, x;
 511 }
 512
 513 vec2 log2(const vec2 v)
 514 {
 515    __asm float_log2 __retVal.x, v.x;
 516    __asm float_log2 __retVal.y, v.y;
 517 }
 518
 519 vec3 log2(const vec3 v)
 520 {
 521    __asm float_log2 __retVal.x, v.x;
 522    __asm float_log2 __retVal.y, v.y;
 523    __asm float_log2 __retVal.z, v.z;
 524 }
 525
 526 vec4 log2(const vec4 v)
 527 {
 528    __asm float_log2 __retVal.x, v.x;
 529    __asm float_log2 __retVal.y, v.y;
 530    __asm float_log2 __retVal.z, v.z;
 531    __asm float_log2 __retVal.w, v.w;
 532 }
 533
 534
 535 //// log  (natural log)
 536
 537 float log(const float x)
 538 {
 539    // note:  logBaseB(x) = logBaseN(x) / logBaseN(B)
 540    // compute log(x) = log2(x) / log2(e)
 541    // c = 1.0 / log2(e) = 0.693147181
 542    const float c = 0.693147181;
 543    return log2(x) * c;
 544 }
 545
 546 vec2 log(const vec2 v)
 547 {
 548    const float c = 0.693147181;
 549    return log2(v) * c;
 550 }
 551
 552 vec3 log(const vec3 v)
 553 {
 554    const float c = 0.693147181;
 555    return log2(v) * c;
 556 }
 557
 558 vec4 log(const vec4 v)
 559 {
 560    const float c = 0.693147181;
 561    return log2(v) * c;
 562 }
 563
 564
 565 //// exp2
 566
 567 float exp2(const float a)
 568 {
 569    __asm float_exp2 __retVal.x, a;
 570 }
 571
 572 vec2 exp2(const vec2 a)
 573 {
 574    __asm float_exp2 __retVal.x, a.x;
 575    __asm float_exp2 __retVal.y, a.y;
 576 }
 577
 578 vec3 exp2(const vec3 a)
 579 {
 580    __asm float_exp2 __retVal.x, a.x;
 581    __asm float_exp2 __retVal.y, a.y;
 582    __asm float_exp2 __retVal.z, a.z;
 583 }
 584
 585 vec4 exp2(const vec4 a)
 586 {
 587    __asm float_exp2 __retVal.x, a.x;
 588    __asm float_exp2 __retVal.y, a.y;
 589    __asm float_exp2 __retVal.z, a.z;
 590    __asm float_exp2 __retVal.w, a.w;
 591 }
 592
 593
 594 //// sqrt
 595
 596 float sqrt(const float x)
 597 {
 598    float r;
 599    __asm float_rsq r, x;
 600    __asm float_rcp __retVal.x, r;
 601 }
 602
 603 vec2 sqrt(const vec2 v)
 604 {
 605    float r;
 606    __asm float_rsq r, v.x;
 607    __asm float_rcp __retVal.x, r;
 608    __asm float_rsq r, v.y;
 609    __asm float_rcp __retVal.y, r;
 610 }
 611
 612 vec3 sqrt(const vec3 v)
 613 {
 614    float r;
 615    __asm float_rsq r, v.x;
 616    __asm float_rcp __retVal.x, r;
 617    __asm float_rsq r, v.y;
 618    __asm float_rcp __retVal.y, r;
 619    __asm float_rsq r, v.z;
 620    __asm float_rcp __retVal.z, r;
 621 }
 622
 623 vec4 sqrt(const vec4 v)
 624 {
 625    float r;
 626    __asm float_rsq r, v.x;
 627    __asm float_rcp __retVal.x, r;
 628    __asm float_rsq r, v.y;
 629    __asm float_rcp __retVal.y, r;
 630    __asm float_rsq r, v.z;
 631    __asm float_rcp __retVal.z, r;
 632    __asm float_rsq r, v.w;
 633    __asm float_rcp __retVal.w, r;
 634 }
 635
 636
 637 //// inversesqrt
 638
 639 float inversesqrt(const float x)
 640 {
 641    __asm float_rsq __retVal.x, x;
 642 }
 643
 644 vec2 inversesqrt(const vec2 v)
 645 {
 646    __asm float_rsq __retVal.x, v.x;
 647    __asm float_rsq __retVal.y, v.y;
 648 }
 649
 650 vec3 inversesqrt(const vec3 v)
 651 {
 652    __asm float_rsq __retVal.x, v.x;
 653    __asm float_rsq __retVal.y, v.y;
 654    __asm float_rsq __retVal.z, v.z;
 655 }
 656
 657 vec4 inversesqrt(const vec4 v)
 658 {
 659    __asm float_rsq __retVal.x, v.x;
 660    __asm float_rsq __retVal.y, v.y;
 661    __asm float_rsq __retVal.z, v.z;
 662    __asm float_rsq __retVal.w, v.w;
 663 }
 664
 665
 666 //// normalize
 667
 668 float normalize(const float x)
 669 {
 670    __retVal.x = 1.0;
 671 }
 672
 673 vec2 normalize(const vec2 v)
 674 {
 675    const float s = inversesqrt(dot(v, v));
 676    __asm vec4_multiply __retVal.xy, v, s.xx;
 677 }
 678
 679 vec3 normalize(const vec3 v)
 680 {
 681 //   const float s = inversesqrt(dot(v, v));
 682 //   __retVal = v * s;
 683 // XXX note, we _could_ use __retVal.w instead of tmp and and save a
 684 // register, but that's actually a compilation error because v is a vec3
 685 // and the .w suffix is illegal.  Oh well.
 686    float tmp;
 687    __asm vec3_dot tmp, v, v;
 688    __asm float_rsq tmp, tmp;
 689    __asm vec4_multiply __retVal.xyz, v, tmp.xxx;
 690 }
 691
 692 vec4 normalize(const vec4 v)
 693 {
 694    float tmp;
 695    __asm vec4_dot tmp, v, v;
 696    __asm float_rsq tmp, tmp;
 697    __asm vec4_multiply __retVal.xyz, v, tmp.xxx;
 698 }
 699
 700
 701
 702 //
 703 // 8.3 Common Functions
 704 //
 705
 706
 707 //// abs
 708
 709 float abs(const float a)
 710 {
 711    __asm vec4_abs __retVal.x, a;
 712 }
 713
 714 vec2 abs(const vec2 a)
 715 {
 716    __asm vec4_abs __retVal.xy, a;
 717 }
 718
 719 vec3 abs(const vec3 a)
 720 {
 721    __asm vec4_abs __retVal.xyz, a;
 722 }
 723
 724 vec4 abs(const vec4 a)
 725 {
 726    __asm vec4_abs __retVal, a;
 727 }
 728
 729
 730 //// sign
 731
 732 float sign(const float x)
 733 {
 734    float p, n;
 735    __asm vec4_sgt p.x, x, 0.0;            // p = (x > 0)
 736    __asm vec4_sgt n.x, 0.0, x;            // n = (x < 0)
 737    __asm vec4_subtract __retVal.x, p, n;  // sign = p - n
 738 }
 739
 740 vec2 sign(const vec2 v)
 741 {
 742    vec2 p, n;
 743    __asm vec4_sgt p.xy, v, 0.0;
 744    __asm vec4_sgt n.xy, 0.0, v;
 745    __asm vec4_subtract __retVal.xy, p, n;
 746 }
 747
 748 vec3 sign(const vec3 v)
 749 {
 750    vec3 p, n;
 751    __asm vec4_sgt p.xyz, v, 0.0;
 752    __asm vec4_sgt n.xyz, 0.0, v;
 753    __asm vec4_subtract __retVal.xyz, p, n;
 754 }
 755
 756 vec4 sign(const vec4 v)
 757 {
 758    vec4 p, n;
 759    __asm vec4_sgt p, v, 0.0;
 760    __asm vec4_sgt n, 0.0, v;
 761    __asm vec4_subtract __retVal, p, n;
 762 }
 763
 764
 765 //// floor
 766
 767 float floor(const float a)
 768 {
 769    __asm vec4_floor __retVal.x, a;
 770 }
 771
 772 vec2 floor(const vec2 a)
 773 {
 774    __asm vec4_floor __retVal.xy, a;
 775 }
 776
 777 vec3 floor(const vec3 a)
 778 {
 779    __asm vec4_floor __retVal.xyz, a;
 780 }
 781
 782 vec4 floor(const vec4 a)
 783 {
 784    __asm vec4_floor __retVal, a;
 785 }
 786
 787
 788 //// ceil
 789
 790 float ceil(const float a)
 791 {
 792    // XXX this could be improved
 793    float b = -a;
 794    __asm vec4_floor b, b;
 795    __retVal.x = -b;
 796 }
 797
 798 vec2 ceil(const vec2 a)
 799 {
 800    vec2 b = -a;
 801    __asm vec4_floor b, b;
 802    __retVal.xy = -b;
 803 }
 804
 805 vec3 ceil(const vec3 a)
 806 {
 807    vec3 b = -a;
 808    __asm vec4_floor b, b;
 809    __retVal.xyz = -b;
 810 }
 811
 812 vec4 ceil(const vec4 a)
 813 {
 814    vec4 b = -a;
 815    __asm vec4_floor b, b;
 816    __retVal = -b;
 817 }
 818
 819
 820 //// fract
 821
 822 float fract(const float a)
 823 {
 824    __asm vec4_frac __retVal.x, a;
 825 }
 826
 827 vec2 fract(const vec2 a)
 828 {
 829    __asm vec4_frac __retVal.xy, a;
 830 }
 831
 832 vec3 fract(const vec3 a)
 833 {
 834    __asm vec4_frac __retVal.xyz, a;
 835 }
 836
 837 vec4 fract(const vec4 a)
 838 {
 839    __asm vec4_frac __retVal, a;
 840 }
 841
 842
 843 //// mod  (very untested!)
 844
 845 float mod(const float a, const float b)
 846 {
 847     float oneOverB;
 848     __asm float_rcp oneOverB, b;
 849     __retVal.x = a - b * floor(a * oneOverB);
 850 }
 851
 852 vec2 mod(const vec2 a, const float b)
 853 {
 854     float oneOverB;
 855     __asm float_rcp oneOverB, b;
 856     __retVal.xy = a - b * floor(a * oneOverB);
 857 }
 858
 859 vec3 mod(const vec3 a, const float b)
 860 {
 861     float oneOverB;
 862     __asm float_rcp oneOverB, b;
 863     __retVal.xyz = a - b * floor(a * oneOverB);
 864 }
 865
 866 vec4 mod(const vec4 a, const float b)
 867 {
 868     float oneOverB;
 869     __asm float_rcp oneOverB, b;
 870     __retVal = a - b * floor(a * oneOverB);
 871 }
 872
 873 vec2 mod(const vec2 a, const vec2 b)
 874 {
 875     float oneOverBx, oneOverBy;
 876     __asm float_rcp oneOverBx, b.x;
 877     __asm float_rcp oneOverBy, b.y;
 878     __retVal.x = a.x - b.x * floor(a.x * oneOverBx);
 879     __retVal.y = a.y - b.y * floor(a.y * oneOverBy);
 880 }
 881
 882 vec3 mod(const vec3 a, const vec3 b)
 883 {
 884     float oneOverBx, oneOverBy, oneOverBz;
 885     __asm float_rcp oneOverBx, b.x;
 886     __asm float_rcp oneOverBy, b.y;
 887     __asm float_rcp oneOverBz, b.z;
 888     __retVal.x = a.x - b.x * floor(a.x * oneOverBx);
 889     __retVal.y = a.y - b.y * floor(a.y * oneOverBy);
 890     __retVal.z = a.z - b.z * floor(a.z * oneOverBz);
 891 }
 892
 893 vec4 mod(const vec4 a, const vec4 b)
 894 {
 895     float oneOverBx, oneOverBy, oneOverBz, oneOverBw;
 896     __asm float_rcp oneOverBx, b.x;
 897     __asm float_rcp oneOverBy, b.y;
 898     __asm float_rcp oneOverBz, b.z;
 899     __asm float_rcp oneOverBw, b.w;
 900     __retVal.x = a.x - b.x * floor(a.x * oneOverBx);
 901     __retVal.y = a.y - b.y * floor(a.y * oneOverBy);
 902     __retVal.z = a.z - b.z * floor(a.z * oneOverBz);
 903     __retVal.w = a.w - b.w * floor(a.w * oneOverBw);
 904 }
 905
 906
 907 //// min
 908
 909 float min(const float a, const float b)
 910 {
 911    __asm vec4_min __retVal.x, a.x, b.x;
 912 }
 913
 914 vec2 min(const vec2 a, const vec2 b)
 915 {
 916    __asm vec4_min __retVal.xy, a.xy, b.xy;
 917 }
 918
 919 vec3 min(const vec3 a, const vec3 b)
 920 {
 921    __asm vec4_min __retVal.xyz, a.xyz, b.xyz;
 922 }
 923
 924 vec4 min(const vec4 a, const vec4 b)
 925 {
 926    __asm vec4_min __retVal, a, b;
 927 }
 928
 929 vec2 min(const vec2 a, const float b)
 930 {
 931    __asm vec4_min __retVal, a.xy, b.xx;
 932 }
 933
 934 vec3 min(const vec3 a, const float b)
 935 {
 936    __asm vec4_min __retVal, a.xyz, b.xxx;
 937 }
 938
 939 vec4 min(const vec4 a, const float b)
 940 {
 941    __asm vec4_min __retVal, a, b.xxxx;
 942 }
 943
 944
 945 //// max
 946
 947 float max(const float a, const float b)
 948 {
 949    __asm vec4_max __retVal.x, a.x, b.x;
 950 }
 951
 952 vec2 max(const vec2 a, const vec2 b)
 953 {
 954    __asm vec4_max __retVal.xy, a.xy, b.xy;
 955 }
 956
 957 vec3 max(const vec3 a, const vec3 b)
 958 {
 959    __asm vec4_max __retVal.xyz, a.xyz, b.xyz;
 960 }
 961
 962 vec4 max(const vec4 a, const vec4 b)
 963 {
 964    __asm vec4_max __retVal, a, b;
 965 }
 966
 967 vec2 max(const vec2 a, const float b)
 968 {
 969    __asm vec4_max __retVal, a.xy, b.xx;
 970 }
 971
 972 vec3 max(const vec3 a, const float b)
 973 {
 974    __asm vec4_max __retVal, a.xyz, b.xxx;
 975 }
 976
 977 vec4 max(const vec4 a, const float b)
 978 {
 979    __asm vec4_max __retVal, a, b.xxxx;
 980 }
 981
 982
 983 //// clamp
 984
 985 float clamp(const float val, const float minVal, const float maxVal)
 986 {
 987    __asm vec4_clamp __retVal, val, minVal, maxVal;
 988 }
 989
 990 vec2 clamp(const vec2 val, const float minVal, const float maxVal)
 991 {
 992    __asm vec4_clamp __retVal, val, minVal, maxVal;
 993 }
 994
 995 vec3 clamp(const vec3 val, const float minVal, const float maxVal)
 996 {
 997    __asm vec4_clamp __retVal, val, minVal, maxVal;
 998 }
 999
1000 vec4 clamp(const vec4 val, const float minVal, const float maxVal)
1001 {
1002    __asm vec4_clamp __retVal, val, minVal, maxVal;
1003 }
1004
1005 vec2 clamp(const vec2 val, const vec2 minVal, const vec2 maxVal)
1006 {
1007    __asm vec4_clamp __retVal, val, minVal, maxVal;
1008 }
1009
1010 vec3 clamp(const vec3 val, const vec3 minVal, const vec3 maxVal)
1011 {
1012    __asm vec4_clamp __retVal, val, minVal, maxVal;
1013 }
1014
1015 vec4 clamp(const vec4 val, const vec4 minVal, const vec4 maxVal)
1016 {
1017    __asm vec4_clamp __retVal, val, minVal, maxVal;
1018 }
1019
1020
1021 //// mix
1022
1023 float mix(const float x, const float y, const float a)
1024 {
1025    __asm vec4_lrp __retVal, a, y, x;
1026 }
1027
1028 vec2 mix(const vec2 x, const vec2 y, const float a)
1029 {
1030    __asm vec4_lrp __retVal, a, y, x;
1031 }
1032
1033 vec3 mix(const vec3 x, const vec3 y, const float a)
1034 {
1035    __asm vec4_lrp __retVal, a, y, x;
1036 }
1037
1038 vec4 mix(const vec4 x, const vec4 y, const float a)
1039 {
1040    __asm vec4_lrp __retVal, a, y, x;
1041 }
1042
1043 vec2 mix(const vec2 x, const vec2 y, const vec2 a)
1044 {
1045    __asm vec4_lrp __retVal, a, y, x;
1046 }
1047
1048 vec3 mix(const vec3 x, const vec3 y, const vec3 a)
1049 {
1050    __asm vec4_lrp __retVal, a, y, x;
1051 }
1052
1053 vec4 mix(const vec4 x, const vec4 y, const vec4 a)
1054 {
1055    __asm vec4_lrp __retVal, a, y, x;
1056 }
1057
1058
1059 //// step (untested)
1060
1061 float step(const float edge, const float x)
1062 {
1063    __asm vec4_sgt __retVal.x, x, edge;
1064 }
1065
1066 vec2 step(const vec2 edge, const vec2 x)
1067 {
1068    __asm vec4_sgt __retVal.xy, x, edge;
1069 }
1070
1071 vec3 step(const vec3 edge, const vec3 x)
1072 {
1073    __asm vec4_sgt __retVal.xyz, x, edge;
1074 }
1075
1076 vec4 step(const vec4 edge, const vec4 x)
1077 {
1078    __asm vec4_sgt __retVal, x, edge;
1079 }
1080
1081 vec2 step(const float edge, const vec2 v)
1082 {
1083    __asm vec4_sgt __retVal.xy, v, edge.xx;
1084 }
1085
1086 vec3 step(const float edge, const vec3 v)
1087 {
1088    __asm vec4_sgt __retVal.xyz, v, edge.xxx;
1089 }
1090
1091 vec4 step(const float edge, const vec4 v)
1092 {
1093    __asm vec4_sgt __retVal, v, edge.xxxx;
1094 }
1095
1096
1097 //// smoothstep (untested)
1098
1099 float smoothstep(const float edge0, const float edge1, const float x)
1100 {
1101     float t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
1102     return t * t * (3.0 - 2.0 * t);
1103 }
1104
1105 vec2 smoothstep(const vec2 edge0, const vec2 edge1, const vec2 v)
1106 {
1107    vec2 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1108    return t * t * (3.0 - 2.0 * t);
1109 }
1110
1111 vec3 smoothstep(const vec3 edge0, const vec3 edge1, const vec3 v)
1112 {
1113    vec3 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1114    return t * t * (3.0 - 2.0 * t);
1115 }
1116
1117 vec4 smoothstep(const vec4 edge0, const vec4 edge1, const vec4 v)
1118 {
1119    vec4 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1120    return t * t * (3.0 - 2.0 * t);
1121 }
1122
1123 vec2 smoothstep(const float edge0, const float edge1, const vec2 v)
1124 {
1125    vec2 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1126    return t * t * (3.0 - 2.0 * t);
1127 }
1128
1129 vec3 smoothstep(const float edge0, const float edge1, const vec3 v)
1130 {
1131    vec3 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1132    return t * t * (3.0 - 2.0 * t);
1133 }
1134
1135 vec4 smoothstep(const float edge0, const float edge1, const vec4 v)
1136 {
1137    vec4 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1138    return t * t * (3.0 - 2.0 * t);
1139 }
1140
1141
1142
1143 //
1144 // 8.4 Geometric Functions
1145 //
1146
1147
1148 //// length
1149
1150 float length(const float x)
1151 {
1152    return abs(x);
1153 }
1154
1155 float length(const vec2 v)
1156 {
1157    float r;
1158    const float p = dot(v, v);      // p = v.x * v.x + v.y * v.y
1159    __asm float_rsq r, p;           // r = 1 / sqrt(p)
1160    __asm float_rcp __retVal.x, r;  // retVal = 1 / r
1161 }
1162
1163 float length(const vec3 v)
1164 {
1165    float r;
1166    const float p = dot(v, v);      // p = v.x * v.x + v.y * v.y + v.z * v.z
1167    __asm float_rsq r, p;           // r = 1 / sqrt(p)
1168    __asm float_rcp __retVal.x, r;  // retVal = 1 / r
1169 }
1170
1171 float length(const vec4 v)
1172 {
1173    float r;
1174    const float p = dot(v, v);      // p = v.x * v.x + v.y * v.y + ...
1175    __asm float_rsq r, p;           // r = 1 / sqrt(p)
1176    __asm float_rcp __retVal.x, r;  // retVal = 1 / r
1177 }
1178
1179
1180 //// distance
1181
1182 float distance(const float x, const float y)
1183 {
1184    const float d = x - y;
1185    __retVal = length(d);
1186 }
1187
1188 float distance(const vec2 v, const vec2 u)
1189 {
1190    const vec2 d2 = v - u;
1191    __retVal = length(d2);
1192 }
1193
1194 float distance(const vec3 v, const vec3 u)
1195 {
1196    const vec3 d3 = v - u;
1197    __retVal = length(d3);
1198 }
1199
1200 float distance(const vec4 v, const vec4 u)
1201 {
1202    const vec4 d4 = v - u;
1203    __retVal = length(d4);
1204 }
1205
1206
1207 //// cross
1208
1209 vec3 cross(const vec3 v, const vec3 u)
1210 {
1211    __asm vec3_cross __retVal.xyz, v, u;
1212 }
1213
1214
1215 //// faceforward
1216
1217 float faceforward(const float N, const float I, const float Nref)
1218 {
1219     // this could probably be done better
1220     const float d = dot(Nref, I);
1221     float s;
1222     __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
1223     return mix(-N, N, s);
1224 }
1225
1226 vec2 faceforward(const vec2 N, const vec2 I, const vec2 Nref)
1227 {
1228     // this could probably be done better
1229     const float d = dot(Nref, I);
1230     float s;
1231     __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
1232     return mix(-N, N, s);
1233 }
1234
1235 vec3 faceforward(const vec3 N, const vec3 I, const vec3 Nref)
1236 {
1237     // this could probably be done better
1238     const float d = dot(Nref, I);
1239     float s;
1240     __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
1241     return mix(-N, N, s);
1242 }
1243
1244 vec4 faceforward(const vec4 N, const vec4 I, const vec4 Nref)
1245 {
1246     // this could probably be done better
1247     const float d = dot(Nref, I);
1248     float s;
1249     __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
1250     return mix(-N, N, s);
1251 }
1252
1253
1254 //// reflect
1255
1256 float reflect(const float I, const float N)
1257 {
1258    return I - 2.0 * dot(N, I) * N;
1259 }
1260
1261 vec2 reflect(const vec2 I, const vec2 N)
1262 {
1263    return I - 2.0 * dot(N, I) * N;
1264 }
1265
1266 vec3 reflect(const vec3 I, const vec3 N)
1267 {
1268    return I - 2.0 * dot(N, I) * N;
1269 }
1270
1271 vec4 reflect(const vec4 I, const vec4 N)
1272 {
1273    return I - 2.0 * dot(N, I) * N;
1274 }
1275
1276 //// refract
1277
1278 float refract(const float I, const float N, const float eta)
1279 {
1280    float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1281    if (k < 0.0)
1282        return 0.0;
1283    return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1284 }
1285
1286 vec2 refract(const vec2 I, const vec2 N, const float eta)
1287 {
1288    float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1289    if (k < 0.0)
1290       return 0.0;
1291    return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1292 }
1293
1294 vec3 refract(const vec3 I, const vec3 N, const float eta)
1295 {
1296    float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1297    if (k < 0.0)
1298       return 0.0;
1299    return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1300 }
1301
1302 vec4 refract(const vec4 I, const vec4 N, const float eta)
1303 {
1304    float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1305    if (k < 0.0)
1306       return 0.0;
1307    return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1308 }
1309
1310
1311
1312
1313 //
1314 // 8.5 Matrix Functions
1315 //
1316
1317 mat2 matrixCompMult (mat2 m, mat2 n) {
1318     return mat2 (m[0] * n[0], m[1] * n[1]);
1319 }
1320
1321 mat3 matrixCompMult (mat3 m, mat3 n) {
1322     return mat3 (m[0] * n[0], m[1] * n[1], m[2] * n[2]);
1323 }
1324
1325 mat4 matrixCompMult (mat4 m, mat4 n) {
1326     return mat4 (m[0] * n[0], m[1] * n[1], m[2] * n[2], m[3] * n[3]);
1327 }
1328
1329
1330
1331
1332 //
1333 // 8.6 Vector Relational Functions
1334 //
1335
1336 //// lessThan
1337
1338 bvec2 lessThan(const vec2 u, const vec2 v)
1339 {
1340    __asm vec4_slt __retVal.xy, u, v;
1341 }
1342
1343 bvec3 lessThan(const vec3 u, const vec3 v)
1344 {
1345    __asm vec4_slt __retVal.xyz, u, v;
1346 }
1347
1348 bvec4 lessThan(const vec4 u, const vec4 v)
1349 {
1350    __asm vec4_slt __retVal, u, v;
1351 }
1352
1353 bvec2 lessThan(const ivec2 u, const ivec2 v)
1354 {
1355    __asm vec4_slt __retVal.xy, u, v;
1356 }
1357
1358 bvec3 lessThan(const ivec3 u, const ivec3 v)
1359 {
1360    __asm vec4_slt __retVal.xyz, u, v;
1361 }
1362
1363 bvec4 lessThan(const ivec4 u, const ivec4 v)
1364 {
1365    __asm vec4_slt __retVal, u, v;
1366 }
1367
1368
1369 //// lessThanEqual
1370
1371 bvec2 lessThanEqual(const vec2 u, const vec2 v)
1372 {
1373    __asm vec4_sle __retVal.xy, u, v;
1374 }
1375
1376 bvec3 lessThanEqual(const vec3 u, const vec3 v)
1377 {
1378    __asm vec4_sle __retVal.xyz, u, v;
1379 }
1380
1381 bvec4 lessThanEqual(const vec4 u, const vec4 v)
1382 {
1383    __asm vec4_sle __retVal, u, v;
1384 }
1385
1386 bvec2 lessThanEqual(const ivec2 u, const ivec2 v)
1387 {
1388    __asm vec4_sle __retVal.xy, u, v;
1389 }
1390
1391 bvec3 lessThanEqual(const ivec3 u, const ivec3 v)
1392 {
1393    __asm vec4_sle __retVal.xyz, u, v;
1394 }
1395
1396 bvec4 lessThanEqual(const ivec4 u, const ivec4 v)
1397 {
1398    __asm vec4_sle __retVal, u, v;
1399 }
1400
1401
1402 //// greaterThan
1403
1404 bvec2 greaterThan(const vec2 u, const vec2 v)
1405 {
1406    __asm vec4_sgt __retVal.xy, u, v;
1407 }
1408
1409 bvec3 greaterThan(const vec3 u, const vec3 v)
1410 {
1411    __asm vec4_sgt __retVal.xyz, u, v;
1412 }
1413
1414 bvec4 greaterThan(const vec4 u, const vec4 v)
1415 {
1416    __asm vec4_sgt __retVal, u, v;
1417 }
1418
1419 bvec2 greaterThan(const ivec2 u, const ivec2 v)
1420 {
1421    __asm vec4_sgt __retVal.xy, u, v;
1422 }
1423
1424 bvec3 greaterThan(const ivec3 u, const ivec3 v)
1425 {
1426    __asm vec4_sgt __retVal.xyz, u, v;
1427 }
1428
1429 bvec4 greaterThan(const ivec4 u, const ivec4 v)
1430 {
1431    __asm vec4_sgt __retVal, u, v;
1432 }
1433
1434
1435 //// greaterThanEqual
1436
1437 bvec2 greaterThanEqual(const vec2 u, const vec2 v)
1438 {
1439    __asm vec4_sge __retVal.xy, u, v;
1440 }
1441
1442 bvec3 greaterThanEqual(const vec3 u, const vec3 v)
1443 {
1444    __asm vec4_sge __retVal.xyz, u, v;
1445 }
1446
1447 bvec4 greaterThanEqual(const vec4 u, const vec4 v)
1448 {
1449    __asm vec4_sge __retVal, u, v;
1450 }
1451
1452 bvec2 greaterThanEqual(const ivec2 u, const ivec2 v)
1453 {
1454    __asm vec4_sge __retVal.xy, u, v;
1455 }
1456
1457 bvec3 greaterThanEqual(const ivec3 u, const ivec3 v)
1458 {
1459    __asm vec4_sge __retVal.xyz, u, v;
1460 }
1461
1462 bvec4 greaterThanEqual(const ivec4 u, const ivec4 v)
1463 {
1464    __asm vec4_sge __retVal, u, v;
1465 }
1466
1467
1468 //// equal
1469
1470 bvec2 equal(const vec2 u, const vec2 v)
1471 {
1472    __asm vec4_seq __retVal.xy, u, v;
1473 }
1474
1475 bvec3 equal(const vec3 u, const vec3 v)
1476 {
1477    __asm vec4_seq __retVal.xyz, u, v;
1478 }
1479
1480 bvec4 equal(const vec4 u, const vec4 v)
1481 {
1482    __asm vec4_seq __retVal, u, v;
1483 }
1484
1485 bvec2 equal(const ivec2 u, const ivec2 v)
1486 {
1487    __asm vec4_seq __retVal.xy, u, v;
1488 }
1489
1490 bvec3 equal(const ivec3 u, const ivec3 v)
1491 {
1492    __asm vec4_seq __retVal.xyz, u, v;
1493 }
1494
1495 bvec4 equal(const ivec4 u, const ivec4 v)
1496 {
1497    __asm vec4_seq __retVal, u, v;
1498 }
1499
1500 bvec2 equal(const bvec2 u, const bvec2 v)
1501 {
1502    __asm vec4_seq __retVal.xy, u, v;
1503 }
1504
1505 bvec3 equal(const bvec3 u, const bvec3 v)
1506 {
1507    __asm vec4_seq __retVal.xyz, u, v;
1508 }
1509
1510 bvec4 equal(const bvec4 u, const bvec4 v)
1511 {
1512    __asm vec4_seq __retVal, u, v;
1513 }
1514
1515
1516
1517
1518 //// notEqual
1519
1520 bvec2 notEqual(const vec2 u, const vec2 v)
1521 {
1522    __asm vec4_sne __retVal.xy, u, v;
1523 }
1524
1525 bvec3 notEqual(const vec3 u, const vec3 v)
1526 {
1527    __asm vec4_sne __retVal.xyz, u, v;
1528 }
1529
1530 bvec4 notEqual(const vec4 u, const vec4 v)
1531 {
1532    __asm vec4_sne __retVal, u, v;
1533 }
1534
1535 bvec2 notEqual(const ivec2 u, const ivec2 v)
1536 {
1537    __asm vec4_sne __retVal.xy, u, v;
1538 }
1539
1540 bvec3 notEqual(const ivec3 u, const ivec3 v)
1541 {
1542    __asm vec4_sne __retVal.xyz, u, v;
1543 }
1544
1545 bvec4 notEqual(const ivec4 u, const ivec4 v)
1546 {
1547    __asm vec4_sne __retVal, u, v;
1548 }
1549
1550 bvec2 notEqual(const bvec2 u, const bvec2 v)
1551 {
1552    __asm vec4_sne __retVal.xy, u, v;
1553 }
1554
1555 bvec3 notEqual(const bvec3 u, const bvec3 v)
1556 {
1557    __asm vec4_sne __retVal.xyz, u, v;
1558 }
1559
1560 bvec4 notEqual(const bvec4 u, const bvec4 v)
1561 {
1562    __asm vec4_sne __retVal, u, v;
1563 }
1564
1565
1566
1567 //// any
1568
1569 bool any(const bvec2 v)
1570 {
1571    float sum;
1572    __asm vec4_add sum.x, v.x, v.y;
1573    __asm vec4_sne __retVal.x, sum.x, 0.0;
1574 }
1575
1576 bool any(const bvec3 v)
1577 {
1578    float sum;
1579    __asm vec4_add sum.x, v.x, v.y;
1580    __asm vec4_add sum.x, sum.x, v.z;
1581    __asm vec4_sne __retVal.x, sum.x, 0.0;
1582 }
1583
1584 bool any(const bvec4 v)
1585 {
1586    float sum;
1587    __asm vec4_add sum.x, v.x, v.y;
1588    __asm vec4_add sum.x, sum.x, v.z;
1589    __asm vec4_add sum.x, sum.x, v.w;
1590    __asm vec4_sne __retVal.x, sum.x, 0.0;
1591 }
1592
1593
1594 //// all
1595
1596 bool all (const bvec2 v)
1597 {
1598    float prod;
1599    __asm vec4_multiply prod.x, v.x, v.y;
1600    __asm vec4_sne __retVal.x, prod.x, 0.0;
1601     return v.x && v.y;
1602 }
1603
1604 bool all (const bvec3 v)
1605 {
1606    float prod;
1607    __asm vec4_multiply prod.x, v.x, v.y;
1608    __asm vec4_multiply prod.x, prod.x, v.z;
1609    __asm vec4_sne __retVal.x, prod.x, 0.0;
1610 }
1611
1612 bool all (const bvec4 v)
1613 {
1614    float prod;
1615    __asm vec4_multiply prod.x, v.x, v.y;
1616    __asm vec4_multiply prod.x, prod.x, v.z;
1617    __asm vec4_multiply prod.x, prod.x, v.w;
1618    __asm vec4_sne __retVal.x, prod.x, 0.0;
1619 }
1620
1621
1622
1623 //// not
1624
1625 bvec2 not (const bvec2 v)
1626 {
1627    __asm vec4_seq __retVal.xy, v, 0.0;
1628 }
1629
1630 bvec3 not (const bvec3 v)
1631 {
1632    __asm vec4_seq __retVal.xyz, v, 0.0;
1633 }
1634
1635 bvec4 not (const bvec4 v)
1636 {
1637    __asm vec4_seq __retVal, v, 0.0;
1638 }
1639
1640
1641
1642 //// Texture Lookup Functions  (for both fragment and vertex shaders)
1643
1644 vec4 texture1D(const sampler1D sampler, const float coord)
1645 {
1646    __asm vec4_tex1d __retVal, sampler, coord;
1647 }
1648
1649 vec4 texture1DProj(const sampler1D sampler, const vec2 coord)
1650 {
1651    // need to swizzle .y into .w
1652    __asm vec4_texp1d __retVal, sampler, coord.xyyy;
1653 }
1654
1655 vec4 texture1DProj(const sampler1D sampler, const vec4 coord)
1656 {
1657    __asm vec4_texp1d __retVal, sampler, coord;
1658 }
1659
1660
1661 vec4 texture2D(const sampler2D sampler, const vec2 coord)
1662 {
1663    __asm vec4_tex2d __retVal, sampler, coord;
1664 }
1665
1666 vec4 texture2DProj(const sampler2D sampler, const vec3 coord)
1667 {
1668    // need to swizzle 'z' into 'w'.
1669    __asm vec4_texp2d __retVal, sampler, coord.xyzz;
1670 }
1671
1672 vec4 texture2DProj(const sampler2D sampler, const vec4 coord)
1673 {
1674    __asm vec4_texp2d __retVal, sampler, coord;
1675 }
1676
1677
1678 vec4 texture3D(const sampler3D sampler, const vec3 coord)
1679 {
1680    __asm vec4_tex3d __retVal, sampler, coord;
1681 }
1682
1683 vec4 texture3DProj(const sampler3D sampler, const vec4 coord)
1684 {
1685    __asm vec4_texp3d __retVal, sampler, coord;
1686 }
1687
1688
1689 vec4 textureCube(const samplerCube sampler, const vec3 coord)
1690 {
1691    __asm vec4_texcube __retVal, sampler, coord;
1692 }
1693
1694
1695
1696 vec4 shadow1D(const sampler1DShadow sampler, const vec3 coord)
1697 {
1698    __asm vec4_tex1d __retVal, sampler, coord;
1699 }
1700
1701 vec4 shadow1DProj(const sampler1DShadow sampler, const vec4 coord)
1702 {
1703    // .s and .p will be divided by .q
1704    __asm vec4_texp1d __retVal, sampler, coord;
1705 }
1706
1707 vec4 shadow2D(const sampler2DShadow sampler, const vec3 coord)
1708 {
1709    __asm vec4_tex2d __retVal, sampler, coord;
1710 }
1711
1712 vec4 shadow2DProj(const sampler2DShadow sampler, const vec4 coord)
1713 {
1714    // .s, .t and .p will be divided by .q
1715    __asm vec4_texp2d __retVal, sampler, coord;
1716 }
1717
1718
1719 //// GL_ARB_texture_rectangle:
1720 vec4 texture2DRect(const sampler2DRect sampler, const vec2 coord)
1721 {
1722    __asm vec4_tex_rect __retVal, sampler, coord;
1723 }
1724
1725 vec4 texture2DRectProj(const sampler2DRect sampler, const vec3 coord)
1726 {
1727    // need to swizzle .y into .w
1728    __asm vec4_texp_rect __retVal, sampler, coord.xyzz;
1729 }
1730
1731 vec4 texture2DRectProj(const sampler2DRect sampler, const vec4 coord)
1732 {
1733    __asm vec4_texp_rect __retVal, sampler, ccoord;
1734 }
1735
1736 vec4 shadow2DRect(const sampler2DRectShadow sampler, const vec3 coord)
1737 {
1738    __asm vec4_tex_rect __retVal, sampler, coord;
1739 }
1740
1741 vec4 shadow2DRectProj(const sampler2DRectShadow sampler, const vec4 coord)
1742 {
1743    __asm vec4_texp_rect __retVal, sampler, coord;
1744 }
1745
1746
1747
1748 //
1749 // 8.9 Noise Functions
1750 //
1751 // AUTHOR: Stefan Gustavson (stegu@itn.liu.se), Nov 26, 2005
1752 //
1753
1754 float noise1(const float x)
1755 {
1756    __asm float_noise1 __retVal, x;
1757 }
1758
1759
1760 float noise1(const vec2 x)
1761 {
1762     __asm float_noise2 __retVal, x;
1763 }
1764
1765 float noise1(const vec3 x)
1766 {
1767     __asm float_noise3 __retVal, x;
1768 }
1769
1770 float noise1(const vec4 x)
1771 {
1772     __asm float_noise4 __retVal, x;
1773 }
1774
1775 vec2 noise2(const float x)
1776 {
1777    __retVal.x = noise1(x);
1778    __retVal.y = noise1(x + 19.34);
1779 }
1780
1781 vec2 noise2(const vec2 x)
1782 {
1783    __retVal.x = noise1(x);
1784    __retVal.y = noise1(x + vec2(19.34, 7.66));
1785 }
1786
1787 vec2 noise2(const vec3 x)
1788 {
1789    __retVal.x = noise1(x);
1790    __retVal.y = noise1(x + vec3(19.34, 7.66, 3.23));
1791 }
1792
1793 vec2 noise2(const vec4 x)
1794 {
1795    __retVal.x = noise1(x);
1796    __retVal.y = noise1(x + vec4(19.34, 7.66, 3.23, 2.77));
1797 }
1798
1799 vec3 noise3(const float x)
1800 {
1801    __retVal.x = noise1(x);
1802    __retVal.y = noise1(x + 19.34);
1803    __retVal.z = noise1(x + 5.47);
1804 }
1805
1806 vec3 noise3(const vec2 x)
1807 {
1808    __retVal.x = noise1(x);
1809    __retVal.y = noise1(x + vec2(19.34, 7.66));
1810    __retVal.z = noise1(x + vec2(5.47, 17.85));
1811 }
1812
1813 vec3 noise3(const vec3 x)
1814 {
1815    __retVal.x = noise1(x);
1816    __retVal.y = noise1(x + vec3(19.34, 7.66, 3.23));
1817    __retVal.z = noise1(x + vec3(5.47, 17.85, 11.04));
1818 }
1819
1820 vec3 noise3(const vec4 x)
1821 {
1822    __retVal.x = noise1(x);
1823    __retVal.y = noise1(x + vec4(19.34, 7.66, 3.23, 2.77));
1824    __retVal.z = noise1(x + vec4(5.47, 17.85, 11.04, 13.19));
1825 }
1826
1827 vec4 noise4(const float x)
1828 {
1829    __retVal.x = noise1(x);
1830    __retVal.y = noise1(x + 19.34);
1831    __retVal.z = noise1(x + 5.47);
1832    __retVal.w = noise1(x + 23.54);
1833 }
1834
1835 vec4 noise4(const vec2 x)
1836 {
1837    __retVal.x = noise1(x);
1838    __retVal.y = noise1(x + vec2 (19.34, 7.66));
1839    __retVal.z = noise1(x + vec2 (5.47, 17.85));
1840    __retVal.w = noise1(x + vec2 (23.54, 29.11));
1841 }
1842
1843 vec4 noise4(const vec3 x)
1844 {
1845    __retVal.x = noise1(x);
1846    __retVal.y = noise1(x + vec3(19.34, 7.66, 3.23));
1847    __retVal.z = noise1(x + vec3(5.47, 17.85, 11.04));
1848    __retVal.w = noise1(x + vec3(23.54, 29.11, 31.91));
1849 }
1850
1851 vec4 noise4(const vec4 x)
1852 {
1853    __retVal.x = noise1(x);
1854    __retVal.y = noise1(x + vec4(19.34, 7.66, 3.23, 2.77));
1855    __retVal.z = noise1(x + vec4(5.47, 17.85, 11.04, 13.19));
1856    __retVal.w = noise1(x + vec4(23.54, 29.11, 31.91, 37.48));
1857 }