The OpenGL Shading Language Runtime Library for Legacy Target.

Sounds good :)

3 files changed, 1916 insertions, 0 deletions

diff --git a/src/mesa/shader/slang_common_builtin.gc b/src/mesa/shader/slang_common_builtin.gc
new file mode 100755
index 0000000000..994e1a31fb
--- /dev/null
+++ b/src/mesa/shader/slang_common_builtin.gc
@@ -0,0 +1,1302 @@
+

+// 

+// TODO:

+// - implement sin, asin, acos, atan, pow, log2, floor, ceil,

+// - implement texture1D, texture2D, texture3D, textureCube,

+// - implement shadow1D, shadow2D,

+// - implement noise1, noise2, noise3, noise4,

+// 

+

+// 

+// From Shader Spec, ver. 1.051

+// 

+// The following built-in constants are provided to vertex and fragment shaders.

+// 

+

+// 

+// Implementation dependent constants. The example values below

+// are the minimum values allowed for these maximums.

+// 

+

+const int gl_MaxLights = 8;                             // GL 1.0

+const int gl_MaxClipPlanes = 6;                         // GL 1.0

+const int gl_MaxTextureUnits = 2;                       // GL 1.2

+const int gl_MaxTextureCoordsARB = 2;                   // ARB_fragment_program

+const int gl_MaxVertexAttributesGL2 = 16;               // GL2_vertex_shader

+const int gl_MaxVertexUniformFloatsGL2 = 512;           // GL2_vertex_shader

+const int gl_MaxVaryingFloatsGL2 = 32;                  // GL2_vertex_shader

+const int gl_MaxVertexTextureUnitsGL2 = 1;              // GL2_vertex_shader

+const int gl_MaxFragmentTextureUnitsGL2 = 2;            // GL2_fragment_shader

+const int gl_MaxFragmentUniformFloatsGL2 = 64;          // GL2_fragment_shader

+

+// 

+// As an aid to accessing OpenGL processing state, the following uniform variables are built into

+// the OpenGL Shading Language. All page numbers and notations are references to the 1.4

+// specification.

+// 

+

+// 

+// Matrix state. p. 31, 32, 37, 39, 40.

+// 

+

+uniform mat4 gl_ModelViewMatrix;

+uniform mat4 gl_ProjectionMatrix;

+uniform mat4 gl_ModelViewProjectionMatrix;

+uniform mat3 gl_NormalMatrix;                           // derived

+uniform mat4 gl_TextureMatrix[gl_MaxTextureCoordsARB];

+

+// 

+// Normal scaling p. 39.

+// 

+

+uniform float gl_NormalScale;

+

+// 

+// Depth range in window coordinates, p. 33

+// 

+

+struct gl_DepthRangeParameters {

+    float near;                                         // n

+    float far;                                          // f

+    float diff;                                         // f - n

+};

+

+uniform gl_DepthRangeParameters gl_DepthRange;

+

+// 

+// Clip planes p. 42.

+// 

+

+uniform vec4 gl_ClipPlane[gl_MaxClipPlanes];

+

+// 

+// Point Size, p. 66, 67.

+// 

+

+struct gl_PointParameters {

+    float size;

+    float sizeMin;

+    float sizeMax;

+    float fadeThresholdSize;

+    float distanceConstantAttenuation;

+    float distanceLinearAttenuation;

+    float distanceQuadraticAttenuation;

+};

+

+uniform gl_PointParameters gl_Point;

+

+// 

+// Material State p. 50, 55.

+// 

+

+struct gl_MaterialParameters {

+    vec4 emission;                                      // Ecm

+    vec4 ambient;                                       // Acm

+    vec4 diffuse;                                       // Dcm

+    vec4 specular;                                      // Scm

+    float shininess;                                    // Srm

+};

+

+uniform gl_MaterialParameters gl_FrontMaterial;

+uniform gl_MaterialParameters gl_BackMaterial;

+

+// 

+// Light State p 50, 53, 55.

+// 

+

+struct gl_LightSourceParameters {

+    vec4 ambient;                                       // Acli

+    vec4 diffuse;                                       // Dcli

+    vec4 specular;                                      // Scli

+    vec4 position;                                      // Ppli

+    vec4 halfVector;                                    // Derived: Hi

+    vec3 spotDirection;                                 // Sdli

+    float spotExponent;                                 // Srli

+    float spotCutoff;                                   // Crli

+                                                        // (range: [0.0,90.0], 180.0)

+    float spotCosCutoff;                                // Derived: cos(Crli)

+                                                        // (range: [1.0,0.0],-1.0)

+    float constantAttenuation;                          // K0

+    float linearAttenuation;                            // K1

+    float quadraticAttenuation;                         // K2

+};

+

+uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];

+

+struct gl_LightModelParameters {

+    vec4 ambient;                                       // Acs

+};

+

+uniform gl_LightModelParameters gl_LightModel;

+

+// 

+// Derived state from products of light and material.

+// 

+

+struct gl_LightModelProducts {

+    vec4 sceneColor;                                    // Derived. Ecm + Acm * Acs

+};

+

+uniform gl_LightModelProducts gl_FrontLightModelProduct;

+uniform gl_LightModelProducts gl_BackLightModelProduct;

+

+struct gl_LightProducts {

+    vec4 ambient;                                       // Acm * Acli

+    vec4 diffuse;                                       // Dcm * Dcli

+    vec4 specular;                                      // Scm * Scli

+};

+

+uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];

+uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];

+

+// 

+// Textureg Environment and Generation, p. 152, p. 40-42.

+// 

+

+uniform vec4 gl_TextureEnvColor[gl_MaxFragmentTextureUnitsGL2];

+uniform vec4 gl_EyePlaneS[gl_MaxTextureCoordsARB];

+uniform vec4 gl_EyePlaneT[gl_MaxTextureCoordsARB];

+uniform vec4 gl_EyePlaneR[gl_MaxTextureCoordsARB];

+uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoordsARB];

+uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoordsARB];

+uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoordsARB];

+uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoordsARB];

+uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoordsARB];

+

+// 

+// Fog p. 161

+// 

+

+struct gl_FogParameters {

+    vec4 color;

+    float density;

+    float start;

+    float end;

+    float scale;                                        // 1 / (gl_FogEnd - gl_FogStart)

+};

+

+uniform gl_FogParameters gl_Fog;

+

+// 

+// The OpenGL Shading Language defines an assortment of built-in convenience functions for scalar

+// and vector operations. Many of these built-in functions can be used in more than one type

+// of shader, but some are intended to provide a direct mapping to hardware and so are available

+// only for a specific type of shader.

+// 

+// The built-in functions basically fall into three categories:

+// 

+// • They expose some necessary hardware functionality in a convenient way such as accessing

+//   a texture map. There is no way in the language for these functions to be emulated by a shader.

+// 

+// • They represent a trivial operation (clamp, mix, etc.) that is very simple for the user

+//   to write, but they are very common and may have direct hardware support. It is a very hard

+//   problem for the compiler to map expressions to complex assembler instructions.

+// 

+// • They represent an operation graphics hardware is likely to accelerate at some point. The

+//   trigonometry functions fall into this category.

+// 

+// Many of the functions are similar to the same named ones in common C libraries, but they support

+// vector input as well as the more traditional scalar input.

+// 

+// Applications should be encouraged to use the built-in functions rather than do the equivalent

+// computations in their own shader code since the built-in functions are assumed to be optimal

+// (e.g., perhaps supported directly in hardware).

+// 

+// User code can replace built-in functions with their own if they choose, by simply re-declaring

+// and defining the same name and argument list.

+// 

+

+// 

+// Angle and Trigonometry Functions

+// 

+// Function parameters specified as angle are assumed to be in units of radians. In no case will

+// any of these functions result in a divide by zero error. If the divisor of a ratio is 0, then

+// results will be undefined.

+// 

+// These all operate component-wise.

+// 

+

+// 

+// Converts degrees to radians and returns the result, i.e., result = PI*deg/180.

+// 

+

+float radians (float deg) {

+    return 3.141593 * deg / 180.0;

+}

+vec2 radians (vec2 deg) {

+    return vec2 (radians (deg.x), radians (deg.y));

+}

+vec3 radians (vec3 deg) {

+    return vec3 (radians (deg.x), radians (deg.y), radians (deg.z));

+}

+vec4 radians (vec4 deg) {

+    return vec4 (radians (deg.x), radians (deg.y), radians (deg.z), radians (deg.w));

+}

+

+// 

+// Converts radians to degrees and returns the result, i.e., result = 180*rad/PI.

+// 

+

+float degrees (float rad) {

+    return 180.0 * rad / 3.141593;

+}

+vec2 degrees (vec2 rad) {

+    return vec2 (degrees (rad.x), degrees (rad.y));

+}

+vec3 degrees (vec3 rad) {

+    return vec3 (degrees (rad.x), degrees (rad.y), degrees (rad.z));

+}

