-
-//
-// TODO:
-// - implement texture1D, texture2D, texture3D, textureCube,
-// - implement shadow1D, shadow2D,
-//
+/*
+ * Mesa 3-D graphics library
+ * Version: 7.3
+ *
+ * Copyright (C) 2006 Brian Paul All Rights Reserved.
+ * Copyright (C) 2008 VMware, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
//
// From Shader Spec, ver. 1.10, rev. 59
//
+//bp: XXX these will probably go away since the value needs to be
+//determined at runtime and may vary from one GLcontext to another...
const int gl_MaxLights = 8;
const int gl_MaxClipPlanes = 6;
const int gl_MaxTextureUnits = 8;
uniform gl_MaterialParameters gl_FrontMaterial;
uniform gl_MaterialParameters gl_BackMaterial;
+/* NOTE: the order of these fields is significant!
+ * See the definition of the lighting state vars such as STATE_SPOT_DIRECTION.
+ */
struct gl_LightSourceParameters {
vec4 ambient;
vec4 diffuse;
vec4 position;
vec4 halfVector;
vec3 spotDirection;
- float spotExponent;
- float spotCutoff;
float spotCosCutoff;
+
float constantAttenuation;
float linearAttenuation;
float quadraticAttenuation;
+ float spotExponent;
+
+ float spotCutoff;
};
uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];
uniform gl_FogParameters gl_Fog;
+
+
+
+
//
// 8.1 Angle and Trigonometry Functions
//
-float radians (float deg) {
- return 3.141593 * deg / 180.0;
-}\r
-
-vec2 radians (vec2 deg) {
- return vec2 (3.141593) * deg / vec2 (180.0);
-}\r
-
-vec3 radians (vec3 deg) {
- return vec3 (3.141593) * deg / vec3 (180.0);
-}\r
-
-vec4 radians (vec4 deg) {
- return vec4 (3.141593) * deg / vec4 (180.0);
-}
-
-float degrees (float rad) {
- return 180.0 * rad / 3.141593;
-}\r
-
-vec2 degrees (vec2 rad) {
- return vec2 (180.0) * rad / vec2 (3.141593);
-}\r
-
-vec3 degrees (vec3 rad) {
- return vec3 (180.0) * rad / vec3 (3.141593);
-}\r
-
-vec4 degrees (vec4 rad) {
- return vec4 (180.0) * rad / vec4 (3.141593);
-}
-
-float sin (float angle) {\r
- float x;\r
- __asm float_sine x, angle;
- return x;
-}\r
-
-vec2 sin (vec2 angle) {
- vec2 u;\r
- u.x = sin (angle.x);\r
- u.y = sin (angle.y);\r
- return u;\r
-}\r
-
-vec3 sin (vec3 angle) {
- vec3 u;\r
- u.x = sin (angle.x);\r
- u.y = sin (angle.y);\r
- u.z = sin (angle.z);\r
- return u;
-}\r
-
-vec4 sin (vec4 angle) {
- vec4 u;\r
- u.x = sin (angle.x);\r
- u.y = sin (angle.y);\r
- u.z = sin (angle.z);\r
- u.w = sin (angle.w);\r
- return u;
-}
-
-float cos (float angle) {
- return sin (angle + 1.5708);
-}\r
-
-vec2 cos (vec2 angle) {
- vec2 u;\r
- u.x = cos (angle.x);\r
- u.y = cos (angle.y);\r
- return u;
-}\r
-
-vec3 cos (vec3 angle) {
- vec3 u;\r
- u.x = cos (angle.x);\r
- u.y = cos (angle.y);\r
- u.z = cos (angle.z);\r
- return u;
-}\r
-
-vec4 cos (vec4 angle) {
- vec4 u;\r
- u.x = cos (angle.x);\r
- u.y = cos (angle.y);\r
- u.z = cos (angle.z);\r
- u.w = cos (angle.w);\r
- return u;
-}
-
-float tan (float angle) {
- return sin (angle) / cos (angle);
-}\r
-
-vec2 tan (vec2 angle) {
- vec2 u;\r
- u.x = tan (angle.x);\r
- u.y = tan (angle.y);\r
- return u;
-}\r
-
-vec3 tan (vec3 angle) {
- vec3 u;\r
- u.x = tan (angle.x);\r
- u.y = tan (angle.y);\r
- u.z = tan (angle.z);\r
- return u;
-}\r
-
-vec4 tan (vec4 angle) {
- vec4 u;\r
- u.x = tan (angle.x);\r
- u.y = tan (angle.y);\r
- u.z = tan (angle.z);\r
- u.w = tan (angle.w);\r
- return u;
-}
-
-float asin (float x) {
- float y;\r
- __asm float_arcsine y, x;\r
- return y;
-}\r
-
-vec2 asin (vec2 v) {
- vec2 u;\r
- u.x = asin (v.x);\r
- u.y = asin (v.y);\r
- return u;
-}\r
-
-vec3 asin (vec3 v) {
- vec3 u;\r
- u.x = asin (v.x);\r
- u.y = asin (v.y);\r
- u.z = asin (v.z);\r
- return u;
-}\r
-
-vec4 asin (vec4 v) {
- vec4 u;\r
- u.x = asin (v.x);\r
- u.y = asin (v.y);\r
- u.z = asin (v.z);\r
- u.w = asin (v.w);\r
- return u;
-}
-
-float acos (float x) {
- return 1.5708 - asin (x);
-}\r
-
-vec2 acos (vec2 v) {
- vec2 u;\r
- u.x = acos (v.x);\r
- u.y = acos (v.y);\r
- return u;
-}\r
-
-vec3 acos (vec3 v) {
- vec3 u;\r
- u.x = acos (v.x);\r
- u.y = acos (v.y);\r
- u.z = acos (v.z);\r
- return u;
-}\r
-
-vec4 acos (vec4 v) {
- vec4 u;\r
- u.x = acos (v.x);\r
- u.y = acos (v.y);\r
- u.z = acos (v.z);\r
- u.w = acos (v.w);\r
- return u;
-}
-
-float atan (float y_over_x) {\r
- float z;\r
- __asm float_arctan z, y_over_x;\r
- return z;\r
-}\r
-\r
-vec2 atan (vec2 y_over_x) {\r
- vec2 u;\r
- u.x = atan (y_over_x.x);\r
- u.y = atan (y_over_x.y);\r
- return u;\r
-}\r
-\r
-vec3 atan (vec3 y_over_x) {\r
- vec3 u;\r
- u.x = atan (y_over_x.x);\r
- u.y = atan (y_over_x.y);\r
- u.z = atan (y_over_x.z);\r
- return u;\r
-}\r
-\r
-vec4 atan (vec4 y_over_x) {\r
- vec4 u;\r
- u.x = atan (y_over_x.x);\r
- u.y = atan (y_over_x.y);\r
- u.z = atan (y_over_x.z);\r
- u.w = atan (y_over_x.w);\r
- return u;\r
-}\r
-\r
-float atan (float y, float x) {\r
- float z;\r
- z = atan (y / x);
- if (x < 0.0)\r
- {\r
- if (y < 0.0)\r
- return z - 3.141593;\r
- return z + 3.141593;\r
- }\r
- return z;
-}\r
-
-vec2 atan (vec2 u, vec2 v) {
- vec2 t;\r
- t.x = atan (u.x, v.x);\r
- t.y = atan (u.y, v.y);\r
- return t;
-}\r
-
-vec3 atan (vec3 u, vec3 v) {
- vec3 t;\r
- t.x = atan (u.x, v.x);\r
- t.y = atan (u.y, v.y);\r
- t.z = atan (u.z, v.z);\r
- return t;
-}\r
-
-vec4 atan (vec4 u, vec4 v) {
- vec4 t;\r
- t.x = atan (u.x, v.x);\r
- t.y = atan (u.y, v.y);\r
- t.z = atan (u.z, v.z);\r
- t.w = atan (u.w, v.w);\r
- return t;
+//// radians
+
+float radians(const float deg)
+{
+ const float c = 3.1415926 / 180.0;
+ __asm vec4_multiply __retVal, deg, c;
+}
+
+vec2 radians(const vec2 deg)
+{
+ const float c = 3.1415926 / 180.0;
+ __asm vec4_multiply __retVal.xy, deg.xy, c.xx;
+}
+
+vec3 radians(const vec3 deg)
+{
+ const float c = 3.1415926 / 180.0;
+ __asm vec4_multiply __retVal.xyz, deg.xyz, c.xxx;
+}
+
+vec4 radians(const vec4 deg)
+{
+ const float c = 3.1415926 / 180.0;
+ __asm vec4_multiply __retVal, deg, c.xxxx;
+}
+
+
+//// degrees
+
+float degrees(const float rad)
+{
+ const float c = 180.0 / 3.1415926;
+ __asm vec4_multiply __retVal, rad, c;
+}
+
+vec2 degrees(const vec2 rad)
+{
+ const float c = 180.0 / 3.1415926;
+ __asm vec4_multiply __retVal.xy, rad.xy, c.xx;
+}
+
+vec3 degrees(const vec3 rad)
+{
+ const float c = 180.0 / 3.1415926;
+ __asm vec4_multiply __retVal.xyz, rad.xyz, c.xxx;
+}
+
+vec4 degrees(const vec4 rad)
+{
+ const float c = 180.0 / 3.1415926;
+ __asm vec4_multiply __retVal, rad, c.xxxx;
+}
+
+
+//// sin
+
+float sin(const float radians)
+{
+ __asm float_sine __retVal, radians;
+}
+
+vec2 sin(const vec2 radians)
+{
+ __asm float_sine __retVal.x, radians.x;
+ __asm float_sine __retVal.y, radians.y;
+}
+
+vec3 sin(const vec3 radians)
+{
+ __asm float_sine __retVal.x, radians.x;
+ __asm float_sine __retVal.y, radians.y;
+ __asm float_sine __retVal.z, radians.z;
+}
+
+vec4 sin(const vec4 radians)
+{
+ __asm float_sine __retVal.x, radians.x;
+ __asm float_sine __retVal.y, radians.y;
+ __asm float_sine __retVal.z, radians.z;
+ __asm float_sine __retVal.w, radians.w;
+}
+
+
+//// cos
+
+float cos(const float radians)
+{
+ __asm float_cosine __retVal, radians;
+}
+
+vec2 cos(const vec2 radians)
+{
+ __asm float_cosine __retVal.x, radians.x;
+ __asm float_cosine __retVal.y, radians.y;
+}
+
+vec3 cos(const vec3 radians)
+{
+ __asm float_cosine __retVal.x, radians.x;
+ __asm float_cosine __retVal.y, radians.y;
+ __asm float_cosine __retVal.z, radians.z;
+}
+
+vec4 cos(const vec4 radians)
+{
+ __asm float_cosine __retVal.x, radians.x;
+ __asm float_cosine __retVal.y, radians.y;
+ __asm float_cosine __retVal.z, radians.z;
+ __asm float_cosine __retVal.w, radians.w;
+}
+
+
+
+//// tan
+
+float tan(const float angle)
+{
+ const float s = sin(angle);
+ const float c = cos(angle);
+ return s / c;
+}
+
+vec2 tan(const vec2 angle)
+{
+ const vec2 s = sin(angle);
+ const vec2 c = cos(angle);
+ return s / c;
+}
+
+vec3 tan(const vec3 angle)
+{
+ const vec3 s = sin(angle);
+ const vec3 c = cos(angle);
+ return s / c;
+}
+
+vec4 tan(const vec4 angle)
+{
+ const vec4 s = sin(angle);
+ const vec4 c = cos(angle);
+ return s / c;
+}
+
+
+
+float asin(const float x)
+{
+ const float a0 = 1.5707288; // PI/2?
+ const float a1 = -0.2121144;
+ const float a2 = 0.0742610;
+ //const float a3 = -0.0187293;
+ const float halfPi = 3.1415926 * 0.5;
+ const float y = abs(x);
+ // three terms seem to be enough:
+ __retVal = (halfPi - sqrt(1.0 - y) * (a0 + y * (a1 + a2 * y))) * sign(x);
+ // otherwise, try four:
+ //__retVal = (halfPi - sqrt(1.0 - y) * (a0 + y * (a1 + y * (a2 + y * a3)))) * sign(x);
+}
+
+vec2 asin(const vec2 v)
+{
+ __retVal.x = asin(v.x);
+ __retVal.y = asin(v.y);
+}
+
+vec3 asin(const vec3 v)
+{
+ __retVal.x = asin(v.x);
+ __retVal.y = asin(v.y);
+ __retVal.z = asin(v.z);
+}
+
+vec4 asin(const vec4 v)
+{
+ __retVal.x = asin(v.x);
+ __retVal.y = asin(v.y);
+ __retVal.z = asin(v.z);
+ __retVal.w = asin(v.w);
+}
+
+float acos(const float x)
+{
+ const float halfPi = 3.1415926 * 0.5;
+ __retVal = halfPi - asin(x);
+}
+
+vec2 acos(const vec2 v)
+{
+ __retVal.x = acos(v.x);
+ __retVal.y = acos(v.y);
+}
+
+vec3 acos(const vec3 v)
+{
+ __retVal.x = acos(v.x);
+ __retVal.y = acos(v.y);
+ __retVal.z = acos(v.z);
+}
+
+vec4 acos(const vec4 v)
+{
+ __retVal.x = acos(v.x);
+ __retVal.y = acos(v.y);
+ __retVal.z = acos(v.z);
+ __retVal.w = acos(v.w);
+}
+
+float atan(const float x)
+{
+ __retVal = asin(x * inversesqrt(x * x + 1.0));
+}
+
+vec2 atan(const vec2 y_over_x)
+{
+ __retVal.x = atan(y_over_x.x);
+ __retVal.y = atan(y_over_x.y);
+}
+
+vec3 atan(const vec3 y_over_x)
+{
+ __retVal.x = atan(y_over_x.x);
+ __retVal.y = atan(y_over_x.y);
+ __retVal.z = atan(y_over_x.z);
+}
+
+vec4 atan(const vec4 y_over_x)
+{
+ __retVal.x = atan(y_over_x.x);
+ __retVal.y = atan(y_over_x.y);
+ __retVal.z = atan(y_over_x.z);
+ __retVal.w = atan(y_over_x.w);
+}
+
+float atan(const float y, const float x)
+{
+ float r;
+ if (abs(x) > 1.0e-4) {
+ r = atan(y / x);
+ if (x < 0.0) {
+ r = r + sign(y) * 3.141593;
+ }
+ }
+ else {
+ r = sign(y) * 1.5707965; // pi/2
+ }
+ return r;
+}
+
+vec2 atan(const vec2 u, const vec2 v)
+{
+ __retVal.x = atan(u.x, v.x);
+ __retVal.y = atan(u.y, v.y);
+}
+
+vec3 atan(const vec3 u, const vec3 v)
+{
+ __retVal.x = atan(u.x, v.x);
+ __retVal.y = atan(u.y, v.y);
+ __retVal.z = atan(u.z, v.z);
+}
+
+vec4 atan(const vec4 u, const vec4 v)
+{
+ __retVal.x = atan(u.x, v.x);
+ __retVal.y = atan(u.y, v.y);
+ __retVal.z = atan(u.z, v.z);
+ __retVal.w = atan(u.w, v.w);
}
+
//
// 8.2 Exponential Functions
//
-float pow (float x, float y) {\r
- float p;\r
- __asm float_power p, x, y;
- return p;
-}\r
-
-vec2 pow (vec2 v, vec2 u) {
- vec2 t;\r
- t.x = pow (v.x, u.x);\r
- t.y = pow (v.y, u.y);\r
- return t;
-}\r
-
-vec3 pow (vec3 v, vec3 u) {
- vec3 t;\r
- t.x = pow (v.x, u.x);\r
- t.y = pow (v.y, u.y);\r
- t.z = pow (v.z, u.z);\r
- return t;
-}\r
-
-vec4 pow (vec4 v, vec4 u) {
- vec4 t;\r
- t.x = pow (v.x, u.x);\r
- t.y = pow (v.y, u.y);\r
- t.z = pow (v.z, u.z);\r
- t.w = pow (v.w, u.w);\r
- return t;
-}
-
-float exp (float x) {
- return pow (2.71828183, x);
-}\r
-
-vec2 exp (vec2 v) {
- return pow (vec2 (2.71828183), v);
-}\r
-
-vec3 exp (vec3 v) {
- return pow (vec3 (2.71828183), v);
-}\r
-
-vec4 exp (vec4 v) {
- return pow (vec4 (2.71828183), v);
-}
-
-float log2 (float x) {\r
- float y;\r
- __asm float_log2 y, x;\r
- return y;\r
-}\r
-\r
-vec2 log2 (vec2 v) {\r
- vec2 u;\r
- u.x = log2 (v.x);\r
- u.y = log2 (v.y);\r
- return u;\r
-}\r
-\r
-vec3 log2 (vec3 v) {\r
- vec3 u;\r
- u.x = log2 (v.x);\r
- u.y = log2 (v.y);\r
- u.z = log2 (v.z);\r
- return u;\r
-}\r
-\r
-vec4 log2 (vec4 v) {\r
- vec4 u;\r
- u.x = log2 (v.x);\r
- u.y = log2 (v.y);\r
- u.z = log2 (v.z);\r
- u.w = log2 (v.w);\r
- return u;\r
-}\r
-\r
-float log (float x) {
- return log2 (x) / log2 (2.71828183);
-}\r
-
-vec2 log (vec2 v) {
- return log2 (v) / log2 (vec2 (2.71828183));
-}\r
-
-vec3 log (vec3 v) {
- return log2 (v) / log2 (vec3 (2.71828183));
-}\r
-
-vec4 log (vec4 v) {
- return log2 (v) / log2 (vec4 (2.71828183));
-}
-
-float exp2 (float x) {
- return pow (2.0, x);
-}\r
-
-vec2 exp2 (vec2 v) {
- return pow (vec2 (2.0), v);
-}\r
-
-vec3 exp2 (vec3 v) {
- return pow (vec3 (2.0), v);
-}\r
-
-vec4 exp2 (vec4 v) {
- return pow (vec4 (2.0), v);
-}
-
-float sqrt (float x) {
- return pow (x, 0.5);
-}\r
-
-vec2 sqrt (vec2 v) {
- return pow (v, vec2 (0.5));
-}\r
-
-vec3 sqrt (vec3 v) {
- return pow (v, vec3 (0.5));
-}\r
-
-vec4 sqrt (vec4 v) {
- return pow (v, vec4 (0.5));
-}
-
-float inversesqrt (float x) {
- return 1.0 / sqrt (x);
-}\r
-
-vec2 inversesqrt (vec2 v) {
- return vec2 (1.0) / sqrt (v);
-}\r
-
-vec3 inversesqrt (vec3 v) {
- return vec3 (1.0) / sqrt (v);
-}\r
-
-vec4 inversesqrt (vec4 v) {
- return vec4 (1.0) / sqrt (v);
+//// pow
+
+float pow(const float a, const float b)
+{
+ __asm float_power __retVal, a, b;
+}
+
+vec2 pow(const vec2 a, const vec2 b)
+{
+ __asm float_power __retVal.x, a.x, b.x;
+ __asm float_power __retVal.y, a.y, b.y;
+}
+
+vec3 pow(const vec3 a, const vec3 b)
+{
+ __asm float_power __retVal.x, a.x, b.x;
+ __asm float_power __retVal.y, a.y, b.y;
+ __asm float_power __retVal.z, a.z, b.z;
+}
+
+vec4 pow(const vec4 a, const vec4 b)
+{
+ __asm float_power __retVal.x, a.x, b.x;
+ __asm float_power __retVal.y, a.y, b.y;
+ __asm float_power __retVal.z, a.z, b.z;
+ __asm float_power __retVal.w, a.w, b.w;
+}
+
+
+//// exp
+
+float exp(const float a)
+{
+ // NOTE: log2(e) = 1.44269502
+ float t = a * 1.44269502;
+ __asm float_exp2 __retVal, t;
+}
+
+vec2 exp(const vec2 a)
+{
+ vec2 t = a * 1.44269502;
+ __asm float_exp2 __retVal.x, t.x;
+ __asm float_exp2 __retVal.y, t.y;
+}
+
+vec3 exp(const vec3 a)
+{
+ vec3 t = a * 1.44269502;
+ __asm float_exp2 __retVal.x, t.x;
+ __asm float_exp2 __retVal.y, t.y;
+ __asm float_exp2 __retVal.z, t.z;
+}
+
+vec4 exp(const vec4 a)
+{
+ vec4 t = a * 1.44269502;
+ __asm float_exp2 __retVal.x, t.x;
+ __asm float_exp2 __retVal.y, t.y;
+ __asm float_exp2 __retVal.z, t.z;
+ __asm float_exp2 __retVal.w, t.w;
+}
+
+
+
+//// log2
+
+float log2(const float x)
+{
+ __asm float_log2 __retVal, x;
+}
+
+vec2 log2(const vec2 v)
+{
+ __asm float_log2 __retVal.x, v.x;
+ __asm float_log2 __retVal.y, v.y;
+}
+
+vec3 log2(const vec3 v)
+{
+ __asm float_log2 __retVal.x, v.x;
+ __asm float_log2 __retVal.y, v.y;
+ __asm float_log2 __retVal.z, v.z;
+}
+
+vec4 log2(const vec4 v)
+{
+ __asm float_log2 __retVal.x, v.x;
+ __asm float_log2 __retVal.y, v.y;
+ __asm float_log2 __retVal.z, v.z;
+ __asm float_log2 __retVal.w, v.w;
+}
+
+
+//// log (natural log)
+
+float log(const float x)
+{
+ // note: logBaseB(x) = logBaseN(x) / logBaseN(B)
+ // compute log(x) = log2(x) / log2(e)
+ // c = 1.0 / log2(e) = 0.693147181
+ const float c = 0.693147181;
+ return log2(x) * c;
}
+vec2 log(const vec2 v)
+{
+ const float c = 0.693147181;
+ return log2(v) * c;
+}
+
+vec3 log(const vec3 v)
+{
+ const float c = 0.693147181;
+ return log2(v) * c;
+}
+
+vec4 log(const vec4 v)
+{
+ const float c = 0.693147181;
+ return log2(v) * c;
+}
+
+
+//// exp2
+
+float exp2(const float a)
+{
+ __asm float_exp2 __retVal, a;
+}
+
+vec2 exp2(const vec2 a)
+{
+ __asm float_exp2 __retVal.x, a.x;
+ __asm float_exp2 __retVal.y, a.y;
+}
+
+vec3 exp2(const vec3 a)
+{
+ __asm float_exp2 __retVal.x, a.x;
+ __asm float_exp2 __retVal.y, a.y;
+ __asm float_exp2 __retVal.z, a.z;
+}
+
+vec4 exp2(const vec4 a)
+{
+ __asm float_exp2 __retVal.x, a.x;
+ __asm float_exp2 __retVal.y, a.y;
+ __asm float_exp2 __retVal.z, a.z;
+ __asm float_exp2 __retVal.w, a.w;
+}
+
+
+//// sqrt
+
+float sqrt(const float x)
+{
+ float r;
+ __asm float_rsq r, x;
+ __asm float_rcp __retVal, r;
+}
+
+vec2 sqrt(const vec2 v)
+{
+ float r;
+ __asm float_rsq r, v.x;
+ __asm float_rcp __retVal.x, r;
+ __asm float_rsq r, v.y;
+ __asm float_rcp __retVal.y, r;
+}
+
+vec3 sqrt(const vec3 v)
+{
+ float r;
+ __asm float_rsq r, v.x;
+ __asm float_rcp __retVal.x, r;
+ __asm float_rsq r, v.y;
+ __asm float_rcp __retVal.y, r;
+ __asm float_rsq r, v.z;
+ __asm float_rcp __retVal.z, r;
+}
+
+vec4 sqrt(const vec4 v)
+{
+ float r;
+ __asm float_rsq r, v.x;
+ __asm float_rcp __retVal.x, r;
+ __asm float_rsq r, v.y;
+ __asm float_rcp __retVal.y, r;
+ __asm float_rsq r, v.z;
+ __asm float_rcp __retVal.z, r;
+ __asm float_rsq r, v.w;
+ __asm float_rcp __retVal.w, r;
+}
+
+
+//// inversesqrt
+
+float inversesqrt(const float x)
+{
+ __asm float_rsq __retVal.x, x;
+}
+
+vec2 inversesqrt(const vec2 v)
+{
+ __asm float_rsq __retVal.x, v.x;
+ __asm float_rsq __retVal.y, v.y;
+}
+
+vec3 inversesqrt(const vec3 v)
+{
+ __asm float_rsq __retVal.x, v.x;
+ __asm float_rsq __retVal.y, v.y;
+ __asm float_rsq __retVal.z, v.z;
+}
+
+vec4 inversesqrt(const vec4 v)
+{
+ __asm float_rsq __retVal.x, v.x;
+ __asm float_rsq __retVal.y, v.y;
+ __asm float_rsq __retVal.z, v.z;
+ __asm float_rsq __retVal.w, v.w;
+}
+
+
+//// normalize
+
+float normalize(const float x)
+{
+ __retVal = 1.0;
+}
+
+vec2 normalize(const vec2 v)
+{
+ const float s = inversesqrt(dot(v, v));
+ __asm vec4_multiply __retVal.xy, v, s;
+}
+
+vec3 normalize(const vec3 v)
+{
+// const float s = inversesqrt(dot(v, v));
+// __retVal = v * s;
+// XXX note, we _could_ use __retVal.w instead of tmp and and save a
+// register, but that's actually a compilation error because v is a vec3
+// and the .w suffix is illegal. Oh well.
+ float tmp;
+ __asm vec3_dot tmp, v, v;
+ __asm float_rsq tmp, tmp;
+ __asm vec4_multiply __retVal.xyz, v, tmp;
+}
+
+vec4 normalize(const vec4 v)
+{
+ float tmp;
+ __asm vec4_dot tmp, v, v;
+ __asm float_rsq tmp, tmp;
+ __asm vec4_multiply __retVal.xyz, v, tmp;
+}
+
+
+
//
// 8.3 Common Functions
//
-float abs (float x) {
- return x >= 0.0 ? x : -x;
-}\r
-
-vec2 abs (vec2 v) {\r
- vec2 u;\r
- u.x = abs (v.x);\r
- u.y = abs (v.y);
- return u;
-}\r
-
-vec3 abs (vec3 v) {
- vec3 u;\r
- u.x = abs (v.x);\r
- u.y = abs (v.y);\r
- u.z = abs (v.z);\r
- return u;
-}\r
-
-vec4 abs (vec4 v) {
- vec4 u;\r
- u.x = abs (v.x);\r
- u.y = abs (v.y);\r
- u.z = abs (v.z);\r
- u.w = abs (v.w);\r
- return u;
-}
-
-float sign (float x) {
- return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : 0.0;
-}\r
-
-vec2 sign (vec2 v) {
- vec2 u;\r
- u.x = sign (v.x);\r
- u.y = sign (v.y);\r
- return u;
-}\r
-
-vec3 sign (vec3 v) {
- vec3 u;\r
- u.x = sign (v.x);\r
- u.y = sign (v.y);\r
- u.z = sign (v.z);\r
- return u;
-}\r
-
-vec4 sign (vec4 v) {
- vec4 u;\r
- u.x = sign (v.x);\r
- u.y = sign (v.y);\r
- u.z = sign (v.z);\r
- u.w = sign (v.w);\r
- return u;
-}
-
-float floor (float x) {\r
- float y;\r
- __asm float_floor y, x;\r
- return y;\r
-}\r
-\r
-vec2 floor (vec2 v) {\r
- vec2 u;\r
- u.x = floor (v.x);\r
- u.y = floor (v.y);\r
- return u;\r
-}\r
-\r
-vec3 floor (vec3 v) {\r
- vec3 u;\r
- u.x = floor (v.x);\r
- u.y = floor (v.y);\r
- u.z = floor (v.z);\r
- return u;\r
-}\r
-\r
-vec4 floor (vec4 v) {\r
- vec4 u;\r
- u.x = floor (v.x);\r
- u.y = floor (v.y);\r
- u.z = floor (v.z);\r
- u.w = floor (v.w);\r
- return u;\r
-}\r
-\r
-float ceil (float x) {\r
- float y;\r
- __asm float_ceil y, x;\r
- return y;\r
-}\r
-\r
-vec2 ceil (vec2 v) {\r
- vec2 u;\r
- u.x = ceil (v.x);\r
- u.y = ceil (v.y);\r
- return u;\r
-}\r
-\r
-vec3 ceil (vec3 v) {\r
- vec3 u;\r
- u.x = ceil (v.x);\r
- u.y = ceil (v.y);\r
- u.z = ceil (v.z);\r
- return u;\r
-}\r
-\r
-vec4 ceil (vec4 v) {\r
- vec4 u;\r
- u.x = ceil (v.x);\r
- u.y = ceil (v.y);\r
- u.z = ceil (v.z);\r
- u.w = ceil (v.w);\r
- return u;\r
-}
-\r
-float fract (float x) {\r
- return x - floor (x);\r
-}\r
-\r
-vec2 fract (vec2 v) {\r
- return v - floor (v);\r
-}\r
-\r
-vec3 fract (vec3 v) {\r
- return v - floor (v);\r
-}\r
-\r
-vec4 fract (vec4 v) {\r
- return v - floor (v);\r
-}\r
-
-float mod (float x, float y) {
- return x - y * floor (x / y);
-}\r
-
-vec2 mod (vec2 v, float u) {
- return v - u * floor (v / u);
-}\r
-
-vec3 mod (vec3 v, float u) {
- return v - u * floor (v / u);
-}\r
-
-vec4 mod (vec4 v, float u) {
- return v - u * floor (v / u);
-}\r
-
-vec2 mod (vec2 v, vec2 u) {
- return v - u * floor (v / u);
-}\r
-
-vec3 mod (vec3 v, vec3 u) {
- return v - u * floor (v / u);
-}\r
-
-vec4 mod (vec4 v, vec4 u) {
- return v - u * floor (v / u);
-}
-
-float min (float x, float y) {
- return x < y ? x : y;
-}\r
-
-vec2 min (vec2 v, vec2 u) {\r
- vec2 t;\r
- t.x = min (v.x, u.x);\r
- t.y = min (v.y, u.y);\r
- return t;\r
-}\r
-\r
-vec3 min (vec3 v, vec3 u) {\r
- vec3 t;\r
- t.x = min (v.x, u.x);\r
- t.y = min (v.y, u.y);\r
- t.z = min (v.z, u.z);\r
- return t;\r
-}\r
-\r
-vec4 min (vec4 v, vec4 u) {\r
- vec4 t;\r
- t.x = min (v.x, u.x);\r
- t.y = min (v.y, u.y);\r
- t.z = min (v.z, u.z);\r
- t.w = min (v.w, u.w);\r
- return t;\r
-}\r
-\r
-vec2 min (vec2 v, float y) {
- return min (v, vec2 (y));
-}\r
-
-vec3 min (vec3 v, float y) {
- return min (v, vec3 (y));
-}\r
-
-vec4 min (vec4 v, float y) {
- return min (v, vec4 (y));
-}\r
-
-float max (float x, float y) {
- return x < y ? y : x;
-}\r
-
-vec2 max (vec2 v, vec2 u) {\r
- vec2 t;\r
- t.x = max (v.x, u.x);\r
- t.y = max (v.y, u.y);\r
- return t;\r
-}\r
-\r
-vec3 max (vec3 v, vec3 u) {\r
- vec3 t;\r
- t.x = max (v.x, u.x);\r
- t.y = max (v.y, u.y);\r
- t.z = max (v.z, u.z);\r
- return t;\r
-}\r
-\r
-vec4 max (vec4 v, vec4 u) {\r
- vec4 t;\r
- t.x = max (v.x, u.x);\r
- t.y = max (v.y, u.y);\r
- t.z = max (v.z, u.z);\r
- t.w = max (v.w, u.w);\r
- return t;\r
-}\r
-\r
-vec2 max (vec2 v, float y) {
- return max (v, vec2 (y));
-}\r
-
-vec3 max (vec3 v, float y) {
- return max (v, vec3 (y));
-}\r
-
-vec4 max (vec4 v, float y) {
- return max (v, vec4 (y));
-}\r
-
-float clamp (float x, float minVal, float maxVal) {
- return min (max (x, minVal), maxVal);
-}\r
-
-vec2 clamp (vec2 x, float minVal, float maxVal) {
- return min (max (x, minVal), maxVal);
-}\r
-
-vec3 clamp (vec3 x, float minVal, float maxVal) {
- return min (max (x, minVal), maxVal);
-}\r
-
-vec4 clamp (vec4 x, float minVal, float maxVal) {
- return min (max (x, minVal), maxVal);
-}\r
-
-vec2 clamp (vec2 x, vec2 minVal, vec2 maxVal) {
- return min (max (x, minVal), maxVal);
-}\r
-
-vec3 clamp (vec3 x, vec3 minVal, vec3 maxVal) {
- return min (max (x, minVal), maxVal);
-}\r
-
-vec4 clamp (vec4 x, vec4 minVal, vec4 maxVal) {
- return min (max (x, minVal), maxVal);
-}
-
-float mix (float x, float y, float a) {
- return x * (1.0 - a) + y * a;
-}\r
-
-vec2 mix (vec2 x, vec2 y, float a) {
- return x * (1.0 - a) + y * a;
-}\r
-
-vec3 mix (vec3 x, vec3 y, float a) {
- return x * (1.0 - a) + y * a;
-}\r
-
-vec4 mix (vec4 x, vec4 y, float a) {
- return x * (1.0 - a) + y * a;
-}\r
-
-vec2 mix (vec2 x, vec2 y, vec2 a) {
- return x * (1.0 - a) + y * a;
-}\r
-
-vec3 mix (vec3 x, vec3 y, vec3 a) {
- return x * (1.0 - a) + y * a;
-}\r
-
-vec4 mix (vec4 x, vec4 y, vec4 a) {
- return x * (1.0 - a) + y * a;
-}
-
-float step (float edge, float x) {
- return x < edge ? 0.0 : 1.0;
-}\r
-
-vec2 step (vec2 edge, vec2 v) {\r
- vec2 u;\r
- u.x = step (edge.x, v.x);\r
- u.y = step (edge.y, v.y);\r
- return u;\r
-}\r
-\r
-vec3 step (vec3 edge, vec3 v) {\r
- vec3 u;\r
- u.x = step (edge.x, v.x);\r
- u.y = step (edge.y, v.y);\r
- u.z = step (edge.z, v.z);\r
- return u;\r
-}\r
-\r
-vec4 step (vec4 edge, vec4 v) {\r
- vec4 u;\r
- u.x = step (edge.x, v.x);\r
- u.y = step (edge.y, v.y);\r
- u.z = step (edge.z, v.z);\r
- u.w = step (edge.w, v.w);\r
- return u;\r
-}\r
-\r
-vec2 step (float edge, vec2 v) {
- return step (vec2 (edge), v);
-}
-\r
-vec3 step (float edge, vec3 v) {
- return step (vec3 (edge), v);
-}\r
-
-vec4 step (float edge, vec4 v) {
- return step (vec4 (edge), v);
-}\r
-
-float smoothstep (float edge0, float edge1, float x) {
- float t;\r
- t = clamp ((x - edge0) / (edge1 - edge0), 0.0, 1.0);
- return t * t * (3.0 - 2.0 * t);
-}\r
-
-vec2 smoothstep (vec2 edge0, vec2 edge1, vec2 v) {\r
- vec2 u;\r
- u.x = smoothstep (edge0.x, edge1.x, v.x);\r
- u.y = smoothstep (edge0.y, edge1.y, v.y);\r
- return u;\r
-}\r
-\r
-vec3 smoothstep (vec3 edge0, vec3 edge1, vec3 v) {\r
- vec3 u;\r
- u.x = smoothstep (edge0.x, edge1.x, v.x);\r
- u.y = smoothstep (edge0.y, edge1.y, v.y);\r
- u.z = smoothstep (edge0.z, edge1.z, v.z);\r
- return u;\r
-}\r
-\r
-vec4 smoothstep (vec4 edge0, vec4 edge1, vec4 v) {\r
- vec4 u;\r
- u.x = smoothstep (edge0.x, edge1.x, v.x);\r
- u.y = smoothstep (edge0.y, edge1.y, v.y);\r
- u.z = smoothstep (edge0.z, edge1.z, v.z);\r
- u.w = smoothstep (edge0.w, edge1.w, v.w);\r
- return u;\r
-}\r
-\r
-vec2 smoothstep (float edge0, float edge1, vec2 v) {
- vec2 u;\r
- u.x = smoothstep (edge0, edge1, v.x);\r
- u.y = smoothstep (edge0, edge1, v.y);\r
- return u;
-}\r
-
-vec3 smoothstep (float edge0, float edge1, vec3 v) {
- vec3 u;\r
- u.x = smoothstep (edge0, edge1, v.x);\r
- u.y = smoothstep (edge0, edge1, v.y);\r
- u.z = smoothstep (edge0, edge1, v.z);\r
- return u;
-}\r
-
-vec4 smoothstep (float edge0, float edge1, vec4 v) {
- vec4 u;\r
- u.x = smoothstep (edge0, edge1, v.x);\r
- u.y = smoothstep (edge0, edge1, v.y);\r
- u.z = smoothstep (edge0, edge1, v.z);\r
- u.w = smoothstep (edge0, edge1, v.w);\r
- return u;
-}\r
-//
-// 8.4 Geometric Functions
-//
+//// abs
+
+float abs(const float a)
+{
+ __asm vec4_abs __retVal, a;
+}
+
+vec2 abs(const vec2 a)
+{
+ __asm vec4_abs __retVal.xy, a;
+}
+
+vec3 abs(const vec3 a)
+{
+ __asm vec4_abs __retVal.xyz, a;
+}
+
+vec4 abs(const vec4 a)
+{
+ __asm vec4_abs __retVal, a;
+}
+
+
+//// sign
+
+float sign(const float x)
+{
+ float p, n;
+ __asm vec4_sgt p, x, 0.0; // p = (x > 0)
+ __asm vec4_sgt n, 0.0, x; // n = (x < 0)
+ __asm vec4_subtract __retVal, p, n; // sign = p - n
+}
-float dot (float x, float y) {
- return x * y;
-}\r
+vec2 sign(const vec2 v)
+{
+ vec2 p, n;
+ __asm vec4_sgt p.xy, v, 0.0;
+ __asm vec4_sgt n.xy, 0.0, v;
+ __asm vec4_subtract __retVal.xy, p, n;
+}
+
+vec3 sign(const vec3 v)
+{
+ vec3 p, n;
+ __asm vec4_sgt p.xyz, v, 0.0;
+ __asm vec4_sgt n.xyz, 0.0, v;
+ __asm vec4_subtract __retVal.xyz, p, n;
+}
+
+vec4 sign(const vec4 v)
+{
+ vec4 p, n;
+ __asm vec4_sgt p, v, 0.0;
+ __asm vec4_sgt n, 0.0, v;
+ __asm vec4_subtract __retVal, p, n;
+}
+
+
+//// floor
+
+float floor(const float a)
+{
+ __asm vec4_floor __retVal, a;
+}
-float dot (vec2 v, vec2 u) {
- return v.x * u.x + v.y * u.y;
-}\r
+vec2 floor(const vec2 a)
+{
+ __asm vec4_floor __retVal.xy, a;
+}
-float dot (vec3 v, vec3 u) {
- return v.x * u.x + v.y * u.y + v.z * u.z;
-}\r
+vec3 floor(const vec3 a)
+{
+ __asm vec4_floor __retVal.xyz, a;
+}
-float dot (vec4 v, vec4 u) {
- return v.x * u.x + v.y * u.y + v.z * u.z + v.w * u.w;
+vec4 floor(const vec4 a)
+{
+ __asm vec4_floor __retVal, a;
}
-float length (float x) {
- return sqrt (dot (x, x));
-}\r
-float length (vec2 v) {
- return sqrt (dot (v, v));
-}\r
+//// ceil
+
+float ceil(const float a)
+{
+ // XXX this could be improved
+ float b = -a;
+ __asm vec4_floor b, b;
+ __retVal = -b;
+}
+
+vec2 ceil(const vec2 a)
+{
+ vec2 b = -a;
+ __asm vec4_floor b, b;
+ __retVal.xy = -b;
+}
-float length (vec3 v) {
- return sqrt (dot (v, v));
-}\r
+vec3 ceil(const vec3 a)
+{
+ vec3 b = -a;
+ __asm vec4_floor b, b;
+ __retVal.xyz = -b;
+}
-float length (vec4 v) {
- return sqrt (dot (v, v));
+vec4 ceil(const vec4 a)
+{
+ vec4 b = -a;
+ __asm vec4_floor b, b;
+ __retVal = -b;
}
-float distance (float x, float y) {
- return length (x - y);
-}\r
-float distance (vec2 v, vec2 u) {
- return length (v - u);
-}\r
+//// fract
-float distance (vec3 v, vec3 u) {
- return length (v - u);
-}\r
+float fract(const float a)
+{
+ __asm vec4_frac __retVal, a;
+}
+
+vec2 fract(const vec2 a)
+{
+ __asm vec4_frac __retVal.xy, a;
+}
-float distance (vec4 v, vec4 u) {
- return length (v - u);
+vec3 fract(const vec3 a)
+{
+ __asm vec4_frac __retVal.xyz, a;
}
-vec3 cross (vec3 v, vec3 u) {
- vec3 t;\r
- t.x = v.y * u.z - u.y * v.z;\r
- t.y = v.z * u.x - u.z * v.x;\r
- t.z = v.x * u.y - u.x * v.y;\r
- return t;
+vec4 fract(const vec4 a)
+{
+ __asm vec4_frac __retVal, a;
}
-float normalize (float x) {
- return 1.0;
-}\r
-vec2 normalize (vec2 v) {
- return v / length (v);
-}\r
+//// mod (very untested!)
-vec3 normalize (vec3 v) {
- return v / length (v);
-}\r
+float mod(const float a, const float b)
+{
+ float oneOverB;
+ __asm float_rcp oneOverB, b;
+ __retVal = a - b * floor(a * oneOverB);
+}
-vec4 normalize (vec4 v) {
- return v / length (v);
+vec2 mod(const vec2 a, const float b)
+{
+ float oneOverB;
+ __asm float_rcp oneOverB, b;
+ __retVal.xy = a - b * floor(a * oneOverB);
}
-float faceforward (float N, float I, float Nref) {
- return dot (Nref, I) < 0.0 ? N : -N;
-}\r
+vec3 mod(const vec3 a, const float b)
+{
+ float oneOverB;
+ __asm float_rcp oneOverB, b;
+ __retVal.xyz = a - b * floor(a * oneOverB);
+}
-vec2 faceforward (vec2 N, vec2 I, vec2 Nref) {
- return dot (Nref, I) < 0.0 ? N : -N;
-}\r
+vec4 mod(const vec4 a, const float b)
+{
+ float oneOverB;
+ __asm float_rcp oneOverB, b;
+ __retVal = a - b * floor(a * oneOverB);
+}
-vec3 faceforward (vec3 N, vec3 I, vec3 Nref) {
- return dot (Nref, I) < 0.0 ? N : -N;
-}\r
+vec2 mod(const vec2 a, const vec2 b)
+{
+ vec2 oneOverB;
+ __asm float_rcp oneOverB.x, b.x;
+ __asm float_rcp oneOverB.y, b.y;
+ __retVal = a - b * floor(a * oneOverB);
+}
-vec4 faceforward (vec4 N, vec4 I, vec4 Nref) {
- return dot (Nref, I) < 0.0 ? N : -N;
+vec3 mod(const vec3 a, const vec3 b)
+{
+ vec3 oneOverB;
+ __asm float_rcp oneOverB.x, b.x;
+ __asm float_rcp oneOverB.y, b.y;
+ __asm float_rcp oneOverB.z, b.z;
+ __retVal = a - b * floor(a * oneOverB);
}
-float reflect (float I, float N) {
- return I - 2.0 * dot (N, I) * N;
-}\r
+vec4 mod(const vec4 a, const vec4 b)
+{
+ vec4 oneOverB;
+ __asm float_rcp oneOverB.x, b.x;
+ __asm float_rcp oneOverB.y, b.y;
+ __asm float_rcp oneOverB.z, b.z;
+ __asm float_rcp oneOverB.w, b.w;
+ __retVal = a - b * floor(a * oneOverB);
+}
-vec2 reflect (vec2 I, vec2 N) {
- return I - 2.0 * dot (N, I) * N;
-}\r
-vec3 reflect (vec3 I, vec3 N) {
- return I - 2.0 * dot (N, I) * N;
-}\r
+//// min
-vec4 reflect (vec4 I, vec4 N) {
- return I - 2.0 * dot (N, I) * N;
+float min(const float a, const float b)
+{
+ __asm vec4_min __retVal, a, b;
}
-float refract (float I, float N, float eta) {
- float k;\r
- k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
- if (k < 0.0)
- return 0.0;
- return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
-}\r
+vec2 min(const vec2 a, const vec2 b)
+{
+ __asm vec4_min __retVal.xy, a.xy, b.xy;
+}
-vec2 refract (vec2 I, vec2 N, float eta) {
- float k;\r
- k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));\r
- if (k < 0.0)\r
- return 0.0;\r
- return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
-}\r
+vec3 min(const vec3 a, const vec3 b)
+{
+ __asm vec4_min __retVal.xyz, a.xyz, b.xyz;
+}
-vec3 refract (vec3 I, vec3 N, float eta) {
- float k;\r
- k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));\r
- if (k < 0.0)\r
- return 0.0;\r
- return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
-}\r
+vec4 min(const vec4 a, const vec4 b)
+{
+ __asm vec4_min __retVal, a, b;
+}
-vec4 refract (vec4 I, vec4 N, float eta) {
- float k;\r
- k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));\r
- if (k < 0.0)\r
- return 0.0;\r
- return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
+vec2 min(const vec2 a, const float b)
+{
+ __asm vec4_min __retVal, a.xy, b;
}
-//
-// 8.5 Matrix Functions
-//
+vec3 min(const vec3 a, const float b)
+{
+ __asm vec4_min __retVal, a.xyz, b;
+}
-mat2 matrixCompMult (mat2 m, mat2 n) {
- mat2 o;
- o[0] = m[0] * n[0];\r
- o[1] = m[1] * n[1];
- return o;
-}\r
+vec4 min(const vec4 a, const float b)
+{
+ __asm vec4_min __retVal, a, b;
+}
-mat3 matrixCompMult (mat3 m, mat3 n) {
- mat3 o;
- o[0] = m[0] * n[0];\r
- o[1] = m[1] * n[1];\r
- o[2] = m[2] * n[2];
- return o;
-}\r
-mat4 matrixCompMult (mat4 m, mat4 n) {
- mat4 o;
- o[0] = m[0] * n[0];\r
- o[1] = m[1] * n[1];\r
- o[2] = m[2] * n[2];\r
- o[3] = m[3] * n[3];
- return o;
+//// max
+
+float max(const float a, const float b)
+{
+ __asm vec4_max __retVal, a, b;
}
-//
-// 8.6 Vector Relational Functions
-//
+vec2 max(const vec2 a, const vec2 b)
+{
+ __asm vec4_max __retVal.xy, a.xy, b.xy;
+}
-bvec2 lessThan (vec2 v, vec2 u) {\r
- bvec2 b;\r
- b.x = v.x < u.x;\r
- b.y = v.y < u.y;\r
- return b;
-}\r
-
-bvec3 lessThan (vec3 v, vec3 u) {
- bvec3 b;\r
- b.x = v.x < u.x;\r
- b.y = v.y < u.y;\r
- b.z = v.z < u.z;\r
- return b;
-}\r
-
-bvec4 lessThan (vec4 v, vec4 u) {
- bvec4 b;\r
- b.x = v.x < u.x;\r
- b.y = v.y < u.y;\r
- b.z = v.z < u.z;\r
- b.w = v.w < u.w;\r
- return b;
-}\r
-
-bvec2 lessThan (ivec2 v, ivec2 u) {
- bvec2 b;\r
- b.x = v.x < u.x;\r
- b.y = v.y < u.y;\r
- return b;
-}\r
-
-bvec3 lessThan (ivec3 v, ivec3 u) {
- bvec3 b;\r
- b.x = v.x < u.x;\r
- b.y = v.y < u.y;\r
- b.z = v.z < u.z;\r
- return b;
-}\r
-
-bvec4 lessThan (ivec4 v, ivec4 u) {
- bvec4 b;\r
- b.x = v.x < u.x;\r
- b.y = v.y < u.y;\r
- b.z = v.z < u.z;\r
- b.w = v.w < u.w;\r
- return b;
-}
-
-bvec2 lessThanEqual (vec2 v, vec2 u) {
- bvec2 b;\r
- b.x = v.x <= u.x;\r
- b.y = v.y <= u.y;\r
- return b;
-}\r
-
-bvec3 lessThanEqual (vec3 v, vec3 u) {
- bvec3 b;\r
- b.x = v.x <= u.x;\r
- b.y = v.y <= u.y;\r
- b.z = v.z <= u.z;\r
- return b;
-}\r
-
-bvec4 lessThanEqual (vec4 v, vec4 u) {
- bvec4 b;\r
- b.x = v.x <= u.x;\r
- b.y = v.y <= u.y;\r
- b.z = v.z <= u.z;\r
- b.w = v.w <= u.w;\r
- return b;
-}\r
-
-bvec2 lessThanEqual (ivec2 v, ivec2 u) {
- bvec2 b;\r
- b.x = v.x <= u.x;\r
- b.y = v.y <= u.y;\r
- return b;
-}\r
-
-bvec3 lessThanEqual (ivec3 v, ivec3 u) {
- bvec3 b;\r
- b.x = v.x <= u.x;\r
- b.y = v.y <= u.y;\r
- b.z = v.z <= u.z;\r
- return b;
-}\r
-
-bvec4 lessThanEqual (ivec4 v, ivec4 u) {
- bvec4 b;\r
- b.x = v.x <= u.x;\r
- b.y = v.y <= u.y;\r
- b.z = v.z <= u.z;\r
- b.w = v.w <= u.w;\r
- return b;
-}
-
-bvec2 greaterThan (vec2 v, vec2 u) {
- bvec2 b;\r
- b.x = v.x > u.x;\r
- b.y = v.y > u.y;\r
- return b;
-}\r
-
-bvec3 greaterThan (vec3 v, vec3 u) {
- bvec3 b;\r
- b.x = v.x > u.x;\r
- b.y = v.y > u.y;\r
- b.z = v.z > u.z;\r
- return b;
-}\r
-
-bvec4 greaterThan (vec4 v, vec4 u) {
- bvec4 b;\r
- b.x = v.x > u.x;\r
- b.y = v.y > u.y;\r
- b.z = v.z > u.z;\r
- b.w = v.w > u.w;\r
- return b;
-}\r
-
-bvec2 greaterThan (ivec2 v, ivec2 u) {
- bvec2 b;\r
- b.x = v.x > u.x;\r
- b.y = v.y > u.y;\r
- return b;
-}\r
-
-bvec3 greaterThan (ivec3 v, ivec3 u) {
- bvec3 b;\r
- b.x = v.x > u.x;\r
- b.y = v.y > u.y;\r
- b.z = v.z > u.z;\r
- return b;
-}\r
-
-bvec4 greaterThan (ivec4 v, ivec4 u) {
- bvec4 b;\r
- b.x = v.x > u.x;\r
- b.y = v.y > u.y;\r
- b.z = v.z > u.z;\r
- b.w = v.w > u.w;\r
- return b;
-}
-
-bvec2 greaterThanEqual (vec2 v, vec2 u) {
- bvec2 b;\r
- b.x = v.x >= u.x;\r
- b.y = v.y >= u.y;\r
- return b;
-}\r
-
-bvec3 greaterThanEqual (vec3 v, vec3 u) {
- bvec3 b;\r
- b.x = v.x >= u.x;\r
- b.y = v.y >= u.y;\r
- b.z = v.z >= u.z;\r
- return b;
-}\r
-
-bvec4 greaterThanEqual (vec4 v, vec4 u) {
- bvec4 b;\r
- b.x = v.x >= u.x;\r
- b.y = v.y >= u.y;\r
- b.z = v.z >= u.z;\r
- b.w = v.w >= u.w;\r
- return b;
-}\r
-
-bvec2 greaterThanEqual (ivec2 v, ivec2 u) {
- bvec2 b;\r
- b.x = v.x >= u.x;\r
- b.y = v.y >= u.y;\r
- return b;
-}\r
-
-bvec3 greaterThanEqual (ivec3 v, ivec3 u) {
- bvec3 b;\r
- b.x = v.x >= u.x;\r
- b.y = v.y >= u.y;\r
- b.z = v.z >= u.z;\r
- return b;
-}\r
-
-bvec4 greaterThanEqual (ivec4 v, ivec4 u) {
- bvec4 b;\r
- b.x = v.x >= u.x;\r
- b.y = v.y >= u.y;\r
- b.z = v.z >= u.z;\r
- b.w = v.w >= u.w;\r
- return b;
-}
-
-bvec2 equal (vec2 v, vec2 u) {
- bvec2 b;\r
- b.x = v.x == u.x;\r
- b.y = v.y == u.y;\r
- return b;
-}\r
-
-bvec3 equal (vec3 v, vec3 u) {
- bvec3 b;\r
- b.x = v.x == u.x;\r
- b.y = v.y == u.y;\r
- b.z = v.z == u.z;\r
- return b;
-}\r
-
-bvec4 equal (vec4 v, vec4 u) {
- bvec4 b;\r
- b.x = v.x == u.x;\r
- b.y = v.y == u.y;\r
- b.z = v.z == u.z;\r
- b.w = v.w == u.w;\r
- return b;
-}\r
-
-bvec2 equal (ivec2 v, ivec2 u) {
- bvec2 b;\r
- b.x = v.x == u.x;\r
- b.y = v.y == u.y;\r
- return b;
-}\r
-
-bvec3 equal (ivec3 v, ivec3 u) {
- bvec3 b;\r
- b.x = v.x == u.x;\r
- b.y = v.y == u.y;\r
- b.z = v.z == u.z;\r
- return b;
-}\r
-
-bvec4 equal (ivec4 v, ivec4 u) {
- bvec4 b;\r
- b.x = v.x == u.x;\r
- b.y = v.y == u.y;\r
- b.z = v.z == u.z;\r
- b.w = v.w == u.w;\r
- return b;
-}
-
-bvec2 notEqual (vec2 v, vec2 u) {
- bvec2 b;\r
- b.x = v.x != u.x;\r
- b.y = v.y != u.y;\r
- return b;
-}\r
-
-bvec3 notEqual (vec3 v, vec3 u) {
- bvec3 b;\r
- b.x = v.x != u.x;\r
- b.y = v.y != u.y;\r
- b.z = v.z != u.z;\r
- return b;
-}\r
-
-bvec4 notEqual (vec4 v, vec4 u) {
- bvec4 b;\r
- b.x = v.x != u.x;\r
- b.y = v.y != u.y;\r
- b.z = v.z != u.z;\r
- b.w = v.w != u.w;\r
- return b;
-}\r
-
-bvec2 notEqual (ivec2 v, ivec2 u) {
- bvec2 b;\r
- b.x = v.x != u.x;\r
- b.y = v.y != u.y;\r
- return b;
-}\r
-
-bvec3 notEqual (ivec3 v, ivec3 u) {
- bvec3 b;\r
- b.x = v.x != u.x;\r
- b.y = v.y != u.y;\r
- b.z = v.z != u.z;\r
- return b;
-}\r
-
-bvec4 notEqual (ivec4 v, ivec4 u) {
- bvec4 b;\r
- b.x = v.x != u.x;\r
- b.y = v.y != u.y;\r
- b.z = v.z != u.z;\r
- b.w = v.w != u.w;\r
- return b;
-}
-
-bool any (bvec2 v) {
- return v.x || v.y;
-}\r
-
-bool any (bvec3 v) {
- return v.x || v.y || v.z;
-}\r
-
-bool any (bvec4 v) {
- return v.x || v.y || v.z || v.w;
-}
-
-bool all (bvec2 v) {
- return v.x && v.y;
-}\r
-
-bool all (bvec3 v) {
- return v.x && v.y && v.z;
-}\r
-
-bool all (bvec4 v) {
- return v.x && v.y && v.z && v.w;
-}
-
-bvec2 not (bvec2 v) {\r
- bvec2 u;\r
- u.x = !v.x;\r
- u.y = !v.y;
- return u;
-}\r
-
-bvec3 not (bvec3 v) {
- bvec3 u;\r
- u.x = !v.x;\r
- u.y = !v.y;\r
- u.z = !v.z;\r
- return u;
-}\r
-
-bvec4 not (bvec4 v) {
- bvec4 u;\r
- u.x = !v.x;\r
- u.y = !v.y;\r
- u.z = !v.z;\r
- u.w = !v.w;\r
- return u;
+vec3 max(const vec3 a, const vec3 b)
+{
+ __asm vec4_max __retVal.xyz, a.xyz, b.xyz;
+}
+
+vec4 max(const vec4 a, const vec4 b)
+{
+ __asm vec4_max __retVal, a, b;
+}
+
+vec2 max(const vec2 a, const float b)
+{
+ __asm vec4_max __retVal, a.xy, b;
+}
+
+vec3 max(const vec3 a, const float b)
+{
+ __asm vec4_max __retVal, a.xyz, b;
+}
+
+vec4 max(const vec4 a, const float b)
+{
+ __asm vec4_max __retVal, a, b;
}
-//
-// 8.7 Texture Lookup Functions
-//
-vec4 texture1D (sampler1D sampler, float coord) {\r
- // XXX:
- return vec4 (0.0);
-}\r
+//// clamp
-vec4 texture1DProj (sampler1D sampler, vec2 coord) {
- return texture1D (sampler, coord.s / coord.t);
-}\r
+float clamp(const float val, const float minVal, const float maxVal)
+{
+ __asm vec4_clamp __retVal, val, minVal, maxVal;
+}
-vec4 texture1DProj (sampler1D sampler, vec4 coord) {
- return texture1D (sampler, coord.s / coord.q);
+vec2 clamp(const vec2 val, const float minVal, const float maxVal)
+{
+ __asm vec4_clamp __retVal, val, minVal, maxVal;
}
-vec4 texture2D (sampler2D sampler, vec2 coord) {\r
- // XXX:
- return vec4 (0.0);
-}\r
+vec3 clamp(const vec3 val, const float minVal, const float maxVal)
+{
+ __asm vec4_clamp __retVal, val, minVal, maxVal;
+}
-vec4 texture2DProj (sampler2D sampler, vec3 coord) {\r
- vec2 u;\r
- u.s = coord.s / coord.p;\r
- u.t = coord.t / coord.p;
- return texture2D (sampler, u);
-}\r
+vec4 clamp(const vec4 val, const float minVal, const float maxVal)
+{
+ __asm vec4_clamp __retVal, val, minVal, maxVal;
+}
-vec4 texture2DProj (sampler2D sampler, vec4 coord) {\r
- vec2 u;\r
- u.s = coord.s / coord.q;\r
- u.t = coord.t / coord.q;
- return texture2D (sampler, u);
+vec2 clamp(const vec2 val, const vec2 minVal, const vec2 maxVal)
+{
+ __asm vec4_clamp __retVal, val, minVal, maxVal;
}
-vec4 texture3D (sampler3D sampler, vec3 coord) {\r
- // XXX:
- return vec4 (0.0);
-}\r
+vec3 clamp(const vec3 val, const vec3 minVal, const vec3 maxVal)
+{
+ __asm vec4_clamp __retVal, val, minVal, maxVal;
+}
-vec4 texture3DProj (sampler3D sampler, vec4 coord) {\r
- vec3 u;\r
- u.s = coord.s / coord.q;\r
- u.t = coord.t / coord.q;\r
- u.p = coord.p / coord.q;
- return texture3D (sampler, u);
+vec4 clamp(const vec4 val, const vec4 minVal, const vec4 maxVal)
+{
+ __asm vec4_clamp __retVal, val, minVal, maxVal;
}
-vec4 textureCube (samplerCube sampler, vec3 coord) {\r
- // XXX:
- return vec4 (0.0);
+
+//// mix
+
+float mix(const float x, const float y, const float a)
+{
+ __asm vec4_lrp __retVal, a, y, x;
}
-vec4 shadow1D (sampler1DShadow sampler, vec3 coord) {\r
- // XXX:
- return vec4 (0.0);
+vec2 mix(const vec2 x, const vec2 y, const float a)
+{
+ __asm vec4_lrp __retVal, a, y, x;
}
-vec4 shadow2D (sampler2DShadow sampler, vec3 coord) {\r
- // XXX:
- return vec4 (0.0);
-}\r
+vec3 mix(const vec3 x, const vec3 y, const float a)
+{
+ __asm vec4_lrp __retVal, a, y, x;
+}
-vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord) {\r
- vec3 u;\r
- u.s = coord.s / coord.q;\r
- u.t = 0.0;\r
- u.p = coord.p / coord.q;
- return shadow1D (sampler, u);
-}\r
+vec4 mix(const vec4 x, const vec4 y, const float a)
+{
+ __asm vec4_lrp __retVal, a, y, x;
+}
-vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord) {\r
- vec3 u;\r
- u.s = coord.s / coord.q;\r
- u.t = coord.t / coord.q;\r
- u.p = coord.p / coord.q;
- return shadow2D (sampler, u);
+vec2 mix(const vec2 x, const vec2 y, const vec2 a)
+{
+ __asm vec4_lrp __retVal, a, y, x;
}
-//
-// 8.9 Noise Functions\r
-//\r
-// AUTHOR: Stefan Gustavson (stegu@itn.liu.se), Nov 26, 2005
-//
+vec3 mix(const vec3 x, const vec3 y, const vec3 a)
+{
+ __asm vec4_lrp __retVal, a, y, x;
+}
-float noise1 (float x) {\r
- float a;\r
- __asm float_noise1 a, x;\r
- return a;
+vec4 mix(const vec4 x, const vec4 y, const vec4 a)
+{
+ __asm vec4_lrp __retVal, a, y, x;
}
-float noise1 (vec2 x) {\r
- float a;\r
- __asm float_noise2 a, x;\r
- return a;
+
+//// step
+
+float step(const float edge, const float x)
+{
+ __asm vec4_sge __retVal, x, edge;
+}
+
+vec2 step(const vec2 edge, const vec2 x)
+{
+ __asm vec4_sge __retVal.xy, x, edge;
+}
+
+vec3 step(const vec3 edge, const vec3 x)
+{
+ __asm vec4_sge __retVal.xyz, x, edge;
+}
+
+vec4 step(const vec4 edge, const vec4 x)
+{
+ __asm vec4_sge __retVal, x, edge;
+}
+
+vec2 step(const float edge, const vec2 v)
+{
+ __asm vec4_sge __retVal.xy, v, edge;
+}
+
+vec3 step(const float edge, const vec3 v)
+{
+ __asm vec4_sge __retVal.xyz, v, edge;
+}
+
+vec4 step(const float edge, const vec4 v)
+{
+ __asm vec4_sge __retVal, v, edge;
+}
+
+
+//// smoothstep
+
+float smoothstep(const float edge0, const float edge1, const float x)
+{
+ float t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+ return t * t * (3.0 - 2.0 * t);
+}
+
+vec2 smoothstep(const vec2 edge0, const vec2 edge1, const vec2 v)
+{
+ vec2 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
+ return t * t * (3.0 - 2.0 * t);
+}
+
+vec3 smoothstep(const vec3 edge0, const vec3 edge1, const vec3 v)
+{
+ vec3 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
+ return t * t * (3.0 - 2.0 * t);
+}
+
+vec4 smoothstep(const vec4 edge0, const vec4 edge1, const vec4 v)
+{
+ vec4 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
+ return t * t * (3.0 - 2.0 * t);
+}
+
+vec2 smoothstep(const float edge0, const float edge1, const vec2 v)
+{
+ vec2 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
+ return t * t * (3.0 - 2.0 * t);
+}
+
+vec3 smoothstep(const float edge0, const float edge1, const vec3 v)
+{
+ vec3 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
+ return t * t * (3.0 - 2.0 * t);
+}
+
+vec4 smoothstep(const float edge0, const float edge1, const vec4 v)
+{
+ vec4 t = clamp((v - edge0) / (edge1 - edge0), 0.0, 1.0);
+ return t * t * (3.0 - 2.0 * t);
+}
+
+
+
+//
+// 8.4 Geometric Functions
+//
+
+
+//// length
+
+float length(const float x)
+{
+ return abs(x);
+}
+
+float length(const vec2 v)
+{
+ float r;
+ const float p = dot(v, v); // p = v.x * v.x + v.y * v.y
+ __asm float_rsq r, p; // r = 1 / sqrt(p)
+ __asm float_rcp __retVal.x, r; // retVal = 1 / r
+}
+
+float length(const vec3 v)
+{
+ float r;
+ const float p = dot(v, v); // p = v.x * v.x + v.y * v.y + v.z * v.z
+ __asm float_rsq r, p; // r = 1 / sqrt(p)
+ __asm float_rcp __retVal, r; // retVal = 1 / r
+}
+
+float length(const vec4 v)
+{
+ float r;
+ const float p = dot(v, v); // p = v.x * v.x + v.y * v.y + ...
+ __asm float_rsq r, p; // r = 1 / sqrt(p)
+ __asm float_rcp __retVal, r; // retVal = 1 / r
+}
+
+
+//// distance
+
+float distance(const float x, const float y)
+{
+ const float d = x - y;
+ __retVal = length(d);
+}
+
+float distance(const vec2 v, const vec2 u)
+{
+ const vec2 d2 = v - u;
+ __retVal = length(d2);
+}
+
+float distance(const vec3 v, const vec3 u)
+{
+ const vec3 d3 = v - u;
+ __retVal = length(d3);
+}
+
+float distance(const vec4 v, const vec4 u)
+{
+ const vec4 d4 = v - u;
+ __retVal = length(d4);
+}
+
+
+//// cross
+
+vec3 cross(const vec3 v, const vec3 u)
+{
+ __asm vec3_cross __retVal.xyz, v, u;
+}
+
+
+//// faceforward
+
+float faceforward(const float N, const float I, const float Nref)
+{
+ // this could probably be done better
+ const float d = dot(Nref, I);
+ float s;
+ __asm vec4_sgt s, 0.0, d; // s = (0.0 > d) ? 1 : 0
+ return mix(-N, N, s);
+}
+
+vec2 faceforward(const vec2 N, const vec2 I, const vec2 Nref)
+{
+ // this could probably be done better
+ const float d = dot(Nref, I);
+ float s;
+ __asm vec4_sgt s, 0.0, d; // s = (0.0 > d) ? 1 : 0
+ return mix(-N, N, s);
+}
+
+vec3 faceforward(const vec3 N, const vec3 I, const vec3 Nref)
+{
+ // this could probably be done better
+ const float d = dot(Nref, I);
+ float s;
+ __asm vec4_sgt s, 0.0, d; // s = (0.0 > d) ? 1 : 0
+ return mix(-N, N, s);
+}
+
+vec4 faceforward(const vec4 N, const vec4 I, const vec4 Nref)
+{
+ // this could probably be done better
+ const float d = dot(Nref, I);
+ float s;
+ __asm vec4_sgt s, 0.0, d; // s = (0.0 > d) ? 1 : 0
+ return mix(-N, N, s);
+}
+
+
+//// reflect
+
+float reflect(const float I, const float N)
+{
+ return I - 2.0 * dot(N, I) * N;
+}
+
+vec2 reflect(const vec2 I, const vec2 N)
+{
+ return I - 2.0 * dot(N, I) * N;
+}
+
+vec3 reflect(const vec3 I, const vec3 N)
+{
+ return I - 2.0 * dot(N, I) * N;
+}
+
+vec4 reflect(const vec4 I, const vec4 N)
+{
+ return I - 2.0 * dot(N, I) * N;
+}
+
+//// refract
+
+float refract(const float I, const float N, const float eta)
+{
+ float n_dot_i = dot(N, I);
+ float k = 1.0 - eta * eta * (1.0 - n_dot_i * n_dot_i);
+ float retval;
+ if (k < 0.0)
+ retval = 0.0;
+ else
+ retval = eta * I - (eta * n_dot_i + sqrt(k)) * N;
+ return retval;
+}
+
+vec2 refract(const vec2 I, const vec2 N, const float eta)
+{
+ float n_dot_i = dot(N, I);
+ float k = 1.0 - eta * eta * (1.0 - n_dot_i * n_dot_i);
+ vec2 retval;
+ if (k < 0.0)
+ retval = vec2(0.0);
+ else
+ retval = eta * I - (eta * n_dot_i + sqrt(k)) * N;
+ return retval;
+}
+
+vec3 refract(const vec3 I, const vec3 N, const float eta)
+{
+ float n_dot_i = dot(N, I);
+ float k = 1.0 - eta * eta * (1.0 - n_dot_i * n_dot_i);
+ vec3 retval;
+ if (k < 0.0)
+ retval = vec3(0.0);
+ else
+ retval = eta * I - (eta * n_dot_i + sqrt(k)) * N;
+ return retval;
+}
+
+vec4 refract(const vec4 I, const vec4 N, const float eta)
+{
+ float n_dot_i = dot(N, I);
+ float k = 1.0 - eta * eta * (1.0 - n_dot_i * n_dot_i);
+ vec4 retval;
+ if (k < 0.0)
+ retval = vec4(0.0);
+ else
+ retval = eta * I - (eta * n_dot_i + sqrt(k)) * N;
+ return retval;
+}
+
+
+
+
+//
+// 8.5 Matrix Functions
+//
+
+mat2 matrixCompMult (mat2 m, mat2 n) {
+ return mat2 (m[0] * n[0], m[1] * n[1]);
+}
+
+mat3 matrixCompMult (mat3 m, mat3 n) {
+ return mat3 (m[0] * n[0], m[1] * n[1], m[2] * n[2]);
+}
+
+mat4 matrixCompMult (mat4 m, mat4 n) {
+ return mat4 (m[0] * n[0], m[1] * n[1], m[2] * n[2], m[3] * n[3]);
+}
+
+
+
+
+//
+// 8.6 Vector Relational Functions
+//
+
+//// lessThan
+
+bvec2 lessThan(const vec2 u, const vec2 v)
+{
+ __asm vec4_slt __retVal.xy, u, v;
+}
+
+bvec3 lessThan(const vec3 u, const vec3 v)
+{
+ __asm vec4_slt __retVal.xyz, u, v;
+}
+
+bvec4 lessThan(const vec4 u, const vec4 v)
+{
+ __asm vec4_slt __retVal, u, v;
+}
+
+bvec2 lessThan(const ivec2 u, const ivec2 v)
+{
+ __asm vec4_slt __retVal.xy, u, v;
+}
+
+bvec3 lessThan(const ivec3 u, const ivec3 v)
+{
+ __asm vec4_slt __retVal.xyz, u, v;
+}
+
+bvec4 lessThan(const ivec4 u, const ivec4 v)
+{
+ __asm vec4_slt __retVal, u, v;
+}
+
+
+//// lessThanEqual
+
+bvec2 lessThanEqual(const vec2 u, const vec2 v)
+{
+ __asm vec4_sle __retVal.xy, u, v;
+}
+
+bvec3 lessThanEqual(const vec3 u, const vec3 v)
+{
+ __asm vec4_sle __retVal.xyz, u, v;
+}
+
+bvec4 lessThanEqual(const vec4 u, const vec4 v)
+{
+ __asm vec4_sle __retVal, u, v;
+}
+
+bvec2 lessThanEqual(const ivec2 u, const ivec2 v)
+{
+ __asm vec4_sle __retVal.xy, u, v;
+}
+
+bvec3 lessThanEqual(const ivec3 u, const ivec3 v)
+{
+ __asm vec4_sle __retVal.xyz, u, v;
+}
+
+bvec4 lessThanEqual(const ivec4 u, const ivec4 v)
+{
+ __asm vec4_sle __retVal, u, v;
+}
+
+
+//// greaterThan
+
+bvec2 greaterThan(const vec2 u, const vec2 v)
+{
+ __asm vec4_sgt __retVal.xy, u, v;
+}
+
+bvec3 greaterThan(const vec3 u, const vec3 v)
+{
+ __asm vec4_sgt __retVal.xyz, u, v;
+}
+
+bvec4 greaterThan(const vec4 u, const vec4 v)
+{
+ __asm vec4_sgt __retVal, u, v;
+}
+
+bvec2 greaterThan(const ivec2 u, const ivec2 v)
+{
+ __asm vec4_sgt __retVal.xy, u.xy, v.xy;
+}
+
+bvec3 greaterThan(const ivec3 u, const ivec3 v)
+{
+ __asm vec4_sgt __retVal.xyz, u, v;
+}
+
+bvec4 greaterThan(const ivec4 u, const ivec4 v)
+{
+ __asm vec4_sgt __retVal, u, v;
+}
+
+
+//// greaterThanEqual
+
+bvec2 greaterThanEqual(const vec2 u, const vec2 v)
+{
+ __asm vec4_sge __retVal.xy, u, v;
+}
+
+bvec3 greaterThanEqual(const vec3 u, const vec3 v)
+{
+ __asm vec4_sge __retVal.xyz, u, v;
+}
+
+bvec4 greaterThanEqual(const vec4 u, const vec4 v)
+{
+ __asm vec4_sge __retVal, u, v;
+}
+
+bvec2 greaterThanEqual(const ivec2 u, const ivec2 v)
+{
+ __asm vec4_sge __retVal.xy, u, v;
+}
+
+bvec3 greaterThanEqual(const ivec3 u, const ivec3 v)
+{
+ __asm vec4_sge __retVal.xyz, u, v;
+}
+
+bvec4 greaterThanEqual(const ivec4 u, const ivec4 v)
+{
+ __asm vec4_sge __retVal, u, v;
+}
+
+
+//// equal
+
+bvec2 equal(const vec2 u, const vec2 v)
+{
+ __asm vec4_seq __retVal.xy, u, v;
+}
+
+bvec3 equal(const vec3 u, const vec3 v)
+{
+ __asm vec4_seq __retVal.xyz, u, v;
+}
+
+bvec4 equal(const vec4 u, const vec4 v)
+{
+ __asm vec4_seq __retVal, u, v;
+}
+
+bvec2 equal(const ivec2 u, const ivec2 v)
+{
+ __asm vec4_seq __retVal.xy, u, v;
+}
+
+bvec3 equal(const ivec3 u, const ivec3 v)
+{
+ __asm vec4_seq __retVal.xyz, u, v;
+}
+
+bvec4 equal(const ivec4 u, const ivec4 v)
+{
+ __asm vec4_seq __retVal, u, v;
+}
+
+bvec2 equal(const bvec2 u, const bvec2 v)
+{
+ __asm vec4_seq __retVal.xy, u, v;
+}
+
+bvec3 equal(const bvec3 u, const bvec3 v)
+{
+ __asm vec4_seq __retVal.xyz, u, v;
+}
+
+bvec4 equal(const bvec4 u, const bvec4 v)
+{
+ __asm vec4_seq __retVal, u, v;
+}
+
+
+
+
+//// notEqual
+
+bvec2 notEqual(const vec2 u, const vec2 v)
+{
+ __asm vec4_sne __retVal.xy, u, v;
+}
+
+bvec3 notEqual(const vec3 u, const vec3 v)
+{
+ __asm vec4_sne __retVal.xyz, u, v;
+}
+
+bvec4 notEqual(const vec4 u, const vec4 v)
+{
+ __asm vec4_sne __retVal, u, v;
+}
+
+bvec2 notEqual(const ivec2 u, const ivec2 v)
+{
+ __asm vec4_sne __retVal.xy, u, v;
+}
+
+bvec3 notEqual(const ivec3 u, const ivec3 v)
+{
+ __asm vec4_sne __retVal.xyz, u, v;
+}
+
+bvec4 notEqual(const ivec4 u, const ivec4 v)
+{
+ __asm vec4_sne __retVal, u, v;
+}
+
+bvec2 notEqual(const bvec2 u, const bvec2 v)
+{
+ __asm vec4_sne __retVal.xy, u, v;
+}
+
+bvec3 notEqual(const bvec3 u, const bvec3 v)
+{
+ __asm vec4_sne __retVal.xyz, u, v;
+}
+
+bvec4 notEqual(const bvec4 u, const bvec4 v)
+{
+ __asm vec4_sne __retVal, u, v;
+}
+
+
+
+//// any
+
+bool any(const bvec2 v)
+{
+ float sum;
+ __asm vec4_add sum.x, v.x, v.y;
+ __asm vec4_sne __retVal.x, sum.x, 0.0;
+}
+
+bool any(const bvec3 v)
+{
+ float sum;
+ __asm vec4_add sum.x, v.x, v.y;
+ __asm vec4_add sum.x, sum.x, v.z;
+ __asm vec4_sne __retVal.x, sum.x, 0.0;
+}
+
+bool any(const bvec4 v)
+{
+ float sum;
+ __asm vec4_add sum.x, v.x, v.y;
+ __asm vec4_add sum.x, sum.x, v.z;
+ __asm vec4_add sum.x, sum.x, v.w;
+ __asm vec4_sne __retVal.x, sum.x, 0.0;
+}
+
+
+//// all
+
+bool all (const bvec2 v)
+{
+ float prod;
+ __asm vec4_multiply prod, v.x, v.y;
+ __asm vec4_sne __retVal, prod, 0.0;
+}
+
+bool all (const bvec3 v)
+{
+ float prod;
+ __asm vec4_multiply prod, v.x, v.y;
+ __asm vec4_multiply prod, prod, v.z;
+ __asm vec4_sne __retVal, prod, 0.0;
+}
+
+bool all (const bvec4 v)
+{
+ float prod;
+ __asm vec4_multiply prod, v.x, v.y;
+ __asm vec4_multiply prod, prod, v.z;
+ __asm vec4_multiply prod, prod, v.w;
+ __asm vec4_sne __retVal, prod, 0.0;
+}
+
+
+
+//// not
+
+bvec2 not (const bvec2 v)
+{
+ __asm vec4_seq __retVal.xy, v, 0.0;
+}
+
+bvec3 not (const bvec3 v)
+{
+ __asm vec4_seq __retVal.xyz, v, 0.0;
+}
+
+bvec4 not (const bvec4 v)
+{
+ __asm vec4_seq __retVal, v, 0.0;
+}
+
+
+
+//// Texture Lookup Functions (for both fragment and vertex shaders)
+
+vec4 texture1D(const sampler1D sampler, const float coord)
+{
+ __asm vec4_tex1d __retVal, sampler, coord;
+}
+
+vec4 texture1DProj(const sampler1D sampler, const vec2 coord)
+{
+ // need to swizzle .y into .w
+ __asm vec4_texp1d __retVal, sampler, coord.xyyy;
+}
+
+vec4 texture1DProj(const sampler1D sampler, const vec4 coord)
+{
+ __asm vec4_texp1d __retVal, sampler, coord;
+}
+
+
+vec4 texture2D(const sampler2D sampler, const vec2 coord)
+{
+ __asm vec4_tex2d __retVal, sampler, coord;
+}
+
+vec4 texture2DProj(const sampler2D sampler, const vec3 coord)
+{
+ // need to swizzle 'z' into 'w'.
+ __asm vec4_texp2d __retVal, sampler, coord.xyzz;
+}
+
+vec4 texture2DProj(const sampler2D sampler, const vec4 coord)
+{
+ __asm vec4_texp2d __retVal, sampler, coord;
+}
+
+
+vec4 texture3D(const sampler3D sampler, const vec3 coord)
+{
+ __asm vec4_tex3d __retVal, sampler, coord;
+}
+
+vec4 texture3DProj(const sampler3D sampler, const vec4 coord)
+{
+ __asm vec4_texp3d __retVal, sampler, coord;
+}
+
+
+vec4 textureCube(const samplerCube sampler, const vec3 coord)
+{
+ __asm vec4_texcube __retVal, sampler, coord;
+}
+
+
+
+vec4 shadow1D(const sampler1DShadow sampler, const vec3 coord)
+{
+ __asm vec4_tex1d __retVal, sampler, coord;
+}
+
+vec4 shadow1DProj(const sampler1DShadow sampler, const vec4 coord)
+{
+ // .s and .p will be divided by .q
+ __asm vec4_texp1d __retVal, sampler, coord;
+}
+
+vec4 shadow2D(const sampler2DShadow sampler, const vec3 coord)
+{
+ __asm vec4_tex2d __retVal, sampler, coord;
+}
+
+vec4 shadow2DProj(const sampler2DShadow sampler, const vec4 coord)
+{
+ // .s, .t and .p will be divided by .q
+ __asm vec4_texp2d __retVal, sampler, coord;
+}
+
+
+//// GL_ARB_texture_rectangle:
+vec4 texture2DRect(const sampler2DRect sampler, const vec2 coord)
+{
+ __asm vec4_tex_rect __retVal, sampler, coord;
+}
+
+vec4 texture2DRectProj(const sampler2DRect sampler, const vec3 coord)
+{
+ // need to swizzle .y into .w
+ __asm vec4_texp_rect __retVal, sampler, coord.xyzz;
+}
+
+vec4 texture2DRectProj(const sampler2DRect sampler, const vec4 coord)
+{
+ __asm vec4_texp_rect __retVal, sampler, ccoord;
+}
+
+vec4 shadow2DRect(const sampler2DRectShadow sampler, const vec3 coord)
+{
+ __asm vec4_tex_rect __retVal, sampler, coord;
+}
+
+vec4 shadow2DRectProj(const sampler2DRectShadow sampler, const vec4 coord)
+{
+ __asm vec4_texp_rect __retVal, sampler, coord;
+}
+
+
+
+//
+// 8.9 Noise Functions
+//
+// AUTHOR: Stefan Gustavson (stegu@itn.liu.se), Nov 26, 2005
+//
+
+float noise1(const float x)
+{
+ __asm float_noise1 __retVal, x;
+}
+
+
+float noise1(const vec2 x)
+{
+ __asm float_noise2 __retVal, x;
}
-float noise1 (vec3 x) {\r
- float a;\r
- __asm float_noise3 a, x;\r
- return a;
+float noise1(const vec3 x)
+{
+ __asm float_noise3 __retVal, x;
}
-float noise1 (vec4 x) {\r
- float a;\r
- __asm float_noise4 a, x;\r
- return a;
+float noise1(const vec4 x)
+{
+ __asm float_noise4 __retVal, x;
}
-vec2 noise2 (float x) {\r
- vec2 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + 19.34);\r
- return u;
+vec2 noise2(const float x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + 19.34);
}
-vec2 noise2 (vec2 x) {\r
- vec2 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec2 (19.34, 7.66));\r
- return u;
+vec2 noise2(const vec2 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec2(19.34, 7.66));
}
-vec2 noise2 (vec3 x) {\r
- vec2 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec3 (19.34, 7.66, 3.23));\r
- return u;
+vec2 noise2(const vec3 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec3(19.34, 7.66, 3.23));
}
-vec2 noise2 (vec4 x) {\r
- vec2 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec4 (19.34, 7.66, 3.23, 2.77));\r
- return u;
+vec2 noise2(const vec4 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec4(19.34, 7.66, 3.23, 2.77));
}
-vec3 noise3 (float x) {\r
- vec3 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + 19.34);\r
- u.z = noise1 (x + 5.47);\r
- return u;
+vec3 noise3(const float x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + 19.34);
+ __retVal.z = noise1(x + 5.47);
}
-vec3 noise3 (vec2 x) {\r
- vec3 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec2 (19.34, 7.66));\r
- u.z = noise1 (x + vec2 (5.47, 17.85));\r
- return u;
+vec3 noise3(const vec2 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec2(19.34, 7.66));
+ __retVal.z = noise1(x + vec2(5.47, 17.85));
}
-vec3 noise3 (vec3 x) {\r
- vec3 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec3 (19.34, 7.66, 3.23));\r
- u.z = noise1 (x + vec3 (5.47, 17.85, 11.04));\r
- return u;
+vec3 noise3(const vec3 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec3(19.34, 7.66, 3.23));
+ __retVal.z = noise1(x + vec3(5.47, 17.85, 11.04));
}
-vec3 noise3 (vec4 x) {\r
- vec3 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec4 (19.34, 7.66, 3.23, 2.77));\r
- u.z = noise1 (x + vec4 (5.47, 17.85, 11.04, 13.19));\r
- return u;
+vec3 noise3(const vec4 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec4(19.34, 7.66, 3.23, 2.77));
+ __retVal.z = noise1(x + vec4(5.47, 17.85, 11.04, 13.19));
}
-vec4 noise4 (float x) {\r
- vec4 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + 19.34);\r
- u.z = noise1 (x + 5.47);\r
- u.w = noise1 (x + 23.54);\r
- return u;
+vec4 noise4(const float x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + 19.34);
+ __retVal.z = noise1(x + 5.47);
+ __retVal.w = noise1(x + 23.54);
}
-vec4 noise4 (vec2 x) {\r
- vec4 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec2 (19.34, 7.66));\r
- u.z = noise1 (x + vec2 (5.47, 17.85));\r
- u.w = noise1 (x + vec2 (23.54, 29.11));\r
- return u;
+vec4 noise4(const vec2 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec2 (19.34, 7.66));
+ __retVal.z = noise1(x + vec2 (5.47, 17.85));
+ __retVal.w = noise1(x + vec2 (23.54, 29.11));
}
-vec4 noise4 (vec3 x) {\r
- vec4 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec3 (19.34, 7.66, 3.23));\r
- u.z = noise1 (x + vec3 (5.47, 17.85, 11.04));\r
- u.w = noise1 (x + vec3 (23.54, 29.11, 31.91));\r
- return u;
+vec4 noise4(const vec3 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec3(19.34, 7.66, 3.23));
+ __retVal.z = noise1(x + vec3(5.47, 17.85, 11.04));
+ __retVal.w = noise1(x + vec3(23.54, 29.11, 31.91));
}
-vec4 noise4 (vec4 x) {\r
- vec4 u;\r
- u.x = noise1 (x);\r
- u.y = noise1 (x + vec4 (19.34, 7.66, 3.23, 2.77));\r
- u.z = noise1 (x + vec4 (5.47, 17.85, 11.04, 13.19));\r
- u.w = noise1 (x + vec4 (23.54, 29.11, 31.91, 37.48));\r
- return u;
+vec4 noise4(const vec4 x)
+{
+ __retVal.x = noise1(x);
+ __retVal.y = noise1(x + vec4(19.34, 7.66, 3.23, 2.77));
+ __retVal.z = noise1(x + vec4(5.47, 17.85, 11.04, 13.19));
+ __retVal.w = noise1(x + vec4(23.54, 29.11, 31.91, 37.48));
}
-\r
projects / mesa.git / blobdiff