2 * Mesa 3-D graphics library
5 * Copyright (C) 2006 Brian Paul All Rights Reserved.
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:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
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.
26 // From Shader Spec, ver. 1.10, rev. 59
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;
44 uniform mat4 gl_ModelViewMatrix;
45 uniform mat4 gl_ProjectionMatrix;
46 uniform mat4 gl_ModelViewProjectionMatrix;
47 uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];
49 uniform mat3 gl_NormalMatrix;
50 uniform mat3 __NormalMatrixTranspose; // Mesa only
52 uniform mat4 gl_ModelViewMatrixInverse;
53 uniform mat4 gl_ProjectionMatrixInverse;
54 uniform mat4 gl_ModelViewProjectionMatrixInverse;
55 uniform mat4 gl_TextureMatrixInverse[gl_MaxTextureCoords];
57 uniform mat4 gl_ModelViewMatrixTranspose;
58 uniform mat4 gl_ProjectionMatrixTranspose;
59 uniform mat4 gl_ModelViewProjectionMatrixTranspose;
60 uniform mat4 gl_TextureMatrixTranspose[gl_MaxTextureCoords];
62 uniform mat4 gl_ModelViewMatrixInverseTranspose;
63 uniform mat4 gl_ProjectionMatrixInverseTranspose;
64 uniform mat4 gl_ModelViewProjectionMatrixInverseTranspose;
65 uniform mat4 gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];
67 uniform float gl_NormalScale;
69 struct gl_DepthRangeParameters {
75 uniform gl_DepthRangeParameters gl_DepthRange;
77 uniform vec4 gl_ClipPlane[gl_MaxClipPlanes];
79 struct gl_PointParameters {
83 float fadeThresholdSize;
84 float distanceConstantAttenuation;
85 float distanceLinearAttenuation;
86 float distanceQuadraticAttenuation;
89 uniform gl_PointParameters gl_Point;
91 struct gl_MaterialParameters {
99 uniform gl_MaterialParameters gl_FrontMaterial;
100 uniform gl_MaterialParameters gl_BackMaterial;
102 struct gl_LightSourceParameters {
112 float constantAttenuation;
113 float linearAttenuation;
114 float quadraticAttenuation;
117 uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];
119 struct gl_LightModelParameters {
123 uniform gl_LightModelParameters gl_LightModel;
125 struct gl_LightModelProducts {
129 uniform gl_LightModelProducts gl_FrontLightModelProduct;
130 uniform gl_LightModelProducts gl_BackLightModelProduct;
132 struct gl_LightProducts {
138 uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];
139 uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];
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];
151 struct gl_FogParameters {
159 uniform gl_FogParameters gl_Fog;
166 // 8.1 Angle and Trigonometry Functions
171 float radians(const float deg)
173 const float c = 3.1415926 / 180.0;
174 __asm vec4_multiply __retVal.x, deg, c;
177 vec2 radians(const vec2 deg)
179 const float c = 3.1415926 / 180.0;
180 __asm vec4_multiply __retVal.xy, deg.xy, c.xx;
183 vec3 radians(const vec3 deg)
185 const float c = 3.1415926 / 180.0;
186 __asm vec4_multiply __retVal.xyz, deg.xyz, c.xxx;
189 vec4 radians(const vec4 deg)
191 const float c = 3.1415926 / 180.0;
192 __asm vec4_multiply __retVal, deg, c.xxxx;
198 float degrees(const float rad)
200 const float c = 180.0 / 3.1415926;
201 __asm vec4_multiply __retVal.x, rad, c;
204 vec2 degrees(const vec2 rad)
206 const float c = 180.0 / 3.1415926;
207 __asm vec4_multiply __retVal.xy, rad.xy, c.xx;
210 vec3 degrees(const vec3 rad)
212 const float c = 180.0 / 3.1415926;
213 __asm vec4_multiply __retVal.xyz, rad.xyz, c.xxx;
216 vec4 degrees(const vec4 rad)
218 const float c = 180.0 / 3.1415926;
219 __asm vec4_multiply __retVal, rad, c.xxxx;
225 float sin(const float radians)
227 __asm float_sine __retVal.x, radians;
230 vec2 sin(const vec2 radians)
232 __asm float_sine __retVal.x, radians.x;
233 __asm float_sine __retVal.y, radians.y;
236 vec3 sin(const vec3 radians)
238 __asm float_sine __retVal.x, radians.x;
239 __asm float_sine __retVal.y, radians.y;
240 __asm float_sine __retVal.z, radians.z;
243 vec4 sin(const vec4 radians)
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;
254 float cos(const float radians)
256 __asm float_cosine __retVal.x, radians;
259 vec2 cos(const vec2 radians)
261 __asm float_cosine __retVal.x, radians.x;
262 __asm float_cosine __retVal.y, radians.y;
265 vec3 cos(const vec3 radians)
267 __asm float_cosine __retVal.x, radians.x;
268 __asm float_cosine __retVal.y, radians.y;
269 __asm float_cosine __retVal.z, radians.z;
272 vec4 cos(const vec4 radians)
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;
284 float tan(const float angle)
286 const float s = sin(angle);
287 const float c = cos(angle);
291 vec2 tan(const vec2 angle)
293 const vec2 s = sin(angle);
294 const vec2 c = cos(angle);
298 vec3 tan(const vec3 angle)
300 const vec3 s = sin(angle);
301 const vec3 c = cos(angle);
305 vec4 tan(const vec4 angle)
307 const vec4 s = sin(angle);
308 const vec4 c = cos(angle);
314 float asin(const float x)
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);
328 vec2 asin(const vec2 v)
330 __retVal.x = asin(v.x);
331 __retVal.y = asin(v.y);
334 vec3 asin(const vec3 v)
336 __retVal.x = asin(v.x);
337 __retVal.y = asin(v.y);
338 __retVal.z = asin(v.z);
341 vec4 asin(const vec4 v)
343 __retVal.x = asin(v.x);
344 __retVal.y = asin(v.y);
345 __retVal.z = asin(v.z);
346 __retVal.w = asin(v.w);
349 float acos(const float x)
351 const float halfPi = 3.1415926 * 0.5;
352 __retVal = halfPi - asin(x);
355 vec2 acos(const vec2 v)
357 __retVal.x = acos(v.x);
358 __retVal.y = acos(v.y);
361 vec3 acos(const vec3 v)
363 __retVal.x = acos(v.x);
364 __retVal.y = acos(v.y);
365 __retVal.z = acos(v.z);
368 vec4 acos(const vec4 v)
370 __retVal.x = acos(v.x);
371 __retVal.y = acos(v.y);
372 __retVal.z = acos(v.z);
373 __retVal.w = acos(v.w);
376 float atan(const float x)
378 __retVal = asin(x * inversesqrt(x * x + 1.0));
381 vec2 atan(const vec2 y_over_x)
383 __retVal.x = atan(y_over_x.x);
384 __retVal.y = atan(y_over_x.y);
387 vec3 atan(const vec3 y_over_x)
389 __retVal.x = atan(y_over_x.x);
390 __retVal.y = atan(y_over_x.y);
391 __retVal.z = atan(y_over_x.z);
394 vec4 atan(const vec4 y_over_x)
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);
402 float atan(const float y, const float x)
405 if (abs(x) > 1.0e-4) {
408 r = r + sign(y) * 3.141593;
412 r = sign(y) * 1.5707965; // pi/2
417 vec2 atan(const vec2 u, const vec2 v)
419 __retVal.x = atan(u.x, v.x);
420 __retVal.y = atan(u.y, v.y);
423 vec3 atan(const vec3 u, const vec3 v)
425 __retVal.x = atan(u.x, v.x);
426 __retVal.y = atan(u.y, v.y);
427 __retVal.z = atan(u.z, v.z);
430 vec4 atan(const vec4 u, const vec4 v)
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);
440 // 8.2 Exponential Functions
445 float pow(const float a, const float b)
447 __asm float_power __retVal.x, a, b;
450 vec2 pow(const vec2 a, const vec2 b)
452 __asm float_power __retVal.x, a.x, b.x;
453 __asm float_power __retVal.y, a.y, b.y;
456 vec3 pow(const vec3 a, const vec3 b)
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;
463 vec4 pow(const vec4 a, const vec4 b)
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;
474 float exp(const float a)
476 const float e = 2.71828;
477 __asm float_power __retVal, e, a;
480 vec2 exp(const vec2 a)
482 const float e = 2.71828;
483 __asm float_power __retVal.x, e, a.x;
484 __asm float_power __retVal.y, e, a.y;
487 vec3 exp(const vec3 a)
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;
495 vec4 exp(const vec4 a)
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;
508 float log2(const float x)
510 __asm float_log2 __retVal.x, x;
513 vec2 log2(const vec2 v)
515 __asm float_log2 __retVal.x, v.x;
516 __asm float_log2 __retVal.y, v.y;
519 vec3 log2(const vec3 v)
521 __asm float_log2 __retVal.x, v.x;
522 __asm float_log2 __retVal.y, v.y;
523 __asm float_log2 __retVal.z, v.z;
526 vec4 log2(const vec4 v)
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;
535 //// log (natural log)
537 float log(const float x)
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;
546 vec2 log(const vec2 v)
548 const float c = 0.693147181;
552 vec3 log(const vec3 v)
554 const float c = 0.693147181;
558 vec4 log(const vec4 v)
560 const float c = 0.693147181;
567 float exp2(const float a)
569 __asm float_exp2 __retVal.x, a;
572 vec2 exp2(const vec2 a)
574 __asm float_exp2 __retVal.x, a.x;
575 __asm float_exp2 __retVal.y, a.y;
578 vec3 exp2(const vec3 a)
580 __asm float_exp2 __retVal.x, a.x;
581 __asm float_exp2 __retVal.y, a.y;
582 __asm float_exp2 __retVal.z, a.z;
585 vec4 exp2(const vec4 a)
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;
596 float sqrt(const float x)
599 __asm float_rsq r, x;
600 __asm float_rcp __retVal.x, r;
603 vec2 sqrt(const vec2 v)
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;
612 vec3 sqrt(const vec3 v)
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;
623 vec4 sqrt(const vec4 v)
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;
639 float inversesqrt(const float x)
641 __asm float_rsq __retVal.x, x;
644 vec2 inversesqrt(const vec2 v)
646 __asm float_rsq __retVal.x, v.x;
647 __asm float_rsq __retVal.y, v.y;
650 vec3 inversesqrt(const vec3 v)
652 __asm float_rsq __retVal.x, v.x;
653 __asm float_rsq __retVal.y, v.y;
654 __asm float_rsq __retVal.z, v.z;
657 vec4 inversesqrt(const vec4 v)
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;
668 float normalize(const float x)
673 vec2 normalize(const vec2 v)
675 const float s = inversesqrt(dot(v, v));
676 __asm vec4_multiply __retVal.xy, v, s.xx;
679 vec3 normalize(const vec3 v)
681 // const float s = inversesqrt(dot(v, v));
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.
687 __asm vec3_dot tmp, v, v;
688 __asm float_rsq tmp, tmp;
689 __asm vec4_multiply __retVal.xyz, v, tmp.xxx;
692 vec4 normalize(const vec4 v)
695 __asm vec4_dot tmp, v, v;
696 __asm float_rsq tmp, tmp;
697 __asm vec4_multiply __retVal.xyz, v, tmp.xxx;
703 // 8.3 Common Functions
709 float abs(const float a)
711 __asm vec4_abs __retVal.x, a;
714 vec2 abs(const vec2 a)
716 __asm vec4_abs __retVal.xy, a;
719 vec3 abs(const vec3 a)
721 __asm vec4_abs __retVal.xyz, a;
724 vec4 abs(const vec4 a)
726 __asm vec4_abs __retVal, a;
732 float sign(const float x)
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
740 vec2 sign(const vec2 v)
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;
748 vec3 sign(const vec3 v)
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;
756 vec4 sign(const vec4 v)
759 __asm vec4_sgt p, v, 0.0;
760 __asm vec4_sgt n, 0.0, v;
761 __asm vec4_subtract __retVal, p, n;
767 float floor(const float a)
769 __asm vec4_floor __retVal.x, a;
772 vec2 floor(const vec2 a)
774 __asm vec4_floor __retVal.xy, a;
777 vec3 floor(const vec3 a)
779 __asm vec4_floor __retVal.xyz, a;
782 vec4 floor(const vec4 a)
784 __asm vec4_floor __retVal, a;
790 float ceil(const float a)
792 // XXX this could be improved
794 __asm vec4_floor b, b;
798 vec2 ceil(const vec2 a)
801 __asm vec4_floor b, b;
805 vec3 ceil(const vec3 a)
808 __asm vec4_floor b, b;
812 vec4 ceil(const vec4 a)
815 __asm vec4_floor b, b;
822 float fract(const float a)
824 __asm vec4_frac __retVal.x, a;
827 vec2 fract(const vec2 a)
829 __asm vec4_frac __retVal.xy, a;
832 vec3 fract(const vec3 a)
834 __asm vec4_frac __retVal.xyz, a;
837 vec4 fract(const vec4 a)
839 __asm vec4_frac __retVal, a;
843 //// mod (very untested!)
845 float mod(const float a, const float b)
848 __asm float_rcp oneOverB, b;
849 __retVal.x = a - b * floor(a * oneOverB);
852 vec2 mod(const vec2 a, const float b)
855 __asm float_rcp oneOverB, b;
856 __retVal.xy = a - b * floor(a * oneOverB);
859 vec3 mod(const vec3 a, const float b)
862 __asm float_rcp oneOverB, b;
863 __retVal.xyz = a - b * floor(a * oneOverB);
866 vec4 mod(const vec4 a, const float b)
869 __asm float_rcp oneOverB, b;
870 __retVal = a - b * floor(a * oneOverB);
873 vec2 mod(const vec2 a, const vec2 b)
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);
882 vec3 mod(const vec3 a, const vec3 b)
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);
893 vec4 mod(const vec4 a, const vec4 b)
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);
909 float min(const float a, const float b)
911 __asm vec4_min __retVal.x, a.x, b.x;
914 vec2 min(const vec2 a, const vec2 b)
916 __asm vec4_min __retVal.xy, a.xy, b.xy;
919 vec3 min(const vec3 a, const vec3 b)
921 __asm vec4_min __retVal.xyz, a.xyz, b.xyz;
924 vec4 min(const vec4 a, const vec4 b)
926 __asm vec4_min __retVal, a, b;
929 vec2 min(const vec2 a, const float b)
931 __asm vec4_min __retVal, a.xy, b.xx;
934 vec3 min(const vec3 a, const float b)
936 __asm vec4_min __retVal, a.xyz, b.xxx;
939 vec4 min(const vec4 a, const float b)
941 __asm vec4_min __retVal, a, b.xxxx;
947 float max(const float a, const float b)
949 __asm vec4_max __retVal.x, a.x, b.x;
952 vec2 max(const vec2 a, const vec2 b)
954 __asm vec4_max __retVal.xy, a.xy, b.xy;
957 vec3 max(const vec3 a, const vec3 b)
959 __asm vec4_max __retVal.xyz, a.xyz, b.xyz;
962 vec4 max(const vec4 a, const vec4 b)
964 __asm vec4_max __retVal, a, b;
967 vec2 max(const vec2 a, const float b)
969 __asm vec4_max __retVal, a.xy, b.xx;
972 vec3 max(const vec3 a, const float b)
974 __asm vec4_max __retVal, a.xyz, b.xxx;
977 vec4 max(const vec4 a, const float b)
979 __asm vec4_max __retVal, a, b.xxxx;
985 float clamp(const float val, const float minVal, const float maxVal)
987 __asm vec4_clamp __retVal, val, minVal, maxVal;
990 vec2 clamp(const vec2 val, const float minVal, const float maxVal)
992 __asm vec4_clamp __retVal, val, minVal, maxVal;
995 vec3 clamp(const vec3 val, const float minVal, const float maxVal)
997 __asm vec4_clamp __retVal, val, minVal, maxVal;
1000 vec4 clamp(const vec4 val, const float minVal, const float maxVal)
1002 __asm vec4_clamp __retVal, val, minVal, maxVal;
1005 vec2 clamp(const vec2 val, const vec2 minVal, const vec2 maxVal)
1007 __asm vec4_clamp __retVal, val, minVal, maxVal;
1010 vec3 clamp(const vec3 val, const vec3 minVal, const vec3 maxVal)
1012 __asm vec4_clamp __retVal, val, minVal, maxVal;
1015 vec4 clamp(const vec4 val, const vec4 minVal, const vec4 maxVal)
1017 __asm vec4_clamp __retVal, val, minVal, maxVal;
1023 float mix(const float x, const float y, const float a)
1025 __asm vec4_lrp __retVal, a, y, x;
1028 vec2 mix(const vec2 x, const vec2 y, const float a)
1030 __asm vec4_lrp __retVal, a, y, x;
1033 vec3 mix(const vec3 x, const vec3 y, const float a)
1035 __asm vec4_lrp __retVal, a, y, x;
1038 vec4 mix(const vec4 x, const vec4 y, const float a)
1040 __asm vec4_lrp __retVal, a, y, x;
1043 vec2 mix(const vec2 x, const vec2 y, const vec2 a)
1045 __asm vec4_lrp __retVal, a, y, x;
1048 vec3 mix(const vec3 x, const vec3 y, const vec3 a)
1050 __asm vec4_lrp __retVal, a, y, x;
1053 vec4 mix(const vec4 x, const vec4 y, const vec4 a)
1055 __asm vec4_lrp __retVal, a, y, x;
1059 //// step (untested)
1061 float step(const float edge, const float x)
1063 __asm vec4_sgt __retVal.x, x, edge;
1066 vec2 step(const vec2 edge, const vec2 x)
1068 __asm vec4_sgt __retVal.xy, x, edge;
1071 vec3 step(const vec3 edge, const vec3 x)
1073 __asm vec4_sgt __retVal.xyz, x, edge;
1076 vec4 step(const vec4 edge, const vec4 x)
1078 __asm vec4_sgt __retVal, x, edge;
1081 vec2 step(const float edge, const vec2 v)
1083 __asm vec4_sgt __retVal.xy, v, edge.xx;
1086 vec3 step(const float edge, const vec3 v)
1088 __asm vec4_sgt __retVal.xyz, v, edge.xxx;
1091 vec4 step(const float edge, const vec4 v)
1093 __asm vec4_sgt __retVal, v, edge.xxxx;
1097 //// smoothstep (untested)
1099 float smoothstep(const float edge0, const float edge1, const float x)
1101 float t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
1102 return t * t * (3.0 - 2.0 * t);
1105 vec2 smoothstep(const vec2 edge0, const vec2 edge1, const vec2 v)
1107 vec2 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1108 return t * t * (3.0 - 2.0 * t);
1111 vec3 smoothstep(const vec3 edge0, const vec3 edge1, const vec3 v)
1113 vec3 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1114 return t * t * (3.0 - 2.0 * t);
1117 vec4 smoothstep(const vec4 edge0, const vec4 edge1, const vec4 v)
1119 vec4 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1120 return t * t * (3.0 - 2.0 * t);
1123 vec2 smoothstep(const float edge0, const float edge1, const vec2 v)
1125 vec2 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1126 return t * t * (3.0 - 2.0 * t);
1129 vec3 smoothstep(const float edge0, const float edge1, const vec3 v)
1131 vec3 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1132 return t * t * (3.0 - 2.0 * t);
1135 vec4 smoothstep(const float edge0, const float edge1, const vec4 v)
1137 vec4 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
1138 return t * t * (3.0 - 2.0 * t);
1144 // 8.4 Geometric Functions
1150 float length(const float x)
1155 float length(const vec2 v)
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
1163 float length(const vec3 v)
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
1171 float length(const vec4 v)
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
1182 float distance(const float x, const float y)
1184 const float d = x - y;
1185 __retVal = length(d);
1188 float distance(const vec2 v, const vec2 u)
1190 const vec2 d2 = v - u;
1191 __retVal = length(d2);
1194 float distance(const vec3 v, const vec3 u)
1196 const vec3 d3 = v - u;
1197 __retVal = length(d3);
1200 float distance(const vec4 v, const vec4 u)
1202 const vec4 d4 = v - u;
1203 __retVal = length(d4);
1209 vec3 cross(const vec3 v, const vec3 u)
1211 __asm vec3_cross __retVal.xyz, v, u;
1217 float faceforward(const float N, const float I, const float Nref)
1219 // this could probably be done better
1220 const float d = dot(Nref, I);
1222 __asm vec4_sgt s.x, 0.0, d; // s = (0.0 > d) ? 1 : 0
1223 return mix(-N, N, s);
1226 vec2 faceforward(const vec2 N, const vec2 I, const vec2 Nref)
1228 // this could probably be done better
1229 const float d = dot(Nref, I);
1231 __asm vec4_sgt s.x, 0.0, d; // s = (0.0 > d) ? 1 : 0
1232 return mix(-N, N, s);
1235 vec3 faceforward(const vec3 N, const vec3 I, const vec3 Nref)
1237 // this could probably be done better
1238 const float d = dot(Nref, I);
1240 __asm vec4_sgt s.x, 0.0, d; // s = (0.0 > d) ? 1 : 0
1241 return mix(-N, N, s);
1244 vec4 faceforward(const vec4 N, const vec4 I, const vec4 Nref)
1246 // this could probably be done better
1247 const float d = dot(Nref, I);
1249 __asm vec4_sgt s.x, 0.0, d; // s = (0.0 > d) ? 1 : 0
1250 return mix(-N, N, s);
1256 float reflect(const float I, const float N)
1258 return I - 2.0 * dot(N, I) * N;
1261 vec2 reflect(const vec2 I, const vec2 N)
1263 return I - 2.0 * dot(N, I) * N;
1266 vec3 reflect(const vec3 I, const vec3 N)
1268 return I - 2.0 * dot(N, I) * N;
1271 vec4 reflect(const vec4 I, const vec4 N)
1273 return I - 2.0 * dot(N, I) * N;
1278 float refract(const float I, const float N, const float eta)
1280 float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1283 return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1286 vec2 refract(const vec2 I, const vec2 N, const float eta)
1288 float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1291 return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1294 vec3 refract(const vec3 I, const vec3 N, const float eta)
1296 float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1299 return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1302 vec4 refract(const vec4 I, const vec4 N, const float eta)
1304 float k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
1307 return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
1314 // 8.5 Matrix Functions
1317 mat2 matrixCompMult (mat2 m, mat2 n) {
1318 return mat2 (m[0] * n[0], m[1] * n[1]);
1321 mat3 matrixCompMult (mat3 m, mat3 n) {
1322 return mat3 (m[0] * n[0], m[1] * n[1], m[2] * n[2]);
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]);
1333 // 8.6 Vector Relational Functions
1338 bvec2 lessThan(const vec2 u, const vec2 v)
1340 __asm vec4_slt __retVal.xy, u, v;
1343 bvec3 lessThan(const vec3 u, const vec3 v)
1345 __asm vec4_slt __retVal.xyz, u, v;
1348 bvec4 lessThan(const vec4 u, const vec4 v)
1350 __asm vec4_slt __retVal, u, v;
1353 bvec2 lessThan(const ivec2 u, const ivec2 v)
1355 __asm vec4_slt __retVal.xy, u, v;
1358 bvec3 lessThan(const ivec3 u, const ivec3 v)
1360 __asm vec4_slt __retVal.xyz, u, v;
1363 bvec4 lessThan(const ivec4 u, const ivec4 v)
1365 __asm vec4_slt __retVal, u, v;
1371 bvec2 lessThanEqual(const vec2 u, const vec2 v)
1373 __asm vec4_sle __retVal.xy, u, v;
1376 bvec3 lessThanEqual(const vec3 u, const vec3 v)
1378 __asm vec4_sle __retVal.xyz, u, v;
1381 bvec4 lessThanEqual(const vec4 u, const vec4 v)
1383 __asm vec4_sle __retVal, u, v;
1386 bvec2 lessThanEqual(const ivec2 u, const ivec2 v)
1388 __asm vec4_sle __retVal.xy, u, v;
1391 bvec3 lessThanEqual(const ivec3 u, const ivec3 v)
1393 __asm vec4_sle __retVal.xyz, u, v;
1396 bvec4 lessThanEqual(const ivec4 u, const ivec4 v)
1398 __asm vec4_sle __retVal, u, v;
1404 bvec2 greaterThan(const vec2 u, const vec2 v)
1406 __asm vec4_sgt __retVal.xy, u, v;
1409 bvec3 greaterThan(const vec3 u, const vec3 v)
1411 __asm vec4_sgt __retVal.xyz, u, v;
1414 bvec4 greaterThan(const vec4 u, const vec4 v)
1416 __asm vec4_sgt __retVal, u, v;
1419 bvec2 greaterThan(const ivec2 u, const ivec2 v)
1421 __asm vec4_sgt __retVal.xy, u, v;
1424 bvec3 greaterThan(const ivec3 u, const ivec3 v)
1426 __asm vec4_sgt __retVal.xyz, u, v;
1429 bvec4 greaterThan(const ivec4 u, const ivec4 v)
1431 __asm vec4_sgt __retVal, u, v;
1435 //// greaterThanEqual
1437 bvec2 greaterThanEqual(const vec2 u, const vec2 v)
1439 __asm vec4_sge __retVal.xy, u, v;
1442 bvec3 greaterThanEqual(const vec3 u, const vec3 v)
1444 __asm vec4_sge __retVal.xyz, u, v;
1447 bvec4 greaterThanEqual(const vec4 u, const vec4 v)
1449 __asm vec4_sge __retVal, u, v;
1452 bvec2 greaterThanEqual(const ivec2 u, const ivec2 v)
1454 __asm vec4_sge __retVal.xy, u, v;
1457 bvec3 greaterThanEqual(const ivec3 u, const ivec3 v)
1459 __asm vec4_sge __retVal.xyz, u, v;
1462 bvec4 greaterThanEqual(const ivec4 u, const ivec4 v)
1464 __asm vec4_sge __retVal, u, v;
1470 bvec2 equal(const vec2 u, const vec2 v)
1472 __asm vec4_seq __retVal.xy, u, v;
1475 bvec3 equal(const vec3 u, const vec3 v)
1477 __asm vec4_seq __retVal.xyz, u, v;
1480 bvec4 equal(const vec4 u, const vec4 v)
1482 __asm vec4_seq __retVal, u, v;
1485 bvec2 equal(const ivec2 u, const ivec2 v)
1487 __asm vec4_seq __retVal.xy, u, v;
1490 bvec3 equal(const ivec3 u, const ivec3 v)
1492 __asm vec4_seq __retVal.xyz, u, v;
1495 bvec4 equal(const ivec4 u, const ivec4 v)
1497 __asm vec4_seq __retVal, u, v;
1500 bvec2 equal(const bvec2 u, const bvec2 v)
1502 __asm vec4_seq __retVal.xy, u, v;
1505 bvec3 equal(const bvec3 u, const bvec3 v)
1507 __asm vec4_seq __retVal.xyz, u, v;
1510 bvec4 equal(const bvec4 u, const bvec4 v)
1512 __asm vec4_seq __retVal, u, v;
1520 bvec2 notEqual(const vec2 u, const vec2 v)
1522 __asm vec4_sne __retVal.xy, u, v;
1525 bvec3 notEqual(const vec3 u, const vec3 v)
1527 __asm vec4_sne __retVal.xyz, u, v;
1530 bvec4 notEqual(const vec4 u, const vec4 v)
1532 __asm vec4_sne __retVal, u, v;
1535 bvec2 notEqual(const ivec2 u, const ivec2 v)
1537 __asm vec4_sne __retVal.xy, u, v;
1540 bvec3 notEqual(const ivec3 u, const ivec3 v)
1542 __asm vec4_sne __retVal.xyz, u, v;
1545 bvec4 notEqual(const ivec4 u, const ivec4 v)
1547 __asm vec4_sne __retVal, u, v;
1550 bvec2 notEqual(const bvec2 u, const bvec2 v)
1552 __asm vec4_sne __retVal.xy, u, v;
1555 bvec3 notEqual(const bvec3 u, const bvec3 v)
1557 __asm vec4_sne __retVal.xyz, u, v;
1560 bvec4 notEqual(const bvec4 u, const bvec4 v)
1562 __asm vec4_sne __retVal, u, v;
1569 bool any(const bvec2 v)
1572 __asm vec4_add sum.x, v.x, v.y;
1573 __asm vec4_sne __retVal.x, sum.x, 0.0;
1576 bool any(const bvec3 v)
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;
1584 bool any(const bvec4 v)
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;
1596 bool all (const bvec2 v)
1599 __asm vec4_multiply prod.x, v.x, v.y;
1600 __asm vec4_sne __retVal.x, prod.x, 0.0;
1604 bool all (const bvec3 v)
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;
1612 bool all (const bvec4 v)
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;
1625 bvec2 not (const bvec2 v)
1627 __asm vec4_seq __retVal.xy, v, 0.0;
1630 bvec3 not (const bvec3 v)
1632 __asm vec4_seq __retVal.xyz, v, 0.0;
1635 bvec4 not (const bvec4 v)
1637 __asm vec4_seq __retVal, v, 0.0;
1642 //// Texture Lookup Functions (for both fragment and vertex shaders)
1644 vec4 texture1D(const sampler1D sampler, const float coord)
1646 __asm vec4_tex1d __retVal, sampler, coord;
1649 vec4 texture1DProj(const sampler1D sampler, const vec2 coord)
1651 // need to swizzle .y into .w
1652 __asm vec4_texp1d __retVal, sampler, coord.xyyy;
1655 vec4 texture1DProj(const sampler1D sampler, const vec4 coord)
1657 __asm vec4_texp1d __retVal, sampler, coord;
1661 vec4 texture2D(const sampler2D sampler, const vec2 coord)
1663 __asm vec4_tex2d __retVal, sampler, coord;
1666 vec4 texture2DProj(const sampler2D sampler, const vec3 coord)
1668 // need to swizzle 'z' into 'w'.
1669 __asm vec4_texp2d __retVal, sampler, coord.xyzz;
1672 vec4 texture2DProj(const sampler2D sampler, const vec4 coord)
1674 __asm vec4_texp2d __retVal, sampler, coord;
1678 vec4 texture3D(const sampler3D sampler, const vec3 coord)
1680 __asm vec4_tex3d __retVal, sampler, coord;
1683 vec4 texture3DProj(const sampler3D sampler, const vec4 coord)
1685 __asm vec4_texp3d __retVal, sampler, coord;
1689 vec4 textureCube(const samplerCube sampler, const vec3 coord)
1691 __asm vec4_texcube __retVal, sampler, coord;
1696 vec4 shadow1D(const sampler1DShadow sampler, const vec3 coord)
1698 __asm vec4_tex1d __retVal, sampler, coord;
1701 vec4 shadow1DProj(const sampler1DShadow sampler, const vec4 coord)
1703 // .s and .p will be divided by .q
1704 __asm vec4_texp1d __retVal, sampler, coord;
1707 vec4 shadow2D(const sampler2DShadow sampler, const vec3 coord)
1709 __asm vec4_tex2d __retVal, sampler, coord;
1712 vec4 shadow2DProj(const sampler2DShadow sampler, const vec4 coord)
1714 // .s, .t and .p will be divided by .q
1715 __asm vec4_texp2d __retVal, sampler, coord;
1719 //// GL_ARB_texture_rectangle:
1720 vec4 texture2DRect(const sampler2DRect sampler, const vec2 coord)
1722 __asm vec4_tex_rect __retVal, sampler, coord;
1725 vec4 texture2DRectProj(const sampler2DRect sampler, const vec3 coord)
1727 // need to swizzle .y into .w
1728 __asm vec4_texp_rect __retVal, sampler, coord.xyzz;
1731 vec4 texture2DRectProj(const sampler2DRect sampler, const vec4 coord)
1733 __asm vec4_texp_rect __retVal, sampler, ccoord;
1736 vec4 shadow2DRect(const sampler2DRectShadow sampler, const vec3 coord)
1738 __asm vec4_tex_rect __retVal, sampler, coord;
1741 vec4 shadow2DRectProj(const sampler2DRectShadow sampler, const vec4 coord)
1743 __asm vec4_texp_rect __retVal, sampler, coord;
1749 // 8.9 Noise Functions
1751 // AUTHOR: Stefan Gustavson (stegu@itn.liu.se), Nov 26, 2005
1754 float noise1(const float x)
1756 __asm float_noise1 __retVal, x;
1760 float noise1(const vec2 x)
1762 __asm float_noise2 __retVal, x;
1765 float noise1(const vec3 x)
1767 __asm float_noise3 __retVal, x;
1770 float noise1(const vec4 x)
1772 __asm float_noise4 __retVal, x;
1775 vec2 noise2(const float x)
1777 __retVal.x = noise1(x);
1778 __retVal.y = noise1(x + 19.34);
1781 vec2 noise2(const vec2 x)
1783 __retVal.x = noise1(x);
1784 __retVal.y = noise1(x + vec2(19.34, 7.66));
1787 vec2 noise2(const vec3 x)
1789 __retVal.x = noise1(x);
1790 __retVal.y = noise1(x + vec3(19.34, 7.66, 3.23));
1793 vec2 noise2(const vec4 x)
1795 __retVal.x = noise1(x);
1796 __retVal.y = noise1(x + vec4(19.34, 7.66, 3.23, 2.77));
1799 vec3 noise3(const float x)
1801 __retVal.x = noise1(x);
1802 __retVal.y = noise1(x + 19.34);
1803 __retVal.z = noise1(x + 5.47);
1806 vec3 noise3(const vec2 x)
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));
1813 vec3 noise3(const vec3 x)
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));
1820 vec3 noise3(const vec4 x)
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));
1827 vec4 noise4(const float x)
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);
1835 vec4 noise4(const vec2 x)
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));
1843 vec4 noise4(const vec3 x)
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));
1851 vec4 noise4(const vec4 x)
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));