+vec4 degrees (vec4 rad) {

+    return vec4 (degrees (rad.x), degrees (rad.y), degrees (rad.z), degrees (rad.w));

+}

+

+// 

+// The standard trigonometric sine function.

+// 

+// XXX

+float sin (float angle) {

+    return 0.0;

+}

+vec2 sin (vec2 angle) {

+    return vec2 (sin (angle.x), sin (angle.y));

+}

+vec3 sin (vec3 angle) {

+    return vec3 (sin (angle.x), sin (angle.y), sin (angle.z));

+}

+vec4 sin (vec4 angle) {

+    return vec4 (sin (angle.x), sin (angle.y), sin (angle.z), sin (angle.w));

+}

+

+// 

+// The standard trigonometric cosine function.

+// 

+

+float cos (float angle) {

+    return sin (angle + 1.5708);

+}

+vec2 cos (vec2 angle) {

+    return vec2 (cos (angle.x), cos (angle.y));

+}

+vec3 cos (vec3 angle) {

+    return vec3 (cos (angle.x), cos (angle.y), cos (angle.z));

+}

+vec4 cos (vec4 angle) {

+    return vec4 (cos (angle.x), cos (angle.y), cos (angle.z), cos (angle.w));

+}

+

+// 

+// The standard trigonometric tangent.

+// 

+

+float tan (float angle) {

+    return sin (angle) / cos (angle);

+}

+vec2 tan (vec2 angle) {

+    return vec2 (tan (angle.x), tan (angle.y));

+}

+vec3 tan (vec3 angle) {

+    return vec3 (tan (angle.x), tan (angle.y), tan (angle.z));

+}

+vec4 tan (vec4 angle) {

+    return vec4 (tan (angle.x), tan (angle.y), tan (angle.z), tan (angle.w));

+}

+

+// 

+// Arc sine. Returns an angle whose sine is x. The range of values returned by this function is

+// [–PI/2, PI/2]. Results are undefined if |x| > 1.

+// 

+// XXX

+float asin (float x) {

+    return 0.0;

+}

+vec2 asin (vec2 x) {

+    return vec2 (asin (x.x), asin (x.y));

+}

+vec3 asin (vec3 x) {

+    return vec3 (asin (x.x), asin (x.y), asin (x.z));

+}

+vec4 asin (vec4 x) {

+    return vec4 (asin (x.x), asin (x.y), asin (x.z), asin (x.w));

+}

+

+// 

+// Arc cosine. Returns an angle whose cosine is x. The range of values returned by this function is

+// [0, PI]. Results are undefined if |x| > 1.

+// 

+// XXX

+float acos (float x) {

+    return 0.0;

+}

+vec2 acos (vec2 x) {

+    return vec2 (acos (x.x), acos (x.y));

+}

+vec3 acos (vec3 x) {

+    return vec3 (acos (x.x), acos (x.y), acos (x.z));

+}

+vec4 acos (vec4 x) {

+    return vec4 (acos (x.x), acos (x.y), acos (x.z), acos (x.w));

+}

+

+// 

+// Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine

+// what quadrant the angle is in. The range of values returned by this function is [–PI, PI].

+// Results are undefined if x and y are both 0.

+// 

+// XXX

+float atan (float x, float y) {

+    return 0.0;

+}

+vec2 atan (vec2 x, vec2 y) {

+    return vec2 (atan (x.x, y.x), atan (x.y, y.y));

+}

+vec3 atan (vec3 x, vec3 y) {

+    return vec3 (atan (x.x, y.x), atan (x.y, y.y), atan (x.z, y.z));

+}

+vec4 atan (vec4 x, vec4 y) {

+    return vec4 (atan (x.x, y.x), atan (x.y, y.y), atan (x.z, y.z), atan (x.w, y.w));

+}

+

+// 

+// Arc tangent. Returns an angle whose tangent is y_over_x. The range of values returned by this

+// function is [–PI/2, PI/2].

+// 

+// XXX

+float atan (float y_over_x) {

+    return 0.0;

+}

+vec2 atan (vec2 y_over_x) {

+    return vec2 (atan (y_over_x.x), atan (y_over_x.y));

+}

+vec3 atan (vec3 y_over_x) {

+    return vec3 (atan (y_over_x.x), atan (y_over_x.y), atan (y_over_x.z));

+}

+vec4 atan (vec4 y_over_x) {

+    return vec4 (atan (y_over_x.x), atan (y_over_x.y), atan (y_over_x.z), atan (y_over_x.w));

+}

+

+// 

+// Exponential Functions

+// 

+// These all operate component-wise.

+// 

+

+// 

+// Returns x raised to the y power, i.e., x^y

+// 

+// XXX

+float pow (float x, float y) {

+    return 0.0;

+}

+vec2 pow (vec2 x, vec2 y) {

+    return vec2 (pow (x.x, y.x), pow (x.y, y.y));

+}

+vec3 pow (vec3 x, vec3 y) {

+    return vec3 (pow (x.x, y.x), pow (x.y, y.y), pow (x.z, y.z));

+}

+vec4 pow (vec4 x, vec4 y) {

+    return vec4 (pow (x.x, y.x), pow (x.y, y.y), pow (x.z, y.z), pow (x.w, y.w));

+}

+

+// 

+// Returns 2 raised to the x power, i.e., 2^x

+// 

+

+float exp2 (float x) {

+    return pow (2.0, x);

+}

+vec2 exp2 (vec2 x) {

+    return vec2 (exp2 (x.x), exp2 (x.y));

+}

+vec3 exp2 (vec3 x) {

+    return vec3 (exp2 (x.x), exp2 (x.y), exp2 (x.z));

+}

+vec4 exp2 (vec4 x) {

+    return vec4 (exp2 (x.x), exp2 (x.y), exp2 (x.z), exp2 (x.w));

+}

+

+// 

+// Returns the base 2 log of x, i.e., returns the value y which satisfies the equation x = 2^y

+// 

+// XXX

+float log2 (float x) {

+    return 0.0;

+}

+vec2 log2 (vec2 x) {

+    return vec2 (log2 (x.x), log2 (x.y));

+}

+vec3 log2 (vec3 x) {

+    return vec3 (log2 (x.x), log2 (x.y), log2 (x.z));

+}

+vec4 log2 (vec4 x) {

+    return vec4 (log2 (x.x), log2 (x.y), log2 (x.z), log2 (x.w));

+}

+

+// 

+// Returns the positive square root of x

+// 

+

+float sqrt (float x) {

+    return pow (x, 0.5);

+}

+vec2 sqrt (vec2 x) {

+    return vec2 (sqrt (x.x), sqrt (x.y));

+}

+vec3 sqrt (vec3 x) {

+    return vec3 (sqrt (x.x), sqrt (x.y), sqrt (x.z));

+}

+vec4 sqrt (vec4 x) {

+    return vec4 (sqrt (x.x), sqrt (x.y), sqrt (x.z), sqrt (x.w));

+}

+

+// 

+// Returns the reciprocal of the positive square root of x

+// 

+

+float inversesqrt (float x) {

+    return 1.0 / sqrt (x);

+}

+vec2 inversesqrt (vec2 x) {

+    return vec2 (inversesqrt (x.x), inversesqrt (x.y));

+}

+vec3 inversesqrt (vec3 x) {

+    return vec3 (inversesqrt (x.x), inversesqrt (x.y), inversesqrt (x.z));

+}

+vec4 inversesqrt (vec4 x) {

+    return vec4 (inversesqrt (x.x), inversesqrt (x.y), inversesqrt (x.z), inversesqrt (x.w));

+}

+

+// 

+// Common Functions

+// 

+// These all operate component-wise.

+// 

+

+// 

+// Returns x if x >= 0, otherwise it returns –x

+// 

+

+float abs (float x) {

+    return x >= 0.0 ? x : -x;

+}

+vec2 abs (vec2 x) {

+    return vec2 (abs (x.x), abs (x.y));

+}

+vec3 abs (vec3 x) {

+    return vec3 (abs (x.x), abs (x.y), abs (x.z));

+}

+vec4 abs (vec4 x) {

+    return vec4 (abs (x.x), abs (x.y), abs (x.z), abs (x.w));

+}

+

+// 

+// Returns 1.0 if x > 0, 0.0 if x = 0, or –1.0 if x < 0

+// 

+

+float sign (float x) {

+    return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : 0.0;

+}

+vec2 sign (vec2 x) {

+    return vec2 (sign (x.x), sign (x.y));

+}

+vec3 sign (vec3 x) {

+    return vec3 (sign (x.x), sign (x.y), sign (x.z));

+}

+vec4 sign (vec4 x) {

+    return vec4 (sign (x.x), sign (x.y), sign (x.z), sign (x.w));

+}

+

+// 

+// Returns a value equal to the nearest integer that is less than or equal to x

+// 

+// XXX

+float floor (float x) {

+    return 0.0;

+}

+vec2 floor (vec2 x) {

+    return vec2 (floor (x.x), floor (x.y));

+}

+vec3 floor (vec3 x) {

+    return vec3 (floor (x.x), floor (x.y), floor (x.z));

+}

+vec4 floor (vec4 x) {

+    return vec4 (floor (x.x), floor (x.y), floor (x.z), floor (x.w));

+}

+

+// 

+// Returns a value equal to the nearest integer that is greater than or equal to x

+// 

+// XXX

+float ceil (float x) {

+    return 0.0;

+}

+vec2 ceil (vec2 x) {

+    return vec2 (ceil (x.x), ceil (x.y));

+}

+vec3 ceil (vec3 x) {

+    return vec3 (ceil (x.x), ceil (x.y), ceil (x.z));

+}

+vec4 ceil (vec4 x) {

+    return vec4 (ceil (x.x), ceil (x.y), ceil (x.z), ceil (x.w));

+}

+

+// 

+// Returns x – floor (x)

+// 

+

+float fract (float x) {

+    return x - floor (x);

+}

+vec2 fract (vec2 x) {

+    return vec2 (fract (x.x), fract (x.y));

+}

+vec3 fract (vec3 x) {

+    return vec3 (fract (x.x), fract (x.y), fract (x.z));

+}

+vec4 fract (vec4 x) {

+    return vec4 (fract (x.x), fract (x.y), fract (x.z), fract (x.w));

+}

+

+// 

+// Modulus. Returns x – y * floor (x/y)

+// 

+

+float mod (float x, float y) {

+    return x - y * floor (x / y);

+}

+vec2 mod (vec2 x, float y) {

+    return vec2 (mod (x.x, y), mod (x.y, y));

+}

+vec3 mod (vec3 x, float y) {

+    return vec3 (mod (x.x, y), mod (x.y, y), mod (x.z, y));

+}

+vec4 mod (vec4 x, float y) {

+    return vec4 (mod (x.x, y), mod (x.y, y), mod (x.z, y), mod (x.w, y));

+}

+vec2 mod (vec2 x, vec2 y) {

+    return vec2 (mod (x.x, y.x), mod (x.y, y.y));

+}

+vec3 mod (vec3 x, vec3 y) {

+    return vec3 (mod (x.x, y.x), mod (x.y, y.y), mod (x.z, y.z));

+}

+vec4 mod (vec4 x, vec4 y) {

+    return vec4 (mod (x.x, y.x), mod (x.y, y.y), mod (x.z, y.z), mod (x.w, y.w));

+}

+

+// 

+// Returns y if y < x, otherwise it returns x

+// 

+

+float min (float x, float y) {

+    return y < x ? y : x;

+}

+vec2 min (vec2 x, float y) {

+    return vec2 (min (x.x, y), min (x.y, y));

+}

+vec3 min (vec3 x, float y) {

+    return vec3 (min (x.x, y), min (x.y, y), min (x.z, y));

+}

+vec4 min (vec4 x, float y) {

+    return vec4 (min (x.x, y), min (x.y, y), min (x.z, y), min (x.w, y));

+}

+vec2 min (vec2 x, vec2 y) {

+    return vec2 (min (x.x, y.x), min (x.y, y.y));

+}

+vec3 min (vec3 x, vec3 y) {

+    return vec3 (min (x.x, y.x), min (x.y, y.y), min (x.z, y.z));

+}

+vec4 min (vec4 x, vec4 y) {

+    return vec4 (min (x.x, y.x), min (x.y, y.y), min (x.z, y.z), min (x.w, y.w));

+}

+

+// 

+// Returns y if x < y, otherwise it returns x

+// 

+

+float max (float x, float y) {

+    return min (y, x);

+}

+vec2 max (vec2 x, float y) {

+    return vec2 (max (x.x, y), max (x.y, y));

+}

+vec3 max (vec3 x, float y) {

+    return vec3 (max (x.x, y), max (x.y, y), max (x.z, y));

+}

+vec4 max (vec4 x, float y) {

+    return vec4 (max (x.x, y), max (x.y, y), max (x.z, y), max (x.w, y));

+}

+vec2 max (vec2 x, vec2 y) {

+    return vec2 (max (x.x, y.x), max (x.y, y.y));

+}

+vec3 max (vec3 x, vec3 y) {

+    return vec3 (max (x.x, y.x), max (x.y, y.y), max (x.z, y.z));

+}

+vec4 max (vec4 x, vec4 y) {

+    return vec4 (max (x.x, y.x), max (x.y, y.y), max (x.z, y.z), max (x.w, y.w));

+}

+

+// 

+// Returns min (max (x, minVal), maxVal)

+// 

+// Note that colors and depths written by fragment shaders will be clamped by the implementation

+// after the fragment shader runs.

+// 

+

+float clamp (float x, float minVal, float maxVal) {

+    return min (max (x, minVal), maxVal);

+}

+vec2 clamp (vec2 x, float minVal, float maxVal) {

+    return vec2 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal));

+}

+vec3 clamp (vec3 x, float minVal, float maxVal) {

+    return vec3 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal),

+        clamp (x.z, minVal, maxVal));

+}

+vec4 clamp (vec4 x, float minVal, float maxVal) {

+    return vec4 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal),

+        clamp (x.z, minVal, maxVal), clamp (x.w, minVal, maxVal));

+}

+vec2 clamp (vec2 x, vec2 minVal, vec2 maxVal) {

+    return vec2 (clamp (x.x, minVal.x, maxVal.x), clamp (x.y, minVal.y, maxVal.y));

+}

+vec3 clamp (vec3 x, vec3 minVal, vec3 maxVal) {

+    return vec3 (clamp (x.x, minVal.x, maxVal.x), clamp (x.y, minVal.y, maxVal.y),

+        clamp (x.z, minVal.z, maxVal.z));

+}

+vec4 clamp (vec4 x, vec4 minVal, vec4 maxVal) {

+    return vec4 (clamp (x.x, minVal.x, maxVal.y), clamp (x.y, minVal.y, maxVal.y),

+        clamp (x.z, minVal.z, maxVal.z), clamp (x.w, minVal.w, maxVal.w));

+}

+

+// 

+// Returns x * (1 – a) + y * a, i.e., the linear blend of x and y

+// 

+

+float mix (float x, float y, float a) {

+    return x * (1.0 - a) + y * a;

+}

+vec2 mix (vec2 x, vec2 y, float a) {

+    return vec2 (mix (x.x, y.x, a), mix (x.y, y.y, a));

+}

+vec3 mix (vec3 x, vec3 y, float a) {

+    return vec3 (mix (x.x, y.x, a), mix (x.y, y.y, a), mix (x.z, y.z, a));

+}

+vec4 mix (vec4 x, vec4 y, float a) {

+    return vec4 (mix (x.x, y.x, a), mix (x.y, y.y, a), mix (x.z, y.z, a), mix (x.w, y.w, a));

+}

+vec2 mix (vec2 x, vec2 y, vec2 a) {

+    return vec2 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y));

+}

+vec3 mix (vec3 x, vec3 y, vec3 a) {

+    return vec3 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y), mix (x.z, y.z, a.z));

+}

+vec4 mix (vec4 x, vec4 y, vec4 a) {

+    return vec4 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y), mix (x.z, y.z, a.z),

+        mix (x.w, y.w, a.w));

+}

+

+// 

+// Returns 0.0 if x <= edge, otherwise it returns 1.0

+// 

+

+float step (float edge, float x) {

+    return x <= edge ? 0.0 : 1.0;

+}

+vec2 step (float edge, vec2 x) {

+    return vec2 (step (edge, x.x), step (edge, x.y));

+}

+vec3 step (float edge, vec3 x) {

+    return vec3 (step (edge, x.x), step (edge, x.y), step (edge, x.z));

+}

+vec4 step (float edge, vec4 x) {

+    return vec4 (step (edge, x.x), step (edge, x.y), step (edge, x.z), step (edge, x.w));

+}

+vec2 step (vec2 edge, vec2 x) {

+    return vec2 (step (edge.x, x.x), step (edge.y, x.y));

+}

+vec3 step (vec3 edge, vec3 x) {

+    return vec3 (step (edge.x, x.x), step (edge.y, x.y), step (edge.z, x.z));

+}

+vec4 step (vec4 edge, vec4 x) {

+    return vec4 (step (edge.x, x.x), step (edge.y, x.y), step (edge.z, x.z), step (edge.w, x.w));

+}

+

+// 

+// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation

+// between 0 and 1 when edge0 < x < edge1. This is useful in cases where you would want a threshold

+// function with a smooth transition. This is equivalent to:

+// <type> t;

+// t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);

+// return t * t * (3 – 2 * t);

+// 

+

+float smoothstep (float edge0, float edge1, float x) {

+    const float t = clamp ((x - edge0) / (edge1 - edge0), 0.0, 1.0);

+    return t * t * (3.0 - 2.0 * t);

+}

+vec2 smoothstep (float edge0, float edge1, vec2 x) {

+    return vec2 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y));

+}

+vec3 smoothstep (float edge0, float edge1, vec3 x) {

+    return vec3 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y),

+        smoothstep (edge0, edge1, x.z));

+}

+vec4 smoothstep (float edge0, float edge1, vec4 x) {

+    return vec4 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y),

+        smoothstep (edge0, edge1, x.z), smoothstep (edge0, edge1, x.w));

+}

+vec2 smoothstep (vec2 edge0, vec2 edge1, vec2 x) {

+    return vec2 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y));

+}

+vec3 smoothstep (vec3 edge0, vec3 edge1, vec3 x) {

+    return vec3 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y),

+        smoothstep (edge0.z, edge1.z, x.z));

+}

+vec4 smoothstep (vec4 edge0, vec4 edge1, vec4 x) {

+    return vec4 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y),

+        smoothstep (edge0.z, edge1.z, x.z), smoothstep (edge0.w, edge1.w, x.w));

+}

+

+// 

+// Geometric Functions

+// 

+// These operate on vectors as vectors, not component-wise.

+// 

+

+// 

+// Returns the dot product of x and y, i.e., result = x[0] * y[0] + x[1] * y[1] + ...

+// 

+

+float dot (float x, float y) {

+    return x * y;

+}

+float dot (vec2 x, vec2 y) {

+    return dot (x.x, y.x) + dot (x.y, y.y);

+}

+float dot (vec3 x, vec3 y) {

+    return dot (x.x, y.x) + dot (x.y, y.y) + dot (x.z, y.z);

+}

+float dot (vec4 x, vec4 y) {

+    return dot (x.x, y.x) + dot (x.y, y.y) + dot (x.z, y.z) + dot (x.w, y.w);

+}

+

+// 

+// Returns the length of vector x, i.e., sqrt (x[0] * x[0] + x[1] * x[1] + ...)

+// 

+

+float length (float x) {

+    return sqrt (dot (x, x));

+}

+float length (vec2 x) {

+    return sqrt (dot (x, x));

+}

+float length (vec3 x) {

+    return sqrt (dot (x, x));

+}

+float length (vec4 x) {

+    return sqrt (dot (x, x));

+}

+

+// 

+// Returns the distance between p0 and p1, i.e. length (p0 – p1)

+// 

+

+float distance (float x, float y) {

+    return length (x - y);

+}

+float distance (vec2 x, vec2 y) {

+    return length (x - y);

+}

+float distance (vec3 x, vec3 y) {

+    return length (x - y);

+}

+float distance (vec4 x, vec4 y) {

+    return length (x - y);

+}

+

+// 

+// Returns the cross product of x and y, i.e.

+// result.0 = x[1] * y[2] - y[1] * x[2]

+// result.1 = x[2] * y[0] - y[2] * x[0]

+// result.2 = x[0] * y[1] - y[0] * x[1]

+// 

+

+vec3 cross (vec3 x, vec3 y) {

+    return vec3 (x.y * y.z - y.y * x.z, x.z * y.x - y.z * x.x, x.x * y.y - y.x * x.y);

+}

+

+// 

+// Returns a vector in the same direction as x but with a length of 1.

+// 

+

+float normalize (float x) {

+    return 1.0;

+}

+vec2 normalize (vec2 x) {

+    return x / length (x);

+}

+vec3 normalize (vec3 x) {

+    return x / length (x);

+}

+vec4 normalize (vec4 x) {

+    return x / length (x);

+}

+

+// 

+// If dot (Nref, I) < 0 return N otherwise return –N

+// 

+

+float faceforward (float N, float I, float Nref) {

+    return dot (Nref, I) < 0.0 ? N : -N;

+}

+vec2 faceforward (vec2 N, vec2 I, vec2 Nref) {

+    return dot (Nref, I) < 0.0 ? N : -N;

+}

+vec3 faceforward (vec3 N, vec3 I, vec3 Nref) {

+    return dot (Nref, I) < 0.0 ? N : -N;

+}

+vec4 faceforward (vec4 N, vec4 I, vec4 Nref) {

+    return dot (Nref, I) < 0.0 ? N : -N;

+}

+

+// 

+// For the incident vector I and surface orientation N, returns the reflection direction:

+// result = I – 2 * dot (N, I) * N

+// N should be normalized in order to achieve the desired result.

+

+float reflect (float I, float N) {

+    return I - 2.0 * dot (N, I) * N;

+}

+vec2 reflect (vec2 I, vec2 N) {

+    return I - 2.0 * dot (N, I) * N;

+}

+vec3 reflect (vec3 I, vec3 N) {

+    return I - 2.0 * dot (N, I) * N;

+}

+vec4 reflect (vec4 I, vec4 N) {

+    return I - 2.0 * dot (N, I) * N;

+}

+

+// 

+// Matrix Functions

+// 

+

+// 

+// Multiply matrix x by matrix y component-wise, i.e., result[i][j] is the scalar product

+// of x[i][j] and y[i][j].

+// Note: to get linear algebraic matrix multiplication, use the multiply operator (*).

+// 

+

+mat2 matrixCompMult (mat2 x, mat2 y) {

+    return mat2 (

+        x[0].x * y[0].x, x[0].y * y[0].y,

+        x[1].x * y[1].x, x[1].y * y[1].y

+    );

+}

+mat3 matrixCompMult (mat3 x, mat3 y) {

+    return mat4 (

+        x[0].x * y[0].x, x[0].y * y[0].y, x[0].z * y[0].z,

+        x[1].x * y[1].x, x[1].y * y[1].y, x[1].z * y[1].z,

+        x[2].x * y[2].x, x[2].y * y[2].y, x[2].z * y[2].z

+    );

+}

+mat4 matrixCompMult (mat4 x, mat4 y) {

+    return mat4 (

+        x[0].x * y[0].x, x[0].y * y[0].y, x[0].z * y[0].z + x[0].w * y[0].w,

+        x[1].x * y[1].x, x[1].y * y[1].y, x[1].z * y[1].z + x[1].w * y[1].w,

+        x[2].x * y[2].x, x[2].y * y[2].y, x[2].z * y[2].z + x[2].w * y[2].w,

+        x[3].x * y[3].x, x[3].y * y[3].y, x[3].z * y[3].z + x[3].w * y[3].w

+    );

+}

+

+// 

+// Vector Relational Functions

+// 

+// Relational and equality operators (<, <=, >, >=, ==, !=) are defined (or reserved) to produce

+// scalar Boolean results.

+// 

+

+// 

+// Returns the component-wise compare of x < y.

+// 

+

+bvec2 lessThan (vec2 x, vec2 y) {

+    return bvec2 (x.x < y.x, x.y < y.y);

+}

+bvec3 lessThan (vec3 x, vec3 y) {

+    return bvec3 (x.x < y.x, x.y < y.y, x.z < y.z);

+}

+bvec4 lessThan (vec4 x, vec4 y) {

+    return bvec4 (x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);

+}

+bvec2 lessThan (ivec2 x, ivec2 y) {

+    return bvec2 (x.x < y.x, x.y < y.y);

+}

+bvec3 lessThan (ivec3 x, ivec3 y) {

+    return bvec3 (x.x < y.x, x.y < y.y, x.z < y.z);

+}

+bvec4 lessThan (ivec4 x, ivec4 y) {

+    return bvec4 (x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);

+}

+

+// 

+// Returns the component-wise compare of x <= y.

+// 

+

+bvec2 lessThanEqual (vec2 x, vec2 y) {

+    return bvec2 (x.x <= y.x, x.y <= y.y);

+}

+bvec3 lessThanEqual (vec3 x, vec3 y) {

+    return bvec3 (x.x <= y.x, x.y <= y.y, x.z <= y.z);

+}

+bvec4 lessThanEqual (vec4 x, vec4 y) {

+    return bvec4 (x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);

+}

+bvec2 lessThanEqual (ivec2 x, ivec2 y) {

+    return bvec2 (x.x <= y.x, x.y <= y.y);

+}

+bvec3 lessThanEqual (ivec3 x, ivec3 y) {

+    return bvec3 (x.x <= y.x, x.y <= y.y, x.z <= y.z);

+}

+bvec4 lessThanEqual (ivec4 x, ivec4 y) {

+    return bvec4 (x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);

+}

+

+// 

+// Returns the component-wise compare of x > y.

+// 

+

+bvec2 greaterThan (vec2 x, vec2 y) {

+    return bvec2 (x.x > y.x, x.y > y.y);

+}

+bvec3 greaterThan (vec3 x, vec3 y) {

+    return bvec3 (x.x > y.x, x.y > y.y, x.z > y.z);

+}

+bvec4 greaterThan (vec4 x, vec4 y) {

+    return bvec4 (x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);

+}

+bvec2 greaterThan (ivec2 x, ivec2 y) {

+    return bvec2 (x.x > y.x, x.y > y.y);

+}

+bvec3 greaterThan (ivec3 x, ivec3 y) {

+    return bvec3 (x.x > y.x, x.y > y.y, x.z > y.z);

+}

+bvec4 greaterThan (ivec4 x, ivec4 y) {

+    return bvec4 (x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);

+}

+

+// 

+// Returns the component-wise compare of x >= y.

+// 

+

+bvec2 greaterThanEqual (vec2 x, vec2 y) {

+    return bvec2 (x.x >= y.x, x.y >= y.y);

+}

+bvec3 greaterThanEqual (vec3 x, vec3 y) {

+    return bvec3 (x.x >= y.x, x.y >= y.y, x.z >= y.z);

+}

+bvec4 greaterThanEqual (vec4 x, vec4 y) {

+    return bvec4 (x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);

+}

+bvec2 greaterThanEqual (ivec2 x, ivec2 y) {

+    return bvec2 (x.x >= y.x, x.y >= y.y);

+}

+bvec3 greaterThanEqual (ivec3 x, ivec3 y) {

+    return bvec3 (x.x >= y.x, x.y >= y.y, x.z >= y.z);

+}

+bvec4 greaterThanEqual (ivec4 x, ivec4 y) {

+    return bvec4 (x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);

+}

+

+// 

+// Returns the component-wise compare of x == y.

+// 

+

+bvec2 equal (vec2 x, vec2 y) {

+    return bvec2 (x.x == y.x, x.y == y.y);

+}

+bvec3 equal (vec3 x, vec3 y) {

+    return bvec3 (x.x == y.x, x.y == y.y, x.z == y.z);

+}

+bvec4 equal (vec4 x, vec4 y) {

+    return bvec4 (x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);

+}

+bvec2 equal (ivec2 x, ivec2 y) {

+    return bvec2 (x.x == y.x, x.y == y.y);

+}

+bvec3 equal (ivec3 x, ivec3 y) {

+    return bvec3 (x.x == y.x, x.y == y.y, x.z == y.z);

+}

+bvec4 equal (ivec4 x, ivec4 y) {

+    return bvec4 (x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);

+}

+

+// 

+// Returns the component-wise compare of x != y.

+// 

+

+bvec2 notEqual (vec2 x, vec2 y) {

+    return bvec2 (x.x != y.x, x.y != y.y);

+}

+bvec3 notEqual (vec3 x, vec3 y) {

+    return bvec3 (x.x != y.x, x.y != y.y, x.z != y.z);

+}

+bvec4 notEqual (vec4 x, vec4 y) {

+    return (bvec4 (x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);

+}

+bvec2 notEqual (ivec2 x, ivec2 y) {

+    return (bvec2 (x.x != y.x, x.y != y.y);

+}

+bvec3 notEqual (ivec3 x, ivec3 y) {

+    return (bvec3 (x.x != y.x, x.y != y.y, x.z != y.z);

+}

+bvec4 notEqual (ivec4 x, ivec4 y) {

+    return (bvec4 (x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);

+}

+

+// 

+// Returns true if any component of x is true.

+// 

+

+bool any (bvec2 x) {

+    return x.x || x.y;

+}

+bool any (bvec3 x) {

+    return x.x || x.y || x.z;

+}

+bool any (bvec4 x) {

+    return x.x || x.y || x.z || x.w;

+}

+

+// 

+// Returns true only if all components of x are true.

+// 

+

+bool all (bvec2 x) {

+    return x.x && x.y;

+}

+bool all (bvec3 x) {

+    return x.x && x.y && x.z;

+}

+bool all (bvec4 x) {

+    return x.x && x.y && x.z && x.w;

+}

+

+// 

+// Returns the component-wise logical complement of x.

+// 

+

+bvec2 not (bvec2 x) {

+    return bvec2 (!x.x, !x.y);

+}

+bvec3 not (bvec3 x) {

+    return bvec3 (!x.x, !x.y, !x.z);

+}

+bvec4 not (bvec4 x) {

+    return bvec4 (!x.x, !x.y, !x.z, !x.w);

+}

+

+// 

+// Texture Lookup Functions

+// 

+// Texture lookup functions are available to both vertex and fragment shaders. However, level

+// of detail is not computed by fixed functionality for vertex shaders, so there are some

+// differences in operation between vertex and fragment texture lookups. The functions in the table

+// below provide access to textures through samplers, as set up through the OpenGL API. Texture

+// properties such as size, pixel format, number of dimensions, filtering method, number of mip-map

+// levels, depth comparison, and so on are also defined by OpenGL API calls. Such properties are

+// taken into account as the texture is accessed via the built-in functions defined below.

+// 

+// If a non-shadow texture call is made to a sampler whose texture has depth comparisons enabled,

+// then results are undefined. If a shadow texture call is made to a sampler whose texture does not

+// have depth comparisions enabled, the results are also undefined.

+// 

+// In all functions below, the bias parameter is optional for fragment shaders. The bias parameter

+// is not accepted in a vertex shader. For a fragment shader, if bias is present, it is added to

+// the calculated level of detail prior to performing the texture access operation. If the bias

+// parameter is not provided, then the implementation automatically selects level of detail:

+// For a texture that is not mip-mapped, the texture is used directly. If it is mip-mapped and

+// running in a fragment shader, the LOD computed by the implementation is used to do the texture

+// lookup. If it is mip-mapped and running on the vertex shader, then the base texture is used.

+// 

+// The built-ins suffixed with “Lod” are allowed only in a vertex shader. For the “Lod” functions,

+// lod is directly used as the level of detail.

+// 

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate coord.s is divided by

+// the last component of coord.

+// 

+// XXX

+vec4 texture1D (sampler1D sampler, float coord) {

+    return vec4 (0.0);

+}

+vec4 texture1DProj (sampler1D sampler, vec2 coord) {

+    return texture1D (sampler, coord.s / coord.t);

+}

+vec4 texture1DProj (sampler1D sampler, vec4 coord) {

+    return texture1D (sampler, coord.s / coord.q);

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate (coord.s, coord.t) is

+// divided by the last component of coord. The third component of coord is ignored for the vec4

+// coord variant.

+// 

+// XXX

+vec4 texture2D (sampler2D sampler, vec2 coord) {

+    return vec4 (0.0);

+}

+vec4 texture2DProj (sampler2D sampler, vec3 coord) {

+    return texture2D (sampler, vec2 (coord.s / coord.p, coord.t / coord.p));

+}

+vec4 texture2DProj (sampler2D sampler, vec4 coord) {

+    return texture2D (sampler, vec2 (coord.s / coord.q, coord.t / coord.q));

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate is divided by coord.q.

+// 

+// XXX

+vec4 texture3D (sampler3D sampler, vec3 coord) {

+    return vec4 (0.0);

+}

+vec4 texture3DProj (sampler3D sampler, vec4 coord) {

+    return texture3D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q));

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound

+// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture

+// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification.

+// 

+// XXX

+vec4 textureCube (samplerCube sampler, vec3 coord) {

+    return vec4 (0.0);

+}

+

+// 

+// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound

+// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd

+// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a

+// depth texture, or results are undefined. For the projective (“Proj”) version of each built-in,

+// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The

+// second component of coord is ignored for the “1D” variants.

+// 

+// XXX

+vec4 shadow1D (sampler1DShadow sampler, vec3 coord) {

+    return vec4 (0.0);

+}

+// XXX

+vec4 shadow2D (sampler2DShadow sampler, vec3 coord) {

+    return vec4 (0.0);

+}

+vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord) {

+    return shadow1D (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q));

+}

+vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord) {

+    return shadow2D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q));

+}

+

+// 

+// Noise Functions

+// 

+// Noise functions are available to both fragment and vertex shaders. They are stochastic functions

+// that can be used to increase visual complexity. Values returned by the following noise functions

+// give the appearance of randomness, but are not truly random. The noise functions below are

+// defined to have the following characteristics:

+// 

+// • The return value(s) are always in the range [-1,1]

+// • The return value(s) have an overall average of 0.0

+// • They are repeatable, in that a particular input value will always produce the same return value

+// • They are statistically invariant under rotation (i.e., no matter how the domain is rotated, it

+//   has the same statistical character)

+// • They have a statistical invariance under translation (i.e., no matter how the domain is

+//   translated, it has the same statistical character)

+// • They typically give different results under translation.

+// • They have a narrow bandpass limit in frequency (i.e., it has no visible features larger or

+//   smaller than a certain narrow size range)

+// 

+

+// 

+// Returns a 1D noise value based on the input value x.

+// 

+// XXX

+float noise1 (float x) {

+    return 0.0;

+}

+// XXX

+float noise1 (vec2 x) {

+    return 0.0;

+}

+// XXX

+float noise1 (vec3 x) {

+    return 0.0;

+}

+// XXX

+float noise1 (vec4 x) {

+    return 0.0;

+}

+

+// 

+// Returns a 2D noise value based on the input value x.

+// 

+// XXX

+vec2 noise2 (float x) {

+    return vec2 (0.0);

+}

+// XXX

+vec2 noise2 (vec2 x) {

+    return vec2 (0.0);

+}

+// XXX

+vec2 noise2 (vec3 x) {

+    return vec2 (0.0);

+}

+// XXX

+vec2 noise2 (vec4 x) {

+    return vec2 (0.0);

+}

+

+// 

+// Returns a 3D noise value based on the input value x.

+// 

+// XXX

+vec3 noise3 (float x) {

+    return vec3 (0.0);

+}

+// XXX

+vec3 noise3 (vec2 x) {

+    return vec3 (0.0);

+}

+// XXX

+vec3 noise3 (vec3 x) {

+    return vec3 (0.0);

+}

+// XXX

+vec3 noise3 (vec4 x) {

+    return vec3 (0.0);

+}

+

+// 

+// Returns a 4D noise value based on the input value x.

+// 

+// XXX

+vec4 noise4 (float x) {

+    return vec4 (0.0);

+}

+// XXX

+vec4 noise4 (vec2 x) {

+    return vec4 (0.0);

+}

+// XXX

+vec4 noise4 (vec3 x) {

+    return vec4 (0.0);

+}

+// XXX

+vec4 noise4 (vec4 x) {

+    return vec4 (0.0);

+}

+

diff --git a/src/mesa/shader/slang_fragment_builtin.gc b/src/mesa/shader/slang_fragment_builtin.gc
new file mode 100755
index 0000000000..6ccf0e7c0f
--- /dev/null
+++ b/src/mesa/shader/slang_fragment_builtin.gc
@@ -0,0 +1,354 @@
+

+// 

+// TODO:

+// - implement texture1D, texture2D, texture3D, textureCube,

+// - implement shadow1D, shadow2D,

+// - implement dFdx, dFdy,

+// 

+

+// 

+// From Shader Spec, ver. 1.051

+// 

+// The output of the fragment shader goes on to be processed by the fixed function operations at

+// the back end of the OpenGL pipeline. Fragment shaders interface with the back end of the OpenGL

+// pipeline using the built-in variables gl_FragColor and gl_FragDepth, or by executing the discard

+// keyword.

+// 

+// These variables may be written more than once within a fragment shader. If so, the last value

+// assigned is the one used in the subsequent fixed function pipeline. The values written to these

+// variables may be read back after writing them. Reading from these variables before writing them

+// results in an undefined value. The fixed functionality computed depth for a fragment may be

+// obtained by reading gl_FragCoord.z, described below.

+// 

+// Writing to gl_FragColor specifies the fragment color that will be used by the subsequent fixed

+// functionality pipeline. If subsequent fixed functionality consumes fragment color and an

+// execution of a fragment shader does not write a value to gl_FragColor then the fragment color

+// consumed is undefined.

+// 

+// If the frame buffer is configured as a color index buffer then behavior is undefined when using

+// a fragment shader.

+// 

+// Writing to gl_FragDepth will establish the depth value for the fragment being processed. If

+// depth buffering is enabled, and a shader does not write gl_FragDepth, then the fixed function

+// value for depth will be used as the fragment’s depth value. If a shader statically assigns

+// a value to gl_FragDepth, and there is an execution path through the shader that does not set

+// gl_FragDepth, then the value of the fragment’s depth may be undefined for some executions of

+// the shader. That is, if a shader statically writes gl_FragDepth, then it is responsible for

+// always writing it. There is also no guarantee that a shader can compute the same depth value

+// as the fixed function value; an implementation will provide invariant results within shaders

+// computing depth with the same source-level expression, but invariance is not provided between

+// shaders and fixed functionality.

+// 

+// Writes to gl_FragColor and gl_FragDepth need not be clamped within a shader. The fixed

+// functionality pipeline following the fragment shader will clamp these values.

+// 

+// If a shader executes the discard keyword, the fragment is discarded, and the values of

+// gl_FragDepth and gl_FragColor become irrelevant.

+// 

+// The variable gl_FragCoord is available as a read-only variable from within fragment shaders

+// and it holds the window relative coordinates x, y, z, and 1/w values for the fragment. This

+// value is the result of the fixed functionality that interpolates primitives after vertex

+// processing to generate fragments. The z component is the depth value that would be used for

+// the fragment’s depth if a shader contained no writes to gl_FragDepth. This is useful for

+// invariance if a shader conditionally computes gl_FragDepth but otherwise wants the fixed

+// functionality fragment depth.

+// 

+// The fragment shader has access to the read-only built-in variable gl_FrontFacing whose value

+// is true if the fragment belongs to a front-facing primitive. One use of this is to emulate

+// two-sided lighting by selecting one of two colors calculated by the vertex shader.

+// 

+// The built-in variables that are accessible from a fragment shader are intrinsically given types

+// as follows:

+// 

+

+vec4 gl_FragCoord;

+bool gl_FrontFacing;

+vec4 gl_FragColor;

+float gl_FragDepth;

+

+// 

+// However, they do not behave like variables with no qualifier; their behavior is as described

+// above. These built-in variables have global scope.

+// 

+

+// 

+// Unlike user-defined varying variables, the built-in varying variables don’t have a strict

+// one-to-one correspondence between the vertex language and the fragment language. Two sets are

+// provided, one for each language. Their relationship is described below.

+// 

+// The following varying variables are available to read from in a fragment shader. The gl_Color

+// and gl_SecondaryColor names are the same names as attributes passed to the vertex shader.

+// However, there is no name conflict, because attributes are visible only in vertex shaders

+// and the following are only visible in a fragment shader.

+// 

+

+varying vec4 gl_Color;

+varying vec4 gl_SecondaryColor;

+varying vec4 gl_TexCoord[];                             // at most will be gl_MaxTextureCoordsARB

+varying float gl_FogFragCoord;

+

+// 

+// The values in gl_Color and gl_SecondaryColor will be derived automatically by the system from

+// gl_FrontColor, gl_BackColor, gl_FrontSecondaryColor, and gl_BackSecondaryColor based on which

+// face is visible. If fixed functionality is used for vertex processing, then gl_FogFragCoord will

+// either be the z-coordinate of the fragment in eye space, or the interpolation of the fog

+// coordinate, as described in section 3.10 of the OpenGL 1.4 Specification. The gl_TexCoord[]

+// values are the interpolated gl_TexCoord[] values from a vertex shader or the texture coordinates

+// of any fixed pipeline based vertex functionality.

+// 

+// Indices to the fragment shader gl_TexCoord array are as described above in the vertex shader

+// text.

+// 

+

+// 

+// The OpenGL Shading Language defines an assortment of built-in convenience functions for scalar

+// and vector operations. Many of these built-in functions can be used in more than one type

+// of shader, but some are intended to provide a direct mapping to hardware and so are available

+// only for a specific type of shader.

+// 

+// The built-in functions basically fall into three categories:

+// 

+// • They expose some necessary hardware functionality in a convenient way such as accessing

+//   a texture map. There is no way in the language for these functions to be emulated by a shader.

+// 

+// • They represent a trivial operation (clamp, mix, etc.) that is very simple for the user

+//   to write, but they are very common and may have direct hardware support. It is a very hard

+//   problem for the compiler to map expressions to complex assembler instructions.

+// 

+// • They represent an operation graphics hardware is likely to accelerate at some point. The

+//   trigonometry functions fall into this category.

+// 

+// Many of the functions are similar to the same named ones in common C libraries, but they support

+// vector input as well as the more traditional scalar input.

+// 

+// Applications should be encouraged to use the built-in functions rather than do the equivalent

+// computations in their own shader code since the built-in functions are assumed to be optimal

+// (e.g., perhaps supported directly in hardware).

+// 

+// User code can replace built-in functions with their own if they choose, by simply re-declaring

+// and defining the same name and argument list.

+// 

+

+// 

+// Texture Lookup Functions

+// 

+// Texture lookup functions are available to both vertex and fragment shaders. However, level

+// of detail is not computed by fixed functionality for vertex shaders, so there are some

+// differences in operation between vertex and fragment texture lookups. The functions in the table

+// below provide access to textures through samplers, as set up through the OpenGL API. Texture

+// properties such as size, pixel format, number of dimensions, filtering method, number of mip-map

+// levels, depth comparison, and so on are also defined by OpenGL API calls. Such properties are

+// taken into account as the texture is accessed via the built-in functions defined below.

+// 

+// If a non-shadow texture call is made to a sampler whose texture has depth comparisons enabled,

+// then results are undefined. If a shadow texture call is made to a sampler whose texture does not

+// have depth comparisions enabled, the results are also undefined.

+// 

+// In all functions below, the bias parameter is optional for fragment shaders. The bias parameter

+// is not accepted in a vertex shader. For a fragment shader, if bias is present, it is added to

+// the calculated level of detail prior to performing the texture access operation. If the bias

+// parameter is not provided, then the implementation automatically selects level of detail:

+// For a texture that is not mip-mapped, the texture is used directly. If it is mip-mapped and

+// running in a fragment shader, the LOD computed by the implementation is used to do the texture

+// lookup. If it is mip-mapped and running on the vertex shader, then the base texture is used.

+// 

+// The built-ins suffixed with “Lod” are allowed only in a vertex shader. For the “Lod” functions,

+// lod is directly used as the level of detail.

+// 

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate coord.s is divided by

+// the last component of coord.

+// 

+// XXX

+vec4 texture1D (sampler1D sampler, float coord, float bias) {

+    return vec4 (0.0);

+}

+vec4 texture1DProj (sampler1D sampler, vec2 coord, float bias) {

+    return texture1D (sampler, coord.s / coord.t, bias);

+}

+vec4 texture1DProj (sampler1D sampler, vec4 coord, float bias) {

+    return texture1D (sampler, coord.s / coord.q, bias);

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate (coord.s, coord.t) is

+// divided by the last component of coord. The third component of coord is ignored for the vec4

+// coord variant.

+// 

+// XXX

+vec4 texture2D (sampler2D sampler, vec2 coord, float bias) {

+    return vec4 (0.0);

+}

+vec4 texture2DProj (sampler2D sampler, vec3 coord, float bias) {

+    return texture2D (sampler, vec2 (coord.s / coord.p, coord.t / coord.p), bias);

+}

+vec4 texture2DProj (sampler2D sampler, vec4 coord, float bias) {

+    return texture2D (sampler, vec2 (coord.s / coord.q, coord.s / coord.q), bias);

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate is divided by coord.q.

+// 

+// XXX

+vec4 texture3D (sampler3D sampler, vec3 coord, float bias) {

+    return vec4 (0.0);

+}   

+vec4 texture3DProj (sampler3D sampler, vec4 coord, float bias) {

+    return texture3DProj (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q),

+        bias);

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound

+// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture

+// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification.

+// 

+// XXX

+vec4 textureCube (samplerCube sampler, vec3 coord, float bias) {

+    return vec4 (0.0);

+}

+

+// 

+// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound

+// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd

+// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a

+// depth texture, or results are undefined. For the projective (“Proj”) version of each built-in,

+// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The

+// second component of coord is ignored for the “1D” variants.

+// 

+// XXX

+vec4 shadow1D (sampler1DShadow sampler, vec3 coord, float bias) {

+    return vec4 (0.0);

+}

+// XXX

+vec4 shadow2D (sampler2DShadow sampler, vec3 coord, float bias) {

+    return vec4 (0.0);

+}

+vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord, float bias) {

+    return shadow1D (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q), bias);

+}

+vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord, float bias) {

+    return shadow2D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q), bias);

+}

+

+// 

+// Fragment processing functions are only available in shaders intended for use on the fragment

+// processor. Derivatives may be computationally expensive and/or numerically unstable. Therefore,

+// an OpenGL implementation may approximate the true derivatives by using a fast but not entirely

+// accurate derivative computation.

+// 

+// The expected behavior of a derivative is specified using forward/backward differencing.

+// 

+// Forward differencing:

+// 

+// F(x+dx) - F(x) ~ dFdx(x) * dx            1a

+// dFdx(x) ~ (F(x+dx) - F(x)) / dx          1b

+// 

+// Backward differencing:

+// 

+// F(x-dx) - F(x) ~ -dFdx(x) * dx           2a

+// dFdx(x) ~ (F(x) - F(x-dx)) / dx          2b

+// 

+// With single-sample rasterization, dx <= 1.0 in equations 1b and 2b. For multi-sample

+// rasterization, dx < 2.0 in equations 1b and 2b.

+// 

+// dFdy is approximated similarly, with y replacing x.

+// 

+// A GL implementation may use the above or other methods to perform the calculation, subject

+// to the following conditions:

+// 

+// 1) The method may use piecewise linear approximations. Such linear approximations imply that

+//    higher order derivatives, dFdx(dFdx(x)) and above, are undefined.

+// 

+// 2) The method may assume that the function evaluated is continuous. Therefore derivatives within

+//    the body of a non-uniform conditional are undefined.

+// 

+// 3) The method may differ per fragment, subject to the constraint that the method may vary by

+//    window coordinates, not screen coordinates. The invariance requirement described in section

+//    3.1 of the OpenGL 1.4 specification is relaxed for derivative calculations, because

+//    the method may be a function of fragment location.

+// 

+// Other properties that are desirable, but not required, are:

+// 

+// 4) Functions should be evaluated within the interior of a primitive (interpolated, not

+//    extrapolated).

+// 

+// 5) Functions for dFdx should be evaluated while holding y constant. Functions for dFdy should

+//    be evaluated while holding x constant. However, mixed higher order derivatives, like

+//    dFdx(dFdy(y)) and dFdy(dFdx(x)) are undefined.

+// 

+// In some implementations, varying degrees of derivative accuracy may be obtained by providing

+// GL hints (section 5.6 of the OpenGL 1.4 specification), allowing a user to make an image

+// quality versus speed tradeoff.

+// 

+

+// 

+// Returns the derivative in x using local differencing for the input argument p.

+// 

+// XXX

+float dFdx (float p) {

+    return 0.0;

+}

+// XXX

+vec2 dFdx (vec2 p) {

+    return vec2 (0.0);

+}

+// XXX

+vec3 dFdx (vec3 p) {

+    return vec3 (0.0);

+}

+// XXX

+vec4 dFdx (vec4 p) {

+    return vec4 (0.0);

+}

+

+// 

+// Returns the derivative in y using local differencing for the input argument p.

+// 

+// These two functions are commonly used to estimate the filter width used to anti-alias procedural

+// textures.We are assuming that the expression is being evaluated in parallel on a SIMD array so

+// that at any given point in time the value of the function is known at the grid points

+// represented by the SIMD array. Local differencing between SIMD array elements can therefore

+// be used to derive dFdx, dFdy, etc.

+// 

+// XXX

+float dFdy (float p) {

+    return 0.0;

+}

+// XXX

+vec2 dFdy (vec2 p) {

+    return vec2 (0.0);

+}

+// XXX

+vec3 dFdy (vec3 p) {

+    return vec3 (0.0);

+}

+// XXX

+vec4 dFdy (vec4 p) {

+    return vec4 (0.0);

+}

+

+// 

+// Returns the sum of the absolute derivative in x and y using local differencing for the input

+// argument p, i.e.:

+// 

+// return = abs (dFdx (p)) + abs (dFdy (p));

+// 

+

+float fwidth (float p) {

+    return abs (dFdx (p)) + abs (dFdy (p));

+}

+vec2 fwidth (vec2 p) {

+    return abs (dFdx (p)) + abs (dFdy (p));

+}

+vec3 fwidth (vec3 p) {

+    return abs (dFdx (p)) + abs (dFdy (p));

+}

+vec4 fwidth (vec4 p) {

+    return abs (dFdx (p)) + abs (dFdy (p));

+}

+

diff --git a/src/mesa/shader/slang_vertex_builtin.gc b/src/mesa/shader/slang_vertex_builtin.gc
new file mode 100755
index 0000000000..ed89be9808
--- /dev/null
+++ b/src/mesa/shader/slang_vertex_builtin.gc
@@ -0,0 +1,260 @@
+

+// 

+// TODO:

+// - what to do with ftransform? can it stay in the current form?

+// - implement texture1DLod, texture2DLod, texture3DLod, textureCubeLod,

+// - implement shadow1DLod, shadow2DLod,

+// 

+

+// 

+// From Shader Spec, ver. 1.051

+// 

+// Some OpenGL operations still continue to occur in fixed functionality in between the vertex

+// processor and the fragment processor. Other OpenGL operations continue to occur in fixed

+// functionality after the fragment processor. Shaders communicate with the fixed functionality

+// of OpenGL through the use of built-in variables.

+// 

+// The variable gl_Position is available only in the vertex language and is intended for writing

+// the homogeneous vertex position. All executions of a well-formed vertex shader must write

+// a value into this variable. It can be written at any time during shader execution. It may also

+// be read back by the shader after being written. This value will be used by primitive assembly,

+// clipping, culling, and other fixed functionality operations that operate on primitives after

+// vertex processing has occurred. Compilers may generate a diagnostic message if they detect

+// gl_Position is not written, or read before being written, but not all such cases are detectable.

+// Results are undefined if a vertex shader is executed and does not write gl_Position.

+// 

+// The variable gl_PointSize is available only in the vertex language and is intended for a vertex

+// shader to write the size of the point to be rasterized. It is measured in pixels.

+// 

+// The variable gl_ClipVertex is available only in the vertex language and provides a place for

+// vertex shaders to write the coordinate to be used with the user clipping planes. The user must

+// ensure the clip vertex and user clipping planes are defined in the same coordinate space. User

+// clip planes work properly only under linear transform. It is undefined what happens under

+// non-linear transform.

+// 

+// These built-in vertex shader variables for communicating with fixed functionality are

+// intrinsically declared with the following types:

+// 

+

+vec4 gl_Position;                                       // must be written to

+float gl_PointSize;                                     // may be written to

+vec4 gl_ClipVertex;                                     // may be written to

+

+// 

+// If gl_PointSize or gl_ClipVertex are not written to, their values are undefined. Any of these

+// variables can be read back by the shader after writing to them, to retrieve what was written.

+// Reading them before writing them results in undefined behavior. If they are written more than

+// once, it is the last value written that is consumed by the subsequent operations.

+// 

+// These built-in variables have global scope.

+// 

+

+// 

+// The following attribute names are built into the OpenGL vertex language and can be used from

+// within a vertex shader to access the current values of attributes declared by OpenGL. All page

+// numbers and notations are references to the OpenGL 1.4 specification.

+// 

+

+// 

+// Vertex Attributes, p. 19.

+// 

+

+attribute vec4 gl_Color;

+attribute vec4 gl_SecondaryColor;

+attribute vec3 gl_Normal;

+attribute vec4 gl_Vertex;

+attribute vec4 gl_MultiTexCoord0;

+attribute vec4 gl_MultiTexCoord1;

+attribute vec4 gl_MultiTexCoord2;

+attribute vec4 gl_MultiTexCoord3;

+attribute vec4 gl_MultiTexCoord4;

+attribute vec4 gl_MultiTexCoord5;

+attribute vec4 gl_MultiTexCoord6;

+attribute vec4 gl_MultiTexCoord7;

+attribute float gl_FogCoord;

+

+// 

+// Unlike user-defined varying variables, the built-in varying variables don’t have a strict

+// one-to-one correspondence between the vertex language and the fragment language. Two sets are

+// provided, one for each language. Their relationship is described below.

+// 

+// The following built-in varying variables are available to write to in a vertex shader.

+// A particular one should be written to if any functionality in a corresponding fragment shader

+// or fixed pipeline uses it or state derived from it. Otherwise, behavior is undefined.

+//

+

+varying vec4 gl_FrontColor;

+varying vec4 gl_BackColor;

+varying vec4 gl_FrontSecondaryColor;

+varying vec4 gl_BackSecondaryColor;

+varying vec4 gl_TexCoord[];                             // at most will be gl_MaxTextureCoordsARB

+varying float gl_FogFragCoord;

+

+// 

+// For gl_FogFragCoord, the value written will be used as the “c” value on page 160 of the

+// OpenGL 1.4 Specification by the fixed functionality pipeline. For example, if the z-coordinate

+// of the fragment in eye space is desired as “c”, then that's what the vertex shader should write

+// into gl_FogFragCoord.

+// 

+// As with all arrays, indices used to subscript gl_TexCoord must either be integral constant

+// expressions, or this array must be re-declared by the shader with a size. The size can be

+// at most gl_MaxTextureCoordsARB. Using indexes close to 0 may aid the implementation

+// in preserving varying resources.

+// 

+

+// 

+// The OpenGL Shading Language defines an assortment of built-in convenience functions for scalar

+// and vector operations. Many of these built-in functions can be used in more than one type

+// of shader, but some are intended to provide a direct mapping to hardware and so are available

+// only for a specific type of shader.

+// 

+// The built-in functions basically fall into three categories:

+// 

+// • They expose some necessary hardware functionality in a convenient way such as accessing

+//   a texture map. There is no way in the language for these functions to be emulated by a shader.

+// 

+// • They represent a trivial operation (clamp, mix, etc.) that is very simple for the user

+//   to write, but they are very common and may have direct hardware support. It is a very hard

+//   problem for the compiler to map expressions to complex assembler instructions.

+// 

+// • They represent an operation graphics hardware is likely to accelerate at some point. The

+//   trigonometry functions fall into this category.

+// 

+// Many of the functions are similar to the same named ones in common C libraries, but they support

+// vector input as well as the more traditional scalar input.

+// 

+// Applications should be encouraged to use the built-in functions rather than do the equivalent

+// computations in their own shader code since the built-in functions are assumed to be optimal

+// (e.g., perhaps supported directly in hardware).

+// 

+// User code can replace built-in functions with their own if they choose, by simply re-declaring

+// and defining the same name and argument list.

+// 

+

+// 

+// Geometric Functions

+// 

+// These operate on vectors as vectors, not component-wise.

+// 

+

+// 

+// For vertex shaders only. This function will ensure that the incoming vertex value will be

+// transformed in a way that produces exactly the same result as would be produced by OpenGL’s

+// fixed functionality transform. It is intended to be used to compute gl_Position, e.g.,

+// gl_Position = ftransform()

+// This function should be used, for example, when an application is rendering the same geometry in

+// separate passes, and one pass uses the fixed functionality path to render and another pass uses

+// programmable shaders.

+// 

+

+vec4 ftransform () {

+    return gl_ModelViewProjectionMatrix * gl_Vertex;

+}

+

+// 

+// Texture Lookup Functions

+// 

+// Texture lookup functions are available to both vertex and fragment shaders. However, level

+// of detail is not computed by fixed functionality for vertex shaders, so there are some

+// differences in operation between vertex and fragment texture lookups. The functions in the table

+// below provide access to textures through samplers, as set up through the OpenGL API. Texture

+// properties such as size, pixel format, number of dimensions, filtering method, number of mip-map

+// levels, depth comparison, and so on are also defined by OpenGL API calls. Such properties are

+// taken into account as the texture is accessed via the built-in functions defined below.

+// 

+// If a non-shadow texture call is made to a sampler whose texture has depth comparisons enabled,

+// then results are undefined. If a shadow texture call is made to a sampler whose texture does not

+// have depth comparisions enabled, the results are also undefined.

+// 

+// In all functions below, the bias parameter is optional for fragment shaders. The bias parameter

+// is not accepted in a vertex shader. For a fragment shader, if bias is present, it is added to

+// the calculated level of detail prior to performing the texture access operation. If the bias

+// parameter is not provided, then the implementation automatically selects level of detail:

+// For a texture that is not mip-mapped, the texture is used directly. If it is mip-mapped and

+// running in a fragment shader, the LOD computed by the implementation is used to do the texture

+// lookup. If it is mip-mapped and running on the vertex shader, then the base texture is used.

+// 

+// The built-ins suffixed with “Lod” are allowed only in a vertex shader. For the “Lod” functions,

+// lod is directly used as the level of detail.

+// 

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate coord.s is divided by

+// the last component of coord.

+// 

+// XXX

+vec4 texture1DLod (sampler1D sampler, float coord, float lod) {

+    return vec4 (0.0);

+}

+vec4 texture1DProjLod (sampler1D sampler, vec2 coord, float lod) {

+    return texture1DLod (sampler, coord.s / coord.t, lod);

+}

+vec4 texture1DProjLod (sampler1D sampler, vec4 coord, float lod) {

+    return texture1DLod (sampler, coord.s / coord.q, lod);

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate (coord.s, coord.t) is

+// divided by the last component of coord. The third component of coord is ignored for the vec4

+// coord variant.

+// 

+// XXX

+vec4 texture2DLod (sampler2D sampler, vec2 coord, float lod) {

+    return vec4 (0.0);

+}

+vec4 texture2DProjLod (sampler2D sampler, vec3 coord, float lod) {

+    return texture2DLod (sampler, vec2 (coord.s / coord.p, coord.t / coord.p), lod);

+}

+vec4 texture2DProjLod (sampler2D sampler, vec4 coord, float lod) {

+    return texture2DLod (sampler, vec2 (coord.s / coord.q, coord.t / coord.q), lod);

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound

+// to sampler. For the projective (“Proj”) versions, the texture coordinate is divided by coord.q.

+// 

+// XXX

+vec4 texture3DLod (sampler3D sampler, vec3 coord, float lod) {

+    return vec4 (0.0);

+}

+vec4 texture3DProjLod (sampler3D sampler, vec4 coord, float lod) {

+    return texture3DLod (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.s / coord.q),

+        lod);

+}

+

+// 

+// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound

+// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture

+// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification.

+// 

+// XXX

+vec4 textureCubeLod (samplerCube sampler, vec3 coord, float lod) {

+    return vec4 (0.0);

+}

+

+// 

+// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound

+// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd

+// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a

+// depth texture, or results are undefined. For the projective (“Proj”) version of each built-in,

+// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The

+// second component of coord is ignored for the “1D” variants.

+// 

+// XXX

+vec4 shadow1DLod (sampler1DShadow sampler, vec3 coord, float lod) {

+    return vec4 (0.0);

+}

+// XXX

+vec4 shadow2DLod (sampler2DShadow sampler, vec3 coord, float lod) {

+    return vec4 (0.0);

+}

+vec4 shadow1DProjLod(sampler1DShadow sampler, vec4 coord, float lod) {

+    return shadow1DLod (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q), lod);

+}

+vec4 shadow2DProjLod(sampler2DShadow sampler, vec4 coord, float lod) {

+    return shadow2DLod (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q),

+        lod);

+}

+