--- /dev/null
+
+//
+// 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.10, rev. 59
+//
+// 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.3
+const int gl_MaxTextureCoords = 2; // ARB_fragment_program
+const int gl_MaxVertexAttribs = 16; // ARB_vertex_shader
+const int gl_MaxVertexUniformComponents = 512; // ARB_vertex_shader
+const int gl_MaxVaryingFloats = 32; // ARB_vertex_shader
+const int gl_MaxVertexTextureImageUnits = 0; // ARB_vertex_shader
+const int gl_MaxCombinedTextureImageUnits = 2; // ARB_vertex_shader
+const int gl_MaxTextureImageUnits = 2; // ARB_fragment_shader
+const int gl_MaxFragmentUniformComponents = 64; // ARB_fragment_shader
+const int gl_MaxDrawBuffers = 1; // proposed ARB_draw_buffers
+
+//
+// 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 mat4 gl_TextureMatrix[gl_MaxTextureCoords];
+
+//
+// Derived matrix state that provides inverse and transposed versions
+// of the matrices above. Poorly conditioned matrices may result
+// in unpredictable values in their inverse forms.
+//
+uniform mat3 gl_NormalMatrix; // transpose of the inverse of the
+ // upper leftmost 3x3 of gl_ModelViewMatrix
+
+uniform mat4 gl_ModelViewMatrixInverse;
+uniform mat4 gl_ProjectionMatrixInverse;
+uniform mat4 gl_ModelViewProjectionMatrixInverse;
+uniform mat4 gl_TextureMatrixInverse[gl_MaxTextureCoords];
+
+uniform mat4 gl_ModelViewMatrixTranspose;
+uniform mat4 gl_ProjectionMatrixTranspose;
+uniform mat4 gl_ModelViewProjectionMatrixTranspose;
+uniform mat4 gl_TextureMatrixTranspose[gl_MaxTextureCoords];
+
+uniform mat4 gl_ModelViewMatrixInverseTranspose;
+uniform mat4 gl_ProjectionMatrixInverseTranspose;
+uniform mat4 gl_ModelViewProjectionMatrixInverseTranspose;
+uniform mat4 gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];
+
+//
+// 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];
+
+//
+// Texture Environment and Generation, p. 152, p. 40-42.
+//
+
+uniform vec4 gl_TextureEnvColor[gl_MaxTextureImageUnits];
+uniform vec4 gl_EyePlaneS[gl_MaxTextureCoords];
+uniform vec4 gl_EyePlaneT[gl_MaxTextureCoords];
+uniform vec4 gl_EyePlaneR[gl_MaxTextureCoords];
+uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoords];
+uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoords];
+uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoords];
+uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoords];
+uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoords];
+
+//
+// Fog p. 161
+//
+
+struct gl_FogParameters {
+ vec4 color;
+ float density;
+ float start;
+ float end;
+ float scale; // Derived: 1.0 / (end - start)
+};
+
+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:
+//
+// \95 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.
+//
+// \95 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.
+//
+// \95 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.
+//
+
+//
+// 8.1 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. The description is per component.
+//
+
+//
+// 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
+// [\96PI/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 [\96PI, 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 [\96PI/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));
+}
+
+//
+// 8.2 Exponential Functions
+//
+// These all operate component-wise. The description is per component.
+//
+
+//
+// Returns x raised to the y power, i.e., x^y.
+// Results are undefined if x < 0.
+// Results are undefined if x = 0 and y <= 0.
+//
+// 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 the natural exponentiation of x, i.e., e^x.
+//
+
+float exp (float x) {
+ return pow (2.71828183, x);
+}
+vec2 exp (vec2 x) {
+ return vec2 (exp (x.x), exp (x.y));
+}
+vec3 exp (vec3 x) {
+ return vec3 (exp (x.x), exp (x.y), exp (x.z));
+}
+vec4 exp (vec4 x) {
+ return vec4 (exp (x.x), exp (x.y), exp (x.z), exp (x.w));
+}
+
+//
+// Returns the natural logarithm of x, i.e., returns the value y which satisfies the equation
+// x = e^y.
+// Results are undefined if x <= 0.
+//
+
+float log (float x) {
+ return log2 (x) / log2 (2.71828183);
+}
+vec2 log (vec2 x) {
+ return vec2 (log (x.x), log (x.y));
+}
+vec3 log (vec3 x) {
+ return vec3 (log (x.x), log (x.y), log (x.z));
+}
+vec4 log (vec4 x) {
+ return vec4 (log (x.x), log (x.y), log (x.z), log (x.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 logarithm of x, i.e., returns the value y which satisfies the equation
+// x = 2^y.
+// Results are undefined if x <= 0.
+//
+// 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.
+// Results are undefined if x < 0.
+//
+
+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.
+// Results are undefined if x <= 0.
+//
+
+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));
+}
+
+//
+// 8.3 Common Functions
+//
+// These all operate component-wise. The description is per component.
+//
+
+//
+// Returns x if x >= 0, otherwise it returns \96x
+//
+
+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 \961.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 \96 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 \96 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 \96 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 \96 edge0) / (edge1 \96 edge0), 0, 1);
+// return t * t * (3 \96 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));
+}
+
+//
+// 8.4 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 \96 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 \96N
+//
+
+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 must already 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;
+}
+
+//
+// For the incident vector I and surface normal N, and the ratio of inidices of refraction eta,
+// return the refraction vector. The returned result is computed by
+//
+// k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I))
+// if (k < 0.0)
+// result = genType (0.0)
+// else
+// result = eta * I - (eta * dot (N, I) + sqrt (k)) * N
+//
+// The input parameters for the incident vector I and the surface normal N must already be
+// normalized to get the desired results.
+//
+
+float refract (float I, float N, float eta) {
+ const float 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;
+}
+vec2 refract (vec2 I, vec2 N, float eta) {
+ const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
+ if (k < 0.0)
+ return vec2 (0.0);
+ return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
+}
+vec3 refract (vec3 I, vec3 N, float eta) {
+ const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
+ if (k < 0.0)
+ return vec3 (0.0);
+ return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
+}
+vec4 refract (vec4 I, vec4 N, float eta) {
+ const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
+ if (k < 0.0)
+ return vec4 (0.0);
+ return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
+}
+
+//
+// 8.5 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
+ );
+}
+
+//
+// 8.6 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);
+}
+
+//
+// 8.7 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 that represents a depth texture with depth
+// comparisons turned on, then results are undefined. If a shadow texture call is made to a sampler
+// that represents a depth texture with depth comparisions turned off, the results are undefined.
+// If a shadow texture call is made to a sampler that does not represent a depth texture, then
+// results are 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 \93Lod\94 are allowed only in a vertex shader. For the \93Lod\94 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 \931D\94 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));
+}
+
+//
+// 8.9 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], and cover at least the range [-0.6, 0.6],
+// with a gaussian-like distribution.
+// \95 The return value(s) have an overall average of 0.0
+// \95 They are repeatable, in that a particular input value will always produce the same return value
+// \95 They are statistically invariant under rotation (i.e., no matter how the domain is rotated, it
+// has the same statistical character)
+// \95 They have a statistical invariance under translation (i.e., no matter how the domain is
+// translated, it has the same statistical character)
+// \95 They typically give different results under translation.
+// - The spatial frequency is narrowly concentrated, centered somewhere between 0.5 to 1.0.
+//
+
+//
+// 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);
+}
+
--- /dev/null
+
+//
+// This file defines nearly all constructors and operators for built-in data types, using
+// extended language syntax. In general, compiler treats constructors and operators as
+// ordinary functions with some exceptions. For example, the language does not allow
+// functions to be called in constant expressions - here the exception is made to allow it.
+//
+// Each implementation provides its own version of this file. Each implementation can define
+// the required set of operators and constructors in its own fashion.
+//
+// The extended language syntax is only present when compiling this file. It is implicitly
+// included at the very beginning of the compiled shader, so no built-in functions can be
+// used.
+//
+// To communicate with the implementation, a special extended "__asm" keyword is used, followed
+// by an instruction name (any valid identifier), a destination variable identifier and a
+// a list of zero or more source variable identifiers. A variable identifier is a variable name
+// declared earlier in the code (as a function parameter, local or global variable).
+// An instruction name designates an instruction that must be exported by the implementation.
+// Each instruction receives data from destination and source variable identifiers and returns
+// data in the destination variable identifier.
+//
+// It is up to the implementation how to define a particular operator or constructor. If it is
+// expected to being used rarely, it can be defined in terms of other operators and constructors,
+// for example:
+//
+// ivec2 __operator + (const ivec2 x, const ivec2 y) {
+// return ivec2 (x[0] + y[0], x[1] + y[1]);
+// }
+//
+// If a particular operator or constructor is expected to be used very often or is an atomic
+// operation (that is, an operation that cannot be expressed in terms of other operations or
+// would create a dependency cycle) it must be defined using one or more __asm constructs.
+//
+// Each implementation must define constructors for all scalar types (bool, float, int).
+// There are 9 scalar-to-scalar constructors (including identity constructors). However,
+// since the language introduces special constructors (like matrix constructor with a single
+// scalar value), implementations must also implement these cases.
+// The compiler provides the following algorithm when resolving a constructor:
+// - try to find a constructor with a prototype matching ours,
+// - if no constructor is found and this is a scalar-to-scalar constructor, raise an error,
+// - if a constructor is found, execute it and return,
+// - count the size of the constructor parameter list - if it is less than the size of
+// our constructor's type, raise an error,
+// - for each parameter in the list do a recursive constructor matching for appropriate
+// scalar fields in the constructed variable,
+//
+// Each implementation must also define a set of operators that deal with built-in data types.
+// There are four kinds of operators:
+// 1) Operators that are implemented only by the compiler: "()" (function call), "," (sequence)
+// and "?:" (selection).
+// 2) Operators that are implemented by the compiler by expressing it in terms of other operators:
+// - "." (field selection) - translated to subscript access,
+// - "&&" (logical and) - translated to "<left_expr> ? <right_expr> : false",
+// - "||" (logical or) - translated to "<left_expr> ? true : <right_expr>",
+// 3) Operators that can be defined by the implementation and if the required prototype is not
+// found, standard behaviour is used:
+// - "==", "!=", "=" (equality, assignment) - compare or assign matching fields one-by-one;
+// note that at least operators for scalar data types must be defined by the implementation
+// to get it work,
+// 4) All other operators not mentioned above. If no required prototype is found, an error is
+// raised. An implementation must follow the language specification to provide all valid
+// operator prototypes.
+//
+
+//
+// From Shader Spec, ver. 1.10, rev. 59
+//
+
+//
+// 5.4.1 Conversion and Scalar Constructors
+//
+
+//
+// When constructors are used to convert a float to an int, the fractional part of the
+// floating-point value is dropped.
+//
+
+int __constructor (const float _f) {
+ int _i;
+ __asm float_to_int _i, _f;
+ return _i;
+}
+
+//
+// When a constructor is used to convert an int or a float to bool, 0 and 0.0 are converted to
+// false, and nonzero values are converted to true.
+//
+
+bool __constructor (const int _i) {
+ return _i != 0;
+}
+
+bool __constructor (const float _f) {
+ return _f != 0.0;
+}
+
+//
+// When a constructor is used to convert a bool to an int or float, false is converted to 0 or
+// 0.0, and true is converted to 1 or 1.0.
+//
+
+int __constructor (const bool _b) {
+ return _b ? 1 : 0;
+}
+
+float __constructor (const bool _b) {
+ return _b ? 1.0 : 0.0;
+}
+
+//
+// Int to float constructor.
+//
+
+float __constructor (const int _i) {
+ float _f;
+ __asm int_to_float _f, _i;
+ return _f;
+}
+
+//
+// Identity constructors, like float(float) are also legal, but of little use.
+//
+
+bool __constructor (const bool _b) {
+ return _b;
+}
+
+int __constructor (const int _i) {
+ return _i;
+}
+
+float __constructor (const float _f) {
+ return _f;
+}
+
+//
+// Scalar constructors with non-scalar parameters can be used to take the first element from
+// a non-scalar. For example, the constructor float(vec3) will select the first component of the
+// vec3 parameter.
+//
+
+// [These scalar conversions will be handled internally by the compiler.]
+
+//
+// 5.4.2 Vector and Matrix Constructors
+//
+// Constructors can be used to create vectors or matrices from a set of scalars, vectors,
+// or matrices. This includes the ability to shorten vectors.
+//
+
+//
+// If there is a single scalar parameter to a vector constructor, it is used to initialize all
+// components of the constructed vector to that scalar\92s value.
+//
+// If the basic type (bool, int, or float) of a parameter to a constructor does not match the basic
+// type of the object being constructed, the scalar construction rules (above) are used to convert
+// the parameters.
+//
+
+vec2 __constructor (const float _f) {
+ return vec2 (_f, _f);
+}
+
+vec2 __constructor (const int _i) {
+ return vec2 (_i, _i);
+}
+
+vec2 __constructor (const bool _b) {
+ return vec2 (_b, _b);
+}
+
+vec3 __constructor (const float _f) {
+ return vec3 (_f, _f, _f);
+}
+
+vec3 __constructor (const int _i) {
+ return vec3 (_i, _i, _i);
+}
+
+vec3 __constructor (const bool _b) {
+ return vec3 (_b, _b, _b);
+}
+
+vec4 __constructor (const float _f) {
+ return vec4 (_f, _f, _f, _f);
+}
+
+vec4 __constructor (const int _i) {
+ return vec4 (_i, _i, _i, _i);
+}
+
+vec4 __constructor (const bool _b) {
+ return vec4 (_b, _b, _b, _b);
+}
+
+ivec2 __constructor (const int _i) {
+ return ivec2 (_i, _i);
+}
+
+ivec2 __constructor (const float _f) {
+ return ivec2 (_f, _f);
+}
+
+ivec2 __constructor (const bool _b) {
+ return ivec2 (_b, _b);
+}
+
+ivec3 __constructor (const int _i) {
+ return ivec3 (_i, _i, _i);
+}
+
+ivec3 __constructor (const float _f) {
+ return ivec3 (_f, _f, _f);
+}
+
+ivec3 __constructor (const bool _b) {
+ return ivec3 (_b, _b, _b);
+}
+
+ivec4 __constructor (const int _i) {
+ return ivec4 (_i, _i, _i, _i);
+}
+
+ivec4 __constructor (const float _f) {
+ return ivec4 (_f, _f, _f, _f);
+}
+
+ivec4 __constructor (const bool _b) {
+ return ivec4 (_b, _b, _b, _b);
+}
+
+bvec2 __constructor (const bool _b) {
+ return bvec2 (_b, _b);
+}
+
+bvec2 __constructor (const float _f) {
+ return bvec2 (_f, _f);
+}
+
+bvec2 __constructor (const int _i) {
+ return bvec2 (_i, _i);
+}
+
+bvec3 __constructor (const bool _b) {
+ return bvec3 (_b, _b, _b);
+}
+
+bvec3 __constructor (const float _f) {
+ return bvec3 (_f, _f, _f);
+}
+
+bvec3 __constructor (const int _i) {
+ return bvec3 (_i, _i, _i);
+}
+
+bvec4 __constructor (const bool _b) {
+ return bvec4 (_b, _b, _b, _b);
+}
+
+bvec4 __constructor (const float _f) {
+ return bvec4 (_f, _f, _f, _f);
+}
+
+bvec4 __constructor (const int _i) {
+ return bvec4 (_i, _i, _i, _i);
+}
+
+//
+// If there is a single scalar parameter to a matrix constructor, it is used to initialize all the
+// components on the matrix\92s diagonal, with the remaining components initialized to 0.0.
+// (...) Matrices will be constructed in column major order. It is an error to construct matrices
+// from other matrices. This is reserved for future use.
+//
+// If the basic type (bool, int, or float) of a parameter to a constructor does not match the basic
+// type of the object being constructed, the scalar construction rules (above) are used to convert
+// the parameters.
+//
+
+mat2 __constructor (const float _f) {
+ return mat2 (
+ _f, .0,
+ .0, _f
+ );
+}
+
+mat2 __constructor (const int _i) {
+ return mat2 (
+ _i, .0,
+ .0, _i
+ );
+}
+
+mat2 __constructor (const bool _b) {
+ return mat2 (
+ _b, .0,
+ .0, _b
+ );
+}
+
+mat3 __constructor (const float _f) {
+ return mat3 (
+ _f, .0, .0,
+ .0, _f, .0,
+ .0, .0, _f
+ );
+}
+
+mat3 __constructor (const int _i) {
+ return mat3 (
+ _i, .0, .0,
+ .0, _i, .0,
+ .0, .0, _i
+ );
+}
+
+mat3 __constructor (const bool _b) {
+ return mat3 (
+ _b, .0, .0,
+ .0, _b, .0,
+ .0, .0, _b
+ );
+}
+
+mat4 __constructor (const float _f) {
+ return mat4 (
+ _f, .0, .0, .0,
+ .0, _f, .0, .0,
+ .0, .0, _f, .0,
+ .0, .0, .0, _f
+ );
+}
+
+mat4 __constructor (const int _i) {
+ return mat4 (
+ _i, .0, .0, .0,
+ .0, _i, .0, .0,
+ .0, .0, _i, .0,
+ .0, .0, .0, _i
+ );
+}
+
+mat4 __constructor (const bool _b) {
+ return mat4 (
+ _b, .0, .0, .0,
+ .0, _b, .0, .0,
+ .0, .0, _b, .0,
+ .0, .0, .0, _b
+ );
+}
+
+//
+// 5.8 Assignments
+//
+// Assignments of values to variable names are done with the assignment operator ( = ), like
+//
+// lvalue = expression
+//
+// The assignment operator stores the value of expression into lvalue. It will compile only if
+// expression and lvalue have the same type. All desired type-conversions must be specified
+// explicitly via a constructor. Lvalues must be writable. Variables that are built-in types,
+// entire structures, structure fields, l-values with the field selector ( . ) applied to select
+// components or swizzles without repeated fields, and l-values dereferenced with the array
+// subscript operator ( [ ] ) are all possible l-values. Other binary or unary expressions,
+// non-dereferenced arrays, function names, swizzles with repeated fields, and constants cannot
+// be l-values.
+//
+// Expressions on the left of an assignment are evaluated before expressions on the right of the
+// assignment.
+//
+
+void __operator = (inout float a, const float b) {
+ __asm float_copy a, b;
+}
+
+void __operator = (inout int a, const int b) {
+ __asm int_copy a, b;
+}
+
+void __operator = (inout bool a, const bool b) {
+ __asm bool_copy a, b;
+}
+
+void __operator = (inout vec2 v, const vec2 u) {
+ v.x = u.x, v.y = u.y;
+}
+
+void __operator = (inout vec3 v, const vec3 u) {
+ v.x = u.x, v.y = u.y, v.z = u.z;
+}
+
+void __operator = (inout vec4 v, const vec4 u) {
+ v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
+}
+
+void __operator = (inout ivec2 v, const ivec2 u) {
+ v.x = u.x, v.y = u.y;
+}
+
+void __operator = (inout ivec3 v, const ivec3 u) {
+ v.x = u.x, v.y = u.y, v.z = u.z;
+}
+
+void __operator = (inout ivec4 v, const ivec4 u) {
+ v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
+}
+
+void __operator = (inout bvec2 v, const bvec2 u) {
+ v.x = u.x, v.y = u.y;
+}
+
+void __operator = (inout bvec3 v, const bvec3 u) {
+ v.x = u.x, v.y = u.y, v.z = u.z;
+}
+
+void __operator = (inout bvec4 v, const bvec4 u) {
+ v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
+}
+
+void __operator = (inout mat2 m, const mat2 n) {
+ m[0] = n[0], m[1] = n[1];
+}
+
+void __operator = (inout mat3 m, const mat3 n) {
+ m[0] = n[0], m[1] = n[1], m[2] = n[2];
+}
+
+void __operator = (inout mat4 m, const mat4 n) {
+ m[0] = n[0], m[1] = n[1], m[2] = n[2], m[3] = n[3];
+}
+
+//
+// \95 The arithmetic assignments add into (+=), subtract from (-=), multiply into (*=), and divide
+// into (/=). The variable and expression must be the same floating-point or integer type, ...
+//
+
+void __operator += (inout float a, const float b) {
+ __asm float_add a, b;
+}
+
+void __operator -= (inout float a, const float b) {
+ a += -b;
+}
+
+void __operator *= (inout float a, const float b) {
+ __asm float_multiply a, b;
+}
+
+void __operator /= (inout float a, const float b) {
+ __asm float_divide a, b;
+}
+
+void __operator += (inout int x, const int y) {
+ __asm int_add x, y;
+}
+
+void __operator -= (inout int x, const int y) {
+ x += -y;
+}
+
+void __operator *= (inout int x, const int y) {
+ __asm int_multiply x, y;
+}
+
+void __operator /= (inout int x, const int y) {
+ __asm int_divide x, y;
+}
+
+void __operator += (inout vec2 v, const vec2 u) {
+ v.x += u.x, v.y += u.y;
+}
+
+void __operator -= (inout vec2 v, const vec2 u) {
+ v.x -= u.x, v.y -= u.y;
+}
+
+void __operator *= (inout vec2 v, const vec2 u) {
+ v.x *= u.x, v.y *= u.y;
+}
+
+void __operator /= (inout vec2 v, const vec2 u) {
+ v.x /= u.x, v.y /= u.y;
+}
+
+void __operator += (inout vec3 v, const vec3 u) {
+ v.x += u.x, v.y += u.y, v.z += u.z;
+}
+
+void __operator -= (inout vec3 v, const vec3 u) {
+ v.x -= u.x, v.y -= u.y, v.z -= u.z;
+}
+
+void __operator *= (inout vec3 v, const vec3 u) {
+ v.x *= u.x, v.y *= u.y, v.z *= u.z;
+}
+
+void __operator /= (inout vec3 v, const vec3 u) {
+ v.x /= u.x, v.y /= u.y, v.z /= u.z;
+}
+
+void __operator += (inout vec4 v, const vec4 u) {
+ v.x += u.x, v.y += u.y, v.z += u.z, v.w += u.w;
+}
+
+void __operator -= (inout vec4 v, const vec4 u) {
+ v.x -= u.x, v.y -= u.y, v.z -= u.z, v.w -= u.w;
+}
+
+void __operator *= (inout vec4 v, const vec4 u) {
+ v.x *= u.x, v.y *= u.y, v.z *= u.z, v.w *= u.w;
+}
+
+void __operator /= (inout vec4 v, const vec4 u) {
+ v.x /= u.x, v.y /= u.y, v.z /= u.z, v.w /= u.w;
+}
+
+void __operator += (inout ivec2 v, const ivec2 u) {
+ v.x += u.x, v.y += u.y;
+}
+
+void __operator -= (inout ivec2 v, const ivec2 u) {
+ v.x -= u.x, v.y -= u.y;
+}
+
+void __operator *= (inout ivec2 v, const ivec2 u) {
+ v.x *= u.x, v.y *= u.y;
+}
+
+void __operator /= (inout ivec2 v, const ivec2 u) {
+ v.x /= u.x, v.y /= u.y;
+}
+
+void __operator += (inout ivec3 v, const ivec3 u) {
+ v.x += u.x, v.y += u.y, v.z += u.z;
+}
+
+void __operator -= (inout ivec3 v, const ivec3 u) {
+ v.x -= u.x, v.y -= u.y, v.z -= u.z;
+}
+
+void __operator *= (inout ivec3 v, const ivec3 u) {
+ v.x *= u.x, v.y *= u.y, v.z *= u.z;
+}
+
+void __operator /= (inout ivec3 v, const ivec3 u) {
+ v.x /= u.x, v.y /= u.y, v.z /= u.z;
+}
+
+void __operator += (inout ivec4 v, const ivec4 u) {
+ v.x += u.x, v.y += u.y, v.z += u.z, v.w += u.w;
+}
+
+void __operator -= (inout ivec4 v, const ivec4 u) {
+ v.x -= u.x, v.y -= u.y, v.z -= u.z, v.w -= u.w;
+}
+
+void __operator *= (inout ivec4 v, const ivec4 u) {
+ v.x *= u.x, v.y *= u.y, v.z *= u.z, v.w *= u.w;
+}
+
+void __operator /= (inout ivec4 v, const ivec4 u) {
+ v.x /= u.x, v.y /= u.y, v.z /= u.z, v.w /= u.w;
+}
+
+void __operator += (inout mat2 m, const mat2 n) {
+ m[0] += n[0], m[1] += n[1];
+}
+
+void __operator -= (inout mat2 v, const mat2 n) {
+ m[0] -= n[0], m[1] -= n[1];
+}
+
+void __operator *= (inout mat2 m, const mat2 n) {
+ m = m * n;
+}
+
+void __operator /= (inout mat2 m, const mat2 n) {
+ m[0] /= n[0], m[1] /= n[1];
+}
+
+void __operator += (inout mat3 m, const mat3 n) {
+ m[0] += n[0], m[1] += n[1], m[2] += n[2];
+}
+
+void __operator -= (inout mat3 m, const mat3 n) {
+ m[0] -= n[0], m[1] -= n[1], m[2] -= n[2];
+}
+
+void __operator *= (inout mat3 m, const mat3 n) {
+ m = m * n;
+}
+
+void __operator /= (inout mat3 m, const mat3 n) {
+ m[0] /= n[0], m[1] /= n[1], m[2] /= n[2];
+}
+
+void __operator += (inout mat4 m, const mat4 n) {
+ m[0] += n[0], m[1] += n[1], m[2] += n[2], m[3] += n[3];
+}
+
+void __operator -= (inout mat4 m, const mat4 n) {
+ m[0] -= n[0], m[1] -= n[1], m[2] -= n[2], m[3] -= n[3];
+}
+
+void __operator *= (inout mat4 m, const mat4 n) {
+ m = m * n;
+}
+
+void __operator /= (inout mat4 m, const mat4 n) {
+ m[0] /= n[0], m[1] /= n[1], m[2] /= n[2], m[3] /= n[3];
+}
+
+//
+// ... or if the expression is a float, then the variable can be floating-point, a vector, or
+// a matrix, ...
+//
+
+void __operator += (inout vec2 v, const float a) {
+ v.x += a, v.y += a;
+}
+
+void __operator -= (inout vec2 v, const float a) {
+ v.x -= a, v.y -= a;
+}
+
+void __operator *= (inout vec2 v, const float a) {
+ v.x *= a, v.y *= a;
+}
+
+void __operator /= (inout vec2 v, const float a) {
+ v.x /= a, v.y /= a;
+}
+
+void __operator += (inout vec3 v, const float a) {
+ v.x += a, v.y += a, v.z += a;
+}
+
+void __operator -= (inout vec3 v, const float a) {
+ v.x -= a, v.y -= a, v.z -= a;
+}
+
+void __operator *= (inout vec3 v, const float a) {
+ v.x *= a, v.y *= a, v.z *= a;
+}
+
+void __operator /= (inout vec3 v, const float a) {
+ v.x /= a, v.y /= a, v.z /= a;
+}
+
+void __operator += (inout vec4 v, const float a) {
+ v.x += a, v.y += a, v.z += a, v.w += a;
+}
+
+void __operator -= (inout vec4 v, const float a) {
+ v.x -= a, v.y -= a, v.z -= a, v.w -= a;
+}
+
+void __operator *= (inout vec4 v, const float a) {
+ v.x *= a, v.y *= a, v.z *= a, v.w *= a;
+}
+
+void __operator /= (inout vec4 v, const float a) {
+ v.x /= a, v.y /= a, v.z /= a, v.w /= a;
+}
+
+void __operator += (inout mat2 m, const float a) {
+ m[0] += a, m[1] += a;
+}
+
+void __operator -= (inout mat2 m, const float a) {
+ m[0] -= a, m[1] -= a;
+}
+
+void __operator *= (inout mat2 m, const float a) {
+ m[0] *= a, m[1] *= a;
+}
+
+void __operator /= (inout mat2 m, const float a) {
+ m[0] /= a, m[1] /= a;
+}
+
+void __operator += (inout mat3 m, const float a) {
+ m[0] += a, m[1] += a, m[2] += a;
+}
+
+void __operator -= (inout mat3 m, const float a) {
+ m[0] -= a, m[1] -= a, m[2] -= a;
+}
+
+void __operator *= (inout mat3 m, const float a) {
+ m[0] *= a, m[1] *= a, m[2] *= a;
+}
+
+void __operator /= (inout mat3 m, const float a) {
+ m[0] /= a, m[1] /= a, m[2] /= a;
+}
+
+void __operator += (inout mat4 m, const float a) {
+ m[0] += a, m[1] += a, m[2] += a, m[3] += a;
+}
+
+void __operator -= (inout mat4 m, const float a) {
+ m[0] -= a, m[1] -= a, m[2] -= a, m[3] -= a;
+}
+
+void __operator *= (inout mat4 m, const float a) {
+ m[0] *= a, m[1] *= a, m[2] *= a, m[3] *= a;
+}
+
+void __operator /= (inout mat4 m, const float a) {
+ m[0] /= a, m[1] /= a, m[2] /= a, m[3] /= a;
+}
+
+//
+// ... or if the operation is multiply into (*=), then the variable can be a vector and the
+// expression can be a matrix of matching size.
+//
+
+void __operator *= (inout vec2 v, const mat2 m) {
+ v = v * m;
+}
+
+void __operator *= (inout vec3 v, const mat3 m) {
+ v = v * m;
+}
+
+void __operator *= (inout vec4 v, const mat4 m) {
+ v = v * m;
+}
+
+//
+// 5.9 Expressions
+//
+// Expressions in the shading language include the following:
+//
+
+//
+// \95 The arithmetic binary operators add (+), subtract (-), multiply (*), and divide (/), that
+// operate on integer and floating-point typed expressions (including vectors and matrices).
+// The two operands must be the same type, (...) Additionally, for multiply (*) (...) If one
+// operand is scalar and the other is a vector or matrix, the scalar is applied component-wise
+// to the vector or matrix, resulting in the same type as the vector or matrix.
+//
+
+float __operator + (const float a, const float b) {
+ float c = a;
+ return c += b;
+}
+
+float __operator - (const float a, const float b) {
+ return a + -b;
+}
+
+float __operator * (const float a, const float b) {
+ float c = a;
+ return c *= b;
+}
+
+float __operator / (const float a, const float b) {
+ float c = a;
+ return c /= b;
+}
+
+int __operator + (const int a, const int b) {
+ int c = a;
+ return c += b;
+}
+
+int __operator - (const int x, const int y) {
+ return x + -y;
+}
+
+int __operator * (const int x, const int y) {
+ int z = x;
+ return z *= y;
+}
+
+int __operator / (const int x, const int y) {
+ int z = x;
+ return z /= y;
+}
+
+vec2 __operator + (const vec2 v, const vec2 u) {
+ return vec2 (v.x + u.x, v.y + u.y);
+}
+
+vec2 __operator - (const vec2 v, const vec2 u) {
+ return vec2 (v.x - u.x, v.y - u.y);
+}
+
+vec3 __operator + (const vec3 v, const vec3 u) {
+ return vec3 (v.x + u.x, v.y + u.y, v.z + u.z);
+}
+
+vec3 __operator - (const vec3 v, const vec3 u) {
+ return vec3 (v.x - u.x, v.y - u.y, v.z - u.z);
+}
+
+vec4 __operator + (const vec4 v, const vec4 u) {
+ return vec4 (v.x + u.x, v.y + u.y, v.z + u.z, v.w + u.w);
+}
+
+vec4 __operator - (const vec4 v, const vec4 u) {
+ return vec4 (v.x - u.x, v.y - u.y, v.z - u.z, v.w - u.w);
+}
+
+ivec2 __operator + (const ivec2 v, const ivec2 u) {
+ return ivec2 (v.x + u.x, v.y + u.y);
+}
+
+ivec2 __operator - (const ivec2 v, const ivec2 u) {
+ return ivec2 (v.x - u.x, v.y - u.y);
+}
+
+ivec3 __operator + (const ivec3 v, const ivec3 u) {
+ return ivec3 (v.x + u.x, v.y + u.y, v.z + u.z);
+}
+
+ivec3 __operator - (const ivec3 v, const ivec3 u) {
+ return ivec3 (v.x - u.x, v.y - u.y, v.z - u.z);
+}
+
+ivec4 __operator + (const ivec4 v, const ivec4 u) {
+ return ivec4 (v.x + u.x, v.y + u.y, v.z + u.z, v.w + u.w);
+}
+
+ivec4 __operator - (const ivec4 v, const ivec4 u) {
+ return ivec4 (v.x - u.x, v.y - u.y, v.z - u.z, v.w - u.w);
+}
+
+mat2 __operator + (const mat2 m, const mat2 n) {
+ return mat2 (m[0] + n[0], m[1] + n[1]);
+}
+
+mat2 __operator - (const mat2 m, const mat2 n) {
+ return mat2 (m[0] - n[0], m[1] - n[1]);
+}
+
+mat3 __operator + (const mat3 m, const mat3 n) {
+ return mat3 (m[0] + n[0], m[1] + n[1], m[2] + n[2]);
+}
+
+mat3 __operator - (const mat3 m, const mat3 n) {
+ return mat3 (m[0] - n[0], m[1] - n[1], m[2] - n[2]);
+}
+
+mat4 __operator + (const mat4 m, const mat4 n) {
+ return mat4 (m[0] + n[0], m[1] + n[1], m[2] + n[2], m[3] + n[3]);
+}
+
+mat4 __operator - (const mat4 m, const mat4 n) {
+ return mat4 (m[0] - n[0], m[1] - n[1], m[2] - n[2], m[3] - n[3]);
+}
+
+//
+// ... or one can be a scalar float and the other a float vector or matrix, ...
+//
+
+vec2 __operator + (const float a, const vec2 u) {
+ return vec2 (a + u.x, a + u.y);
+}
+
+vec2 __operator + (const vec2 v, const float b) {
+ return vec2 (v.x + b, v.y + b);
+}
+
+vec2 __operator - (const float a, const vec2 u) {
+ return vec2 (a - u.x, a - u.y);
+}
+
+vec2 __operator - (const vec2 v, const float b) {
+ return vec2 (v.x - b, v.y - b);
+}
+
+vec2 __operator * (const float a, const vec2 u) {
+ return vec2 (a * u.x, a * u.y);
+}
+
+vec2 __operator * (const vec2 v, const float b) {
+ return vec2 (v.x * b, v.y * b);
+}
+
+vec2 __operator / (const float a, const vec2 u) {
+ return vec2 (a / u.x, a / u.y);
+}
+
+vec2 __operator / (const vec2 v, const float b) {
+ return vec2 (v.x / b, v.y / b);
+}
+
+vec3 __operator + (const float a, const vec3 u) {
+ return vec3 (a + u.x, a + u.y, a + u.z);
+}
+
+vec3 __operator + (const vec3 v, const float b) {
+ return vec3 (v.x + b, v.y + b, v.z + b);
+}
+
+vec3 __operator - (const float a, const vec3 u) {
+ return vec3 (a - u.x, a - u.y, a - u.z);
+}
+
+vec3 __operator - (const vec3 v, const float b) {
+ return vec3 (v.x - b, v.y - b, v.z - b);
+}
+
+vec3 __operator * (const float a, const vec3 u) {
+ return vec3 (a * u.x, a * u.y, a * u.z);
+}
+
+vec3 __operator * (const vec3 v, const float b) {
+ return vec3 (v.x * b, v.y * b, v.z * b);
+}
+
+vec3 __operator / (const float a, const vec3 u) {
+ return vec3 (a / u.x, a / u.y, a / u.z);
+}
+
+vec3 __operator / (const vec3 v, const float b) {
+ return vec3 (v.x / b, v.y / b, v.z / b);
+}
+
+vec4 __operator + (const float a, const vec4 u) {
+ return vec4 (a + u.x, a + u.y, a + u.z, a + u.w);
+}
+
+vec4 __operator + (const vec4 v, const float b) {
+ return vec4 (v.x + b, v.y + b, v.z + b, v.w + b);
+}
+
+vec4 __operator - (const float a, const vec4 u) {
+ return vec4 (a - u.x, a - u.y, a - u.z, a - u.w);
+}
+
+vec4 __operator - (const vec4 v, const float b) {
+ return vec4 (v.x - b, v.y - b, v.z - b, v.w - b);
+}
+
+vec4 __operator * (const float a, const vec4 u) {
+ return vec4 (a * u.x, a * u.y, a * u.z, a * u.w);
+}
+
+vec4 __operator * (const vec4 v, const float b) {
+ return vec4 (v.x * b, v.y * b, v.z * b, v.w * b);
+}
+
+vec4 __operator / (const float a, const vec4 u) {
+ return vec4 (a / u.x, a / u.y, a / u.z, a / u.w);
+}
+
+vec4 __operator / (const vec4 v, const float b) {
+ return vec4 (v.x / b, v.y / b, v.z / b, v.w / b);
+}
+
+mat2 __operator + (const float a, const mat2 n) {
+ return mat2 (a + n[0], a + n[1]);
+}
+
+mat2 __operator + (const mat2 m, const float b) {
+ return mat2 (m[0] + b, m[1] + b);
+}
+
+mat2 __operator - (const float a, const mat2 n) {
+ return mat2 (a - n[0], a - n[1]);
+}
+
+mat2 __operator - (const mat2 m, const float b) {
+ return mat2 (m[0] - b, m[1] - b);
+}
+
+mat2 __operator * (const float a, const mat2 n) {
+ return mat2 (a * n[0], a * n[1]);
+}
+
+mat2 __operator * (const mat2 m, const float b) {
+ return mat2 (m[0] * b, m[1] * b);
+}
+
+mat2 __operator / (const float a, const mat2 n) {
+ return mat2 (a / n[0], a / n[1]);
+}
+
+mat2 __operator / (const mat2 m, const float b) {
+ return mat2 (m[0] / b, m[1] / b);
+}
+
+mat3 __operator + (const float a, const mat3 n) {
+ return mat3 (a + n[0], a + n[1], a + n[2]);
+}
+
+mat3 __operator + (const mat3 m, const float b) {
+ return mat3 (m[0] + b, m[1] + b, m[2] + b);
+}
+
+mat3 __operator - (const float a, const mat3 n) {
+ return mat3 (a - n[0], a - n[1], a - n[2]);
+}
+
+mat3 __operator - (const mat3 m, const float b) {
+ return mat3 (m[0] - b, m[1] - b, m[2] - b);
+}
+
+mat3 __operator * (const float a, const mat3 n) {
+ return mat3 (a * n[0], a * n[1], a * n[2]);
+}
+
+mat3 __operator * (const mat3 m, const float b) {
+ return mat3 (m[0] * b, m[1] * b, m[2] * b);
+}
+
+mat3 __operator / (const float a, const mat3 n) {
+ return mat3 (a / n[0], a / n[1], a / n[2]);
+}
+
+mat3 __operator / (const mat3 m, const float b) {
+ return mat3 (m[0] / b, m[1] / b, m[2] / b);
+}
+
+mat4 __operator + (const float a, const mat4 n) {
+ return mat4 (a + n[0], a + n[1], a + n[2], a + n[3]);
+}
+
+mat4 __operator + (const mat4 m, const float b) {
+ return mat4 (m[0] + b, m[1] + b, m[2] + b, m[3] + b);
+}
+
+mat4 __operator - (const float a, const mat4 n) {
+ return mat4 (a - n[0], a - n[1], a - n[2], a - n[3]);
+}
+
+mat4 __operator - (const mat4 m, const float b) {
+ return mat4 (m[0] - b, m[1] - b, m[2] - b, m[3] - b);
+}
+
+mat4 __operator * (const float a, const mat4 n) {
+ return mat4 (a * n[0], a * n[1], a * n[2], a * n[3]);
+}
+
+mat4 __operator * (const mat4 m, const float b) {
+ return mat4 (m[0] * b, m[1] * b, m[2] * b, m[3] * b);
+}
+
+mat4 __operator / (const float a, const mat4 n) {
+ return mat4 (a / n[0], a / n[1], a / n[2], a / n[3]);
+}
+
+mat4 __operator / (const mat4 m, const float b) {
+ return mat4 (m[0] / b, m[1] / b, m[2] / b, m[3] / b);
+}
+
+//
+// ... or one can be a scalar integer and the other an integer vector.
+//
+
+ivec2 __operator + (const int a, const ivec2 u) {
+ return ivec2 (a + u.x, a + u.y);
+}
+
+ivec2 __operator + (const ivec2 v, const int b) {
+ return ivec2 (v.x + b, v.y + b);
+}
+
+ivec2 __operator - (const int a, const ivec2 u) {
+ return ivec2 (a - u.x, a - u.y);
+}
+
+ivec2 __operator - (const ivec2 v, const int b) {
+ return ivec2 (v.x - b, v.y - b);
+}
+
+ivec2 __operator * (const int a, const ivec2 u) {
+ return ivec2 (a * u.x, a * u.y);
+}
+
+ivec2 __operator * (const ivec2 v, const int b) {
+ return ivec2 (v.x * b, v.y * b);
+}
+
+ivec2 __operator / (const int a, const ivec2 u) {
+ return ivec2 (a / u.x, a / u.y);
+}
+
+ivec2 __operator / (const ivec2 v, const int b) {
+ return ivec2 (v.x / b, v.y / b);
+}
+
+ivec3 __operator + (const int a, const ivec3 u) {
+ return ivec3 (a + u.x, a + u.y, a + u.z);
+}
+
+ivec3 __operator + (const ivec3 v, const int b) {
+ return ivec3 (v.x + b, v.y + b, v.z + b);
+}
+
+ivec3 __operator - (const int a, const ivec3 u) {
+ return ivec3 (a - u.x, a - u.y, a - u.z);
+}
+
+ivec3 __operator - (const ivec3 v, const int b) {
+ return ivec3 (v.x - b, v.y - b, v.z - b);
+}
+
+ivec3 __operator * (const int a, const ivec3 u) {
+ return ivec3 (a * u.x, a * u.y, a * u.z);
+}
+
+ivec3 __operator * (const ivec3 v, const int b) {
+ return ivec3 (v.x * b, v.y * b, v.z * b);
+}
+
+ivec3 __operator / (const int a, const ivec3 u) {
+ return ivec3 (a / u.x, a / u.y, a / u.z);
+}
+
+ivec3 __operator / (const ivec3 v, const int b) {
+ return ivec3 (v.x / b, v.y / b, v.z / b);
+}
+
+ivec4 __operator + (const int a, const ivec4 u) {
+ return ivec4 (a + u.x, a + u.y, a + u.z, a + u.w);
+}
+
+ivec4 __operator + (const ivec4 v, const int b) {
+ return ivec4 (v.x + b, v.y + b, v.z + b, v.w + b);
+}
+
+ivec4 __operator - (const int a, const ivec4 u) {
+ return ivec4 (a - u.x, a - u.y, a - u.z, a - u.w);
+}
+
+ivec4 __operator - (const ivec4 v, const int b) {
+ return ivec4 (v.x - b, v.y - b, v.z - b, v.w - b);
+}
+
+ivec4 __operator * (const int a, const ivec4 u) {
+ return ivec4 (a * u.x, a * u.y, a * u.z, a * u.w);
+}
+
+ivec4 __operator * (const ivec4 v, const int b) {
+ return ivec4 (v.x * b, v.y * b, v.z * b, v.w * b);
+}
+
+ivec4 __operator / (const int a, const ivec4 u) {
+ return ivec4 (a / u.x, a / u.y, a / u.z, a / u.w);
+}
+
+ivec4 __operator / (const ivec4 v, const int b) {
+ return ivec4 (v.x / b, v.y / b, v.z / b, v.w / b);
+}
+
+//
+// Additionally, for multiply (*) one can be a vector and the other a matrix with the same
+// dimensional size of the vector. These result in the same fundamental type (integer or float)
+// as the expressions they operate on.
+//
+// [When:]
+// \95 the left argument is a floating-point vector and the right is a matrix with a compatible
+// dimension in which case the * operator will do a row vector matrix multiplication.
+// \95 the left argument is a matrix and the right is a floating-point vector with a compatible
+// dimension in which case the * operator will do a column vector matrix multiplication.
+//
+
+vec2 __operator * (const mat2 m, const vec2 v) {
+ return vec2 (
+ v.x * m[0].x + v.y * m[1].x,
+ v.x * m[0].y + v.y * m[1].y
+ );
+}
+
+vec2 __operator * (const vec2 v, const mat2 m) {
+ return vec2 (
+ v.x * m[0].x + v.y * m[0].y,
+ v.x * m[1].x + v.y * m[1].y
+ );
+}
+
+vec3 __operator * (const mat3 m, const vec3 v) {
+ return vec3 (
+ v.x * m[0].x + v.y * m[1].x + v.z * m[2].x,
+ v.x * m[0].y + v.y * m[1].y + v.z * m[2].y,
+ v.x * m[0].z + v.y * m[1].z + v.z * m[2].z
+ );
+}
+
+vec3 __operator * (const vec3 v, const mat3 m) {
+ return vec3 (
+ v.x * m[0].x + v.y * m[0].y + v.z * m[0].z,
+ v.x * m[1].x + v.y * m[1].y + v.z * m[1].z,
+ v.x * m[2].x + v.y * m[2].y + v.z * m[2].z
+ );
+}
+
+vec4 __operator * (const mat4 m, const vec4 v) {
+ return vec4 (
+ v.x * m[0].x + v.y * m[1].x + v.z * m[2].x + v.w * m[3].x,
+ v.x * m[0].y + v.y * m[1].y + v.z * m[2].y + v.w * m[3].y,
+ v.x * m[0].z + v.y * m[1].z + v.z * m[2].z + v.w * m[3].z,
+ v.x * m[0].w + v.y * m[1].w + v.z * m[2].w + v.w * m[3].w
+ );
+}
+
+vec4 __operator * (const vec4 v, const mat4 m) {
+ return vec4 (
+ v.x * m[0].x + v.y * m[0].y + v.z * m[0].z + v.w * m[0].w,
+ v.x * m[1].x + v.y * m[1].y + v.z * m[1].z + v.w * m[1].w,
+ v.x * m[2].x + v.y * m[2].y + v.z * m[2].z + v.w * m[2].w,
+ v.x * m[3].x + v.y * m[3].y + v.z * m[3].z + v.w * m[3].w
+ );
+}
+
+//
+// Multiply (*) applied to two vectors yields a component-wise multiply.
+//
+
+vec2 __operator * (const vec2 v, const vec2 u) {
+ return vec2 (v.x * u.x, v.y * u.y);
+}
+
+vec3 __operator * (const vec3 v, const vec3 u) {
+ return vec3 (v.x * u.x, v.y * u.y, v.z * u.z);
+}
+
+vec4 __operator * (const vec4 v, const vec4 u) {
+ return vec4 (v.x * u.x, v.y * u.y, v.z * u.z, v.w * u.w);
+}
+
+ivec2 __operator * (const ivec2 v, const ivec2 u) {
+ return ivec2 (v.x * u.x, v.y * u.y);
+}
+
+ivec3 __operator * (const ivec3 v, const ivec3 u) {
+ return ivec3 (v.x * u.x, v.y * u.y, v.z * u.z);
+}
+
+ivec4 __operator * (const ivec4 v, const ivec4 u) {
+ return ivec4 (v.x * u.x, v.y * u.y, v.z * u.z, v.w * u.w);
+}
+
+//
+// Dividing by zero does not cause an exception but does result in an unspecified value.
+//
+
+vec2 __operator / (const vec2 v, const vec2 u) {
+ return vec2 (v.x / u.x, v.y / u.y);
+}
+
+vec3 __operator / (const vec3 v, const vec3 u) {
+ return vec3 (v.x / u.x, v.y / u.y, v.z / u.z);
+}
+
+vec4 __operator / (const vec4 v, const vec4 u) {
+ return vec4 (v.x / u.x, v.y / u.y, v.z / u.z, v.w / u.w);
+}
+
+ivec2 __operator / (const ivec2 v, const ivec2 u) {
+ return ivec2 (v.x / u.x, v.y / u.y);
+}
+
+ivec3 __operator / (const ivec3 v, const ivec3 u) {
+ return ivec3 (v.x / u.x, v.y / u.y, v.z / u.z);
+}
+
+ivec4 __operator / (const ivec4 v, const ivec4 u) {
+ return ivec4 (v.x / u.x, v.y / u.y, v.z / u.z, v.w / u.w);
+}
+
+mat2 __operator / (const mat2 m, const mat2 n) {
+ return mat2 (m[0] / n[0], m[1] / n[1]);
+}
+
+mat3 __operator / (const mat3 m, const mat3 n) {
+ return mat3 (m[0] / n[0], m[1] / n[1], m[2] / n[2]);
+}
+
+mat4 __operator / (const mat4 m, const mat4 n) {
+ return mat4 (m[0] / n[0], m[1] / n[1], m[2] / n[2], m[3] / n[3]);
+}
+
+//
+// Multiply (*) applied to two matrices yields a linear algebraic matrix multiply, not
+// a component-wise multiply.
+//
+
+mat2 __operator * (const mat2 m, const mat2 n) {
+ return mat2 (m * n[0], m * n[1]);
+}
+
+mat3 __operator * (const mat3 m, const mat3 n) {
+ return mat3 (m * n[0], m * n[1], m * n[2]);
+}
+
+mat4 __operator * (const mat4 m, const mat4 n) {
+ return mat4 (m * n[0], m * n[1], m * n[2], m * n[3]);
+}
+
+//
+// \95 The arithmetic unary operators negate (-), post- and pre-increment and decrement (-- and
+// ++) that operate on integer or floating-point values (including vectors and matrices). These
+// result with the same type they operated on. For post- and pre-increment and decrement, the
+// expression must be one that could be assigned to (an l-value). Pre-increment and predecrement
+// add or subtract 1 or 1.0 to the contents of the expression they operate on, and the
+// value of the pre-increment or pre-decrement expression is the resulting value of that
+// modification. Post-increment and post-decrement expressions add or subtract 1 or 1.0 to
+// the contents of the expression they operate on, but the resulting expression has the
+// expression\92s value before the post-increment or post-decrement was executed.
+//
+// [NOTE: postfix increment and decrement operators take additional dummy int parameter to
+// distinguish their prototypes from prefix ones.]
+//
+
+float __operator - (const float a) {
+ float c = a;
+ __asm float_negate c;
+ return c;
+}
+
+int __operator - (const int a) {
+ int c = a;
+ __asm int_negate c;
+ return c;
+}
+
+vec2 __operator - (const vec2 v) {
+ return vec2 (-v.x, -v.y);
+}
+
+vec3 __operator - (const vec3 v) {
+ return vec3 (-v.x, -v.y, -v.z);
+}
+
+vec4 __operator - (const vec4 v) {
+ return vec4 (-v.x, -v.y, -v.z, -v.w);
+}
+
+ivec2 __operator - (const ivec2 v) {
+ return ivec2 (-v.x, -v.y);
+}
+
+ivec3 __operator - (const ivec3 v) {
+ return ivec3 (-v.x, -v.y, -v.z);
+}
+
+ivec4 __operator - (const ivec4 v) {
+ return ivec4 (-v.x, -v.y, -v.z, -v.w);
+}
+
+mat2 __operator - (const mat2 m) {
+ return mat2 (-m[0], -m[1]);
+}
+
+mat3 __operator - (const mat3 m) {
+ return mat3 (-m[0], -m[1], -m[2]);
+}
+
+mat4 __operator - (const mat4 m) {
+ return mat4 (-m[0], -m[1], -m[2], -m[3]);
+}
+
+void __operator -- (inout float a) {
+ a -= 1.0;
+}
+
+void __operator -- (inout int a) {
+ a -= 1;
+}
+
+void __operator -- (inout vec2 v) {
+ --v.x, --v.y;
+}
+
+void __operator -- (inout vec3 v) {
+ --v.x, --v.y, --v.z;
+}
+
+void __operator -- (inout vec4 v) {
+ --v.x, --v.y, --v.z, --v.w;
+}
+
+void __operator -- (inout ivec2 v) {
+ --v.x, --v.y;
+}
+
+void __operator -- (inout ivec3 v) {
+ --v.x, --v.y, --v.z;
+}
+
+void __operator -- (inout ivec4 v) {
+ --v.x, --v.y, --v.z, --v.w;
+}
+
+void __operator -- (inout mat2 m) {
+ --m[0], --m[1];
+}
+
+void __operator -- (inout mat3 m) {
+ --m[0], --m[1], --m[2];
+}
+
+void __operator -- (inout mat4 m) {
+ --m[0], --m[1], --m[2], --m[3];
+}
+
+void __operator ++ (inout float a) {
+ a += 1.0;
+}
+
+void __operator ++ (inout int a) {
+ a += 1;
+}
+
+void __operator ++ (inout vec2 v) {
+ ++v.x, ++v.y;
+}
+
+void __operator ++ (inout vec3 v) {
+ ++v.x, ++v.y, ++v.z;
+}
+
+void __operator ++ (inout vec4 v) {
+ ++v.x, ++v.y, ++v.z, ++v.w;
+}
+
+void __operator ++ (inout ivec2 v) {
+ ++v.x, ++v.y;
+}
+
+void __operator ++ (inout ivec3 v) {
+ ++v.x, ++v.y, ++v.z;
+}
+
+void __operator ++ (inout ivec4 v) {
+ ++v.x, ++v.y, ++v.z, ++v.w;
+}
+
+void __operator ++ (inout mat2 m) {
+ ++m[0], ++m[1];
+}
+
+void __operator ++ (inout mat3 m) {
+ ++m[0], ++m[1], ++m[2];
+}
+
+void __operator ++ (inout mat4 m) {
+ ++m[0], ++m[1], ++m[2], ++m[3];
+}
+
+float __operator -- (inout float a, const int) {
+ const float c = a;
+ --a;
+ return c;
+}
+
+int __operator -- (inout int a, const int) {
+ const int c = a;
+ --a;
+ return c;
+}
+
+vec2 __operator -- (inout vec2 v, const int) {
+ return vec2 (v.x--, v.y--);
+}
+
+vec3 __operator -- (inout vec3 v, const int) {
+ return vec3 (v.x--, v.y--, v.z--);
+}
+
+vec4 __operator -- (inout vec4 v, const int) {
+ return vec4 (v.x--, v.y--, v.z--, v.w--);
+}
+
+ivec2 __operator -- (inout ivec2 v, const int) {
+ return ivec2 (v.x--, v.y--);
+}
+
+ivec3 __operator -- (inout ivec3 v, const int) {
+ return ivec3 (v.x--, v.y--, v.z--);
+}
+
+ivec4 __operator -- (inout ivec4 v, const int) {
+ return ivec4 (v.x--, v.y--, v.z--, v.w--);
+}
+
+mat2 __operator -- (inout mat2 m, const int) {
+ return mat2 (m[0]--, m[1]--);
+}
+
+mat3 __operator -- (inout mat3 m, const int) {
+ return mat3 (m[0]--, m[1]--, m[2]--);
+}
+
+mat4 __operator -- (inout mat4 m, const int) {
+ return mat4 (m[0]--, m[1]--, m[2]--, m[3]--);
+}
+
+float __operator ++ (inout float a, const int) {
+ const float c = a;
+ ++a;
+ return c;
+}
+
+int __operator ++ (inout int a, const int) {
+ const int c = a;
+ ++a;
+ return c;
+}
+
+vec2 __operator ++ (inout vec2 v, const int) {
+ return vec2 (v.x++, v.y++);
+}
+
+vec3 __operator ++ (inout vec3 v, const int) {
+ return vec3 (v.x++, v.y++, v.z++);
+}
+
+vec4 __operator ++ (inout vec4 v, const int) {
+ return vec4 (v.x++, v.y++, v.z++, v.w++);
+}
+
+ivec2 __operator ++ (inout ivec2 v, const int) {
+ return ivec2 (v.x++, v.y++);
+}
+
+ivec3 __operator ++ (inout ivec3 v, const int) {
+ return ivec3 (v.x++, v.y++, v.z++);
+}
+
+ivec4 __operator ++ (inout ivec4 v, const int) {
+ return ivec4 (v.x++, v.y++, v.z++, v.w++);
+}
+
+mat2 __operator ++ (inout mat2 m, const int) {
+ return mat2 (m[0]++, m[1]++);
+}
+
+mat3 __operator ++ (inout mat3 m, const int) {
+ return mat3 (m[0]++, m[1]++, m[2]++);
+}
+
+mat4 __operator ++ (inout mat4 m, const int) {
+ return mat4 (m[0]++, m[1]++, m[2]++, m[3]++);
+}
+
+//
+// \95 The relational operators greater than (>), less than (<), greater than or equal (>=), and less
+// than or equal (<=) operate only on scalar integer and scalar floating-point expressions. The
+// result is scalar Boolean. The operands\92 types must match. To do component-wise
+// comparisons on vectors, use the built-in functions lessThan, lessThanEqual,
+// greaterThan, and greaterThanEqual.
+//
+
+bool __operator < (const float a, const float b) {
+ bool c;
+ __asm float_less c, a, b;
+ return c;
+}
+
+bool __operator < (const int a, const int b) {
+ bool c;
+ __asm int_less c, a, b;
+ return c;
+}
+
+bool __operator > (const float a, const float b) {
+ return b < a;
+}
+
+bool __operator > (const int a, const int b) {
+ return b < a;
+}
+
+bool __operator >= (const float a, const float b) {
+ return a > b || a == b;
+}
+
+bool __operator >= (const int a, const int b) {
+ return a > b || a == b;
+}
+
+bool __operator <= (const float a, const float b) {
+ return a < b || a == b;
+}
+
+bool __operator <= (const int a, const int b) {
+ return a < b || a == b;
+}
+
+//
+// \95 The equality operators equal (==), and not equal (!=) operate on all types except arrays.
+// They result in a scalar Boolean. For vectors, matrices, and structures, all components of the
+// operands must be equal for the operands to be considered equal. To get component-wise
+// equality results for vectors, use the built-in functions equal and notEqual.
+//
+
+bool __operator == (const float a, const float b) {
+ bool c;
+ __asm float_equal c, a, b;
+ return c;
+}
+
+bool __operator == (const int a, const int b) {
+ bool c;
+ __asm int_equal c, a, b;
+ return c;
+}
+
+bool __operator == (const bool a, const bool b) {
+ bool c;
+ __asm bool_equal c, a, b;
+ return c;
+}
+
+bool __operator == (const vec2 v, const vec2 u) {
+ return v.x == u.x && v.y == u.y;
+}
+
+bool __operator == (const vec3 v, const vec3 u) {
+ return v.x == u.x && v.y == u.y && v.z == u.z;
+}
+
+bool __operator == (const vec4 v, const vec4 u) {
+ return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;
+}
+
+bool __operator == (const ivec2 v, const ivec2 u) {
+ return v.x == u.x && v.y == u.y;
+}
+
+bool __operator == (const ivec3 v, const ivec3 u) {
+ return v.x == u.x && v.y == u.y && v.z == u.z;
+}
+
+bool __operator == (const ivec4 v, const ivec4 u) {
+ return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;
+}
+
+bool __operator == (const bvec2 v, const bvec2 u) {
+ return v.x == u.x && v.y == u.y;
+}
+
+bool __operator == (const bvec3 v, const bvec3 u) {
+ return v.x == u.x && v.y == u.y && v.z == u.z;
+}
+
+bool __operator == (const bvec4 v, const bvec4 u) {
+ return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;
+}
+
+bool __operator == (const mat2 m, const mat2 n) {
+ return m[0] == n[0] && m[1] == n[1];
+}
+
+bool __operator == (const mat3 m, const mat3 n) {
+ return m[0] == n[0] && m[1] == n[1] && m[2] == n[2];
+}
+
+bool __operator == (const mat4 m, const mat4 n) {
+ return m[0] == n[0] && m[1] == n[1] && m[2] == n[2] && m[3] == n[3];
+}
+
+bool __operator != (const float a, const float b) {
+ return !(a == b);
+}
+
+bool __operator != (const int a, const int b) {
+ return !(a == b);
+}
+
+bool __operator != (const bool a, const bool b) {
+ return !(a == b);
+}
+
+bool __operator != (const vec2 v, const vec2 u) {
+ return v.x != u.x || v.y != u.y;
+}
+
+bool __operator != (const vec3 v, const vec3 u) {
+ return v.x != u.x || v.y != u.y || v.z != u.z;
+}
+
+bool __operator != (const vec4 v, const vec4 u) {
+ return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;
+}
+
+bool __operator != (const ivec2 v, const ivec2 u) {
+ return v.x != u.x || v.y != u.y;
+}
+
+bool __operator != (const ivec3 v, const ivec3 u) {
+ return v.x != u.x || v.y != u.y || v.z != u.z;
+}
+
+bool __operator != (const ivec4 v, const ivec4 u) {
+ return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;
+}
+
+bool __operator != (const bvec2 v, const bvec2 u) {
+ return v.x != u.x || v.y != u.y;
+}
+
+bool __operator != (const bvec3 v, const bvec3 u) {
+ return v.x != u.x || v.y != u.y || v.z != u.z;
+}
+
+bool __operator != (const bvec4 v, const bvec4 u) {
+ return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;
+}
+
+bool __operator != (const mat2 m, const mat2 n) {
+ return m[0] != n[0] || m[1] != n[1];
+}
+
+bool __operator != (const mat3 m, const mat3 n) {
+ return m[0] != n[0] || m[1] != n[1] || m[2] != n[2];
+}
+
+bool __operator != (const mat4 m, const mat4 n) {
+ return m[0] != n[0] || m[1] != n[1] || m[2] != n[2] || m[3] != n[3];
+}
+
+//
+// \95 The logical binary operators and (&&), or ( | | ), and exclusive or (^^). They operate only
+// on two Boolean expressions and result in a Boolean expression. And (&&) will only
+// evaluate the right hand operand if the left hand operand evaluated to true. Or ( | | ) will
+// only evaluate the right hand operand if the left hand operand evaluated to false. Exclusive or
+// (^^) will always evaluate both operands.
+//
+
+bool __operator ^^ (const bool a, const bool b) {
+ return a != b;
+}
+
+//
+// [These operators are handled internally by the compiler:]
+//
+// bool __operator && (bool a, bool b) {
+// return a ? b : false;
+// }
+// bool __operator || (bool a, bool b) {
+// return a ? true : b;
+// }
+//
+
+//
+// \95 The logical unary operator not (!). It operates only on a Boolean expression and results in a
+// Boolean expression. To operate on a vector, use the built-in function not.
+//
+
+bool __operator ! (const bool a) {
+ return a == false;
+}
+
--- /dev/null
+
+//
+// TODO:
+// - implement texture1D, texture2D, texture3D, textureCube,
+// - implement shadow1D, shadow2D,
+// - implement dFdx, dFdy,
+//
+
+//
+// From Shader Spec, ver. 1.10, rev. 59
+//
+// The output of the fragment shader is processed by the fixed function operations at the back end
+// of the OpenGL pipeline. Fragment shaders output values to the OpenGL pipeline using the built-in
+// variables gl_FragColor, gl_FragData and gl_FragDepth, unless the discard keyword is executed.
+//
+// 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\92s 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 executions of the
+// shader that take that path. That is, if a shader statically contains a write gl_FragDepth, then
+// it is responsible for always writing it.
+//
+// (A shader contains a static assignment to a variable x if, after pre-processing, the shader
+// contains statement that would write x, whether or not run-time flow of control will cause
+// that statement to be executed.)
+//
+// The variable gl_FragData is an array. Writing to gl_FragData[n] specifies the fragment data
+// that will be used by the subsequent fixed functionality pipeline for data n. If subsequent
+// fixed functionality consumes fragment data and an execution of a fragment shader does not
+// write a value to it, then the fragment data consumed is undefined.
+//
+// If a shader statically assigns a value to gl_FragColor, it may not assign a value to any element
+// of gl_FragData. If a shader statically writes a value to any element of gl_FragData, it may not
+// assign a value to gl_FragColor. That is, a shader may assign values to either gl_FragColor or
+// gl_FragData, but not both.
+//
+// If a shader executes the discard keyword, the fragment is discarded, and the values of
+// gl_FragDepth, gl_FragColor and gl_FragData 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\92s 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;
+vec4 gl_FragData[gl_MaxDrawBuffers];
+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\92t 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_MaxTextureCoords
+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:
+//
+// \95 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.
+//
+// \95 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.
+//
+// \95 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.
+//
+
+//
+// 8.7 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 that represents a depth texture with depth
+// comparisons turned on, then results are undefined. If a shadow texture call is made to a sampler
+// that represents a depth texture with depth comparisions turned off, the results are undefined.
+// If a shadow texture call is made to a sampler that does not represent a depth texture, then
+// results are 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 \93Lod\94 are allowed only in a vertex shader. For the \93Lod\94 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 \931D\94 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);
+}
+
+//
+// 8.8 Fragment Processing Functions
+//
+// 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));
+}
+
--- /dev/null
+/*\r
+ * Mesa 3-D graphics library\r
+ * Version: 6.2\r
+ *\r
+ * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a\r
+ * copy of this software and associated documentation files (the "Software"),\r
+ * to deal in the Software without restriction, including without limitation\r
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
+ * and/or sell copies of the Software, and to permit persons to whom the\r
+ * Software is furnished to do so, subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included\r
+ * in all copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN\r
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ */\r
+\r
+/*\r
+ * \file slang_shader.syn\r
+ * slang shader syntax\r
+ * \author Michal Krol\r
+ */\r
+\r
+/*\r
+ * usage:\r
+ * syn2c slang_shader.syn > slang_shader_syn.h\r
+ *\r
+ * when modifying or extending this file, several things must be taken into consideration:\r
+ * - when adding new operators that were marked as reserved in the initial specification,\r
+ * one must only uncomment particular lines of code that refer to operators being added;\r
+ * - when adding new shader target, one must reserve new value for shader_type register and\r
+ * use it in .if constructs for symbols that are exclusive for that shader;\r
+ * - some symbols mimic output of other symbols - the best example is the "for" construct:\r
+ * expression "for (foo(); ; bar())" is seen as "for (foo(); true; bar())" by the output\r
+ * processor - hence, special care must be taken when rearranging output of essential symbols;\r
+ * - order of single-quoted tokens does matter in alternatives - so do not parse "<" operator\r
+ * before "<<" and "<<" before "<<=";\r
+ * - all double-quoted tokens are internally preprocessed to eliminate problems with parsing\r
+ * strings that are prefixes of other strings, like "sampler1D" and "sampler1DShadow";\r
+ */\r
+\r
+.syntax translation_unit;\r
+\r
+/* revision number - increment after each change affecting emitted output */\r
+.emtcode REVISION 1\r
+\r
+/* external declaration */\r
+.emtcode EXTERNAL_NULL 0\r
+.emtcode EXTERNAL_FUNCTION_DEFINITION 1\r
+.emtcode EXTERNAL_DECLARATION 2\r
+\r
+/* declaration */\r
+.emtcode DECLARATION_FUNCTION_PROTOTYPE 1\r
+.emtcode DECLARATION_INIT_DECLARATOR_LIST 2\r
+\r
+/* function type */\r
+.emtcode FUNCTION_ORDINARY 0\r
+.emtcode FUNCTION_CONSTRUCTOR 1\r
+.emtcode FUNCTION_OPERATOR 2\r
+\r
+/* operator type */\r
+.emtcode OPERATOR_ASSIGN 1\r
+.emtcode OPERATOR_ADDASSIGN 2\r
+.emtcode OPERATOR_SUBASSIGN 3\r
+.emtcode OPERATOR_MULASSIGN 4\r
+.emtcode OPERATOR_DIVASSIGN 5\r
+/*.emtcode OPERATOR_MODASSIGN 6*/\r
+/*.emtcode OPERATOR_LSHASSIGN 7*/\r
+/*.emtcode OPERATOR_RSHASSIGN 8*/\r
+/*.emtcode OPERATOR_ORASSIGN 9*/\r
+/*.emtcode OPERATOR_XORASSIGN 10*/\r
+/*.emtcode OPERATOR_ANDASSIGN 11*/\r
+.emtcode OPERATOR_LOGICALXOR 12\r
+/*.emtcode OPERATOR_BITOR 13*/\r
+/*.emtcode OPERATOR_BITXOR 14*/\r
+/*.emtcode OPERATOR_BITAND 15*/\r
+.emtcode OPERATOR_EQUAL 16\r
+.emtcode OPERATOR_NOTEQUAL 17\r
+.emtcode OPERATOR_LESS 18\r
+.emtcode OPERATOR_GREATER 19\r
+.emtcode OPERATOR_LESSEQUAL 20\r
+.emtcode OPERATOR_GREATEREQUAL 21\r
+/*.emtcode OPERATOR_LSHIFT 22*/\r
+/*.emtcode OPERATOR_RSHIFT 23*/\r
+.emtcode OPERATOR_MULTIPLY 24\r
+.emtcode OPERATOR_DIVIDE 25\r
+/*.emtcode OPERATOR_MODULUS 26*/\r
+.emtcode OPERATOR_INCREMENT 27\r
+.emtcode OPERATOR_DECREMENT 28\r
+.emtcode OPERATOR_PLUS 29\r
+.emtcode OPERATOR_MINUS 30\r
+/*.emtcode OPERATOR_COMPLEMENT 31*/\r
+.emtcode OPERATOR_NOT 32\r
+\r
+/* init declarator list */\r
+.emtcode DECLARATOR_NONE 0\r
+.emtcode DECLARATOR_NEXT 1\r
+\r
+/* variable declaration */\r
+.emtcode VARIABLE_NONE 0\r
+.emtcode VARIABLE_IDENTIFIER 1\r
+.emtcode VARIABLE_INITIALIZER 2\r
+.emtcode VARIABLE_ARRAY_EXPLICIT 3\r
+.emtcode VARIABLE_ARRAY_UNKNOWN 4\r
+\r
+/* type qualifier */\r
+.emtcode TYPE_QUALIFIER_NONE 0\r
+.emtcode TYPE_QUALIFIER_CONST 1\r
+.emtcode TYPE_QUALIFIER_ATTRIBUTE 2\r
+.emtcode TYPE_QUALIFIER_VARYING 3\r
+.emtcode TYPE_QUALIFIER_UNIFORM 4\r
+\r
+/* type specifier */\r
+.emtcode TYPE_SPECIFIER_VOID 0\r
+.emtcode TYPE_SPECIFIER_BOOL 1\r
+.emtcode TYPE_SPECIFIER_BVEC2 2\r
+.emtcode TYPE_SPECIFIER_BVEC3 3\r
+.emtcode TYPE_SPECIFIER_BVEC4 4\r
+.emtcode TYPE_SPECIFIER_INT 5\r
+.emtcode TYPE_SPECIFIER_IVEC2 6\r
+.emtcode TYPE_SPECIFIER_IVEC3 7\r
+.emtcode TYPE_SPECIFIER_IVEC4 8\r
+.emtcode TYPE_SPECIFIER_FLOAT 9\r
+.emtcode TYPE_SPECIFIER_VEC2 10\r
+.emtcode TYPE_SPECIFIER_VEC3 11\r
+.emtcode TYPE_SPECIFIER_VEC4 12\r
+.emtcode TYPE_SPECIFIER_MAT2 13\r
+.emtcode TYPE_SPECIFIER_MAT3 14\r
+.emtcode TYPE_SPECIFIER_MAT4 15\r
+.emtcode TYPE_SPECIFIER_SAMPLER1D 16\r
+.emtcode TYPE_SPECIFIER_SAMPLER2D 17\r
+.emtcode TYPE_SPECIFIER_SAMPLER3D 18\r
+.emtcode TYPE_SPECIFIER_SAMPLERCUBE 19\r
+.emtcode TYPE_SPECIFIER_SAMPLER1DSHADOW 20\r
+.emtcode TYPE_SPECIFIER_SAMPLER2DSHADOW 21\r
+.emtcode TYPE_SPECIFIER_STRUCT 22\r
+.emtcode TYPE_SPECIFIER_TYPENAME 23\r
+\r
+/* structure field */\r
+.emtcode FIELD_NONE 0\r
+.emtcode FIELD_NEXT 1\r
+.emtcode FIELD_ARRAY 2\r
+\r
+/* operation */\r
+.emtcode OP_END 0\r
+.emtcode OP_BLOCK_BEGIN_NO_NEW_SCOPE 1\r
+.emtcode OP_BLOCK_BEGIN_NEW_SCOPE 2\r
+.emtcode OP_DECLARE 3\r
+.emtcode OP_ASM 4\r
+.emtcode OP_BREAK 5\r
+.emtcode OP_CONTINUE 6\r
+.emtcode OP_DISCARD 7\r
+.emtcode OP_RETURN 8\r
+.emtcode OP_EXPRESSION 9\r
+.emtcode OP_IF 10\r
+.emtcode OP_WHILE 11\r
+.emtcode OP_DO 12\r
+.emtcode OP_FOR 13\r
+.emtcode OP_PUSH_VOID 14\r
+.emtcode OP_PUSH_BOOL 15\r
+.emtcode OP_PUSH_INT 16\r
+.emtcode OP_PUSH_FLOAT 17\r
+.emtcode OP_PUSH_IDENTIFIER 18\r
+.emtcode OP_SEQUENCE 19\r
+.emtcode OP_ASSIGN 20\r
+.emtcode OP_ADDASSIGN 21\r
+.emtcode OP_SUBASSIGN 22\r
+.emtcode OP_MULASSIGN 23\r
+.emtcode OP_DIVASSIGN 24\r
+/*.emtcode OP_MODASSIGN 25*/\r
+/*.emtcode OP_LSHASSIGN 26*/\r
+/*.emtcode OP_RSHASSIGN 27*/\r
+/*.emtcode OP_ORASSIGN 28*/\r
+/*.emtcode OP_XORASSIGN 29*/\r
+/*.emtcode OP_ANDASSIGN 30*/\r
+.emtcode OP_SELECT 31\r
+.emtcode OP_LOGICALOR 32\r
+.emtcode OP_LOGICALXOR 33\r
+.emtcode OP_LOGICALAND 34\r
+/*.emtcode OP_BITOR 35*/\r
+/*.emtcode OP_BITXOR 36*/\r
+/*.emtcode OP_BITAND 37*/\r
+.emtcode OP_EQUAL 38\r
+.emtcode OP_NOTEQUAL 39\r
+.emtcode OP_LESS 40\r
+.emtcode OP_GREATER 41\r
+.emtcode OP_LESSEQUAL 42\r
+.emtcode OP_GREATEREQUAL 43\r
+/*.emtcode OP_LSHIFT 44*/\r
+/*.emtcode OP_RSHIFT 45*/\r
+.emtcode OP_ADD 46\r
+.emtcode OP_SUBTRACT 47\r
+.emtcode OP_MULTIPLY 48\r
+.emtcode OP_DIVIDE 49\r
+/*.emtcode OP_MODULUS 50*/\r
+.emtcode OP_PREINCREMENT 51\r
+.emtcode OP_PREDECREMENT 52\r
+.emtcode OP_PLUS 53\r
+.emtcode OP_MINUS 54\r
+/*.emtcode OP_COMPLEMENT 55*/\r
+.emtcode OP_NOT 56\r
+.emtcode OP_SUBSCRIPT 57\r
+.emtcode OP_CALL 58\r
+.emtcode OP_FIELD 59\r
+.emtcode OP_POSTINCREMENT 60\r
+.emtcode OP_POSTDECREMENT 61\r
+\r
+/* parameter qualifier */\r
+.emtcode PARAM_QUALIFIER_IN 0\r
+.emtcode PARAM_QUALIFIER_OUT 1\r
+.emtcode PARAM_QUALIFIER_INOUT 2\r
+\r
+/* function parameter */\r
+.emtcode PARAMETER_NONE 0\r
+.emtcode PARAMETER_NEXT 1\r
+\r
+/* function parameter array presence */\r
+.emtcode PARAMETER_ARRAY_NOT_PRESENT 0\r
+.emtcode PARAMETER_ARRAY_PRESENT 1\r
+\r
+.errtext INVALID_EXTERNAL_DECLARATION "error 2001: invalid external declaration"\r
+.errtext INVALID_OPERATOR_OVERRIDE "error 2002: invalid operator override"\r
+.errtext LBRACE_EXPECTED "error 2003: '{' expected but '$err_token$' found"\r
+.errtext LPAREN_EXPECTED "error 2004: '(' expected but '$err_token$' found"\r
+.errtext RPAREN_EXPECTED "error 2005: ')' expected but '$err_token$' found"\r
+\r
+/* tells whether the shader that is being parsed is a built-in shader or not */\r
+/* 0 - normal behaviour */\r
+/* 1 - accepts constructor and operator definitions and __asm statements */\r
+/* the implementation will set it to 1 when compiling internal built-in shaders */\r
+.regbyte parsing_builtin 0\r
+\r
+/* holds the type of shader that is being parsed, possible values are listed below */\r
+/* FRAGMENT_SHADER 1 */\r
+/* VERTEX_SHADER 2 */\r
+/* shader type is set by the caller before parsing */\r
+.regbyte shader_type 0\r
+\r
+/*\r
+ <variable_identifier> ::= <identifier>\r
+*/\r
+variable_identifier\r
+ identifier .emit OP_PUSH_IDENTIFIER;\r
+\r
+/*\r
+ <primary_expression> ::= <variable_identifier>\r
+ | <intconstant>\r
+ | <floatconstant>\r
+ | <boolconstant>\r
+ | "(" <expression> ")"\r
+*/\r
+primary_expression\r
+ floatconstant .or boolconstant .or intconstant .or variable_identifier .or primary_expression_1;\r
+primary_expression_1\r
+ lparen .and expression .and rparen;\r
+\r
+/*\r
+ <postfix_expression> ::= <primary_expression>\r
+ | <postfix_expression> "[" <integer_expression> "]"\r
+ | <function_call>\r
+ | <postfix_expression> "." <field_selection>\r
+ | <postfix_expression> "++"\r
+ | <postfix_expression> "--"\r
+*/\r
+postfix_expression\r
+ postfix_expression_1 .and .loop postfix_expression_2;\r
+postfix_expression_1\r
+ function_call .or primary_expression;\r
+postfix_expression_2\r
+ postfix_expression_3 .or postfix_expression_4 .or\r
+ plusplus .emit OP_POSTINCREMENT .or\r
+ minusminus .emit OP_POSTDECREMENT;\r
+postfix_expression_3\r
+ lbracket .and integer_expression .and rbracket .emit OP_SUBSCRIPT;\r
+postfix_expression_4\r
+ dot .and field_selection .emit OP_FIELD;\r
+\r
+/*\r
+ <integer_expression> ::= <expression>\r
+*/\r
+integer_expression\r
+ expression;\r
+\r
+/*\r
+ <function_call> ::= <function_call_generic>\r
+*/\r
+function_call\r
+ function_call_generic .emit OP_CALL .and .true .emit OP_END;\r
+\r
+/*\r
+ <function_call_generic> ::= <function_call_header_with_parameters> ")"\r
+ | <function_call_header_no_parameters> ")"\r
+*/\r
+function_call_generic\r
+ function_call_generic_1 .or function_call_generic_2;\r
+function_call_generic_1\r
+ function_call_header_with_parameters .and rparen .error RPAREN_EXPECTED;\r
+function_call_generic_2\r
+ function_call_header_no_parameters .and rparen .error RPAREN_EXPECTED;\r
+\r
+/*\r
+ <function_call_header_no_parameters>::= <function_call_header> "void"\r
+ | <function_call_header>\r
+*/\r
+function_call_header_no_parameters\r
+ function_call_header .and function_call_header_no_parameters_1;\r
+function_call_header_no_parameters_1\r
+ "void" .or .true;\r
+\r
+/*\r
+ <function_call_header_with_parameters>::= <function_call_header> <assignment_expression>\r
+ | <function_call_header_with_parameters> ","\r
+ <assignment_expression>\r
+*/\r
+function_call_header_with_parameters\r
+ function_call_header .and assignment_expression .and .true .emit OP_END .and\r
+ .loop function_call_header_with_parameters_1;\r
+function_call_header_with_parameters_1\r
+ comma .and assignment_expression .and .true .emit OP_END;\r
+\r
+/*\r
+ <function_call_header> ::= <function_identifier> "("\r
+*/\r
+function_call_header\r
+ function_identifier .and lparen;\r
+\r
+/*\r
+ <function_identifier> ::= <constructor_identifier>\r
+ | <identifier>\r
+\r
+note: <constructor_identifier> has been deleted\r
+*/\r
+function_identifier\r
+ identifier;\r
+\r
+/*\r
+ <unary_expression> ::= <postfix_expression>\r
+ | "++" <unary_expression>\r
+ | "--" <unary_expression>\r
+ | <unary_operator> <unary_expression>\r
+\r
+ <unary_operator> ::= "+"\r
+ | "-"\r
+ | "!"\r
+ | "~" // reserved\r
+*/\r
+unary_expression\r
+ postfix_expression .or unary_expression_1 .or unary_expression_2 .or unary_expression_3 .or\r
+ unary_expression_4 .or unary_expression_5/* .or unary_expression_6*/;\r
+unary_expression_1\r
+ plusplus .and unary_expression .and .true .emit OP_PREINCREMENT;\r
+unary_expression_2\r
+ minusminus .and unary_expression .and .true .emit OP_PREDECREMENT;\r
+unary_expression_3\r
+ plus .and unary_expression .and .true .emit OP_PLUS;\r
+unary_expression_4\r
+ minus .and unary_expression .and .true .emit OP_MINUS;\r
+unary_expression_5\r
+ bang .and unary_expression .and .true .emit OP_NOT;\r
+/*unary_expression_6\r
+ tilde .and unary_expression .and .true .emit OP_COMPLEMENT;*/\r
+\r
+/*\r
+ <multiplicative_expression> ::= <unary_expression>\r
+ | <multiplicative_expression> "*" <unary_expression>\r
+ | <multiplicative_expression> "/" <unary_expression>\r
+ | <multiplicative_expression> "%" <unary_expression> // reserved\r
+*/\r
+multiplicative_expression\r
+ unary_expression .and .loop multiplicative_expression_1;\r
+multiplicative_expression_1\r
+ multiplicative_expression_2 .or multiplicative_expression_3/* .or multiplicative_expression_4*/;\r
+multiplicative_expression_2\r
+ star .and unary_expression .and .true .emit OP_MULTIPLY;\r
+multiplicative_expression_3\r
+ slash .and unary_expression .and .true .emit OP_DIVIDE;\r
+/*multiplicative_expression_4\r
+ percent .and unary_expression .and .true .emit OP_MODULUS;*/\r
+\r
+/*\r
+ <additive_expression> ::= <multiplicative_expression>\r
+ | <additive_expression> "+" <multiplicative_expression>\r
+ | <additive_expression> "-" <multiplicative_expression>\r
+*/\r
+additive_expression\r
+ multiplicative_expression .and .loop additive_expression_1;\r
+additive_expression_1\r
+ additive_expression_2 .or additive_expression_3;\r
+additive_expression_2\r
+ plus .and multiplicative_expression .and .true .emit OP_ADD;\r
+additive_expression_3\r
+ minus .and multiplicative_expression .and .true .emit OP_SUBTRACT;\r
+\r
+/*\r
+ <shift_expression> ::= <additive_expression>\r
+ | <shift_expression> "<<" <additive_expression> // reserved\r
+ | <shift_expression> ">>" <additive_expression> // reserved\r
+*/\r
+shift_expression\r
+ additive_expression/* .and .loop shift_expression_1*/;\r
+/*shift_expression_1\r
+ shift_expression_2 .or shift_expression_3;*/\r
+/*shift_expression_2\r
+ lessless .and additive_expression .and .true .emit OP_LSHIFT;*/\r
+/*shift_expression_3\r
+ greatergreater .and additive_expression .and .true .emit OP_RSHIFT;*/\r
+\r
+/*\r
+ <relational_expression> ::= <shift_expression>\r
+ | <relational_expression> "<" <shift_expression>\r
+ | <relational_expression> ">" <shift_expression>\r
+ | <relational_expression> "<=" <shift_expression>\r
+ | <relational_expression> ">=" <shift_expression>\r
+*/\r
+relational_expression\r
+ shift_expression .and .loop relational_expression_1;\r
+relational_expression_1\r
+ relational_expression_2 .or relational_expression_3 .or relational_expression_4 .or\r
+ relational_expression_5;\r
+relational_expression_2\r
+ lessequals .and shift_expression .and .true .emit OP_LESSEQUAL;\r
+relational_expression_3\r
+ greaterequals .and shift_expression .and .true .emit OP_GREATEREQUAL;\r
+relational_expression_4\r
+ less .and shift_expression .and .true .emit OP_LESS;\r
+relational_expression_5\r
+ greater .and shift_expression .and .true .emit OP_GREATER;\r
+\r
+/*\r
+ <equality_expression> ::= <relational_expression>\r
+ | <equality_expression> "==" <relational_expression>\r
+ | <equality_expression> "!=" <relational_expression>\r
+*/\r
+equality_expression\r
+ relational_expression .and .loop equality_expression_1;\r
+equality_expression_1\r
+ equality_expression_2 .or equality_expression_3;\r
+equality_expression_2\r
+ equalsequals .and relational_expression .and .true .emit OP_EQUAL;\r
+equality_expression_3\r
+ bangequals .and relational_expression .and .true .emit OP_NOTEQUAL;\r
+\r
+/*\r
+ <and_expression> ::= <equality_expression>\r
+ | <and_expression> "&" <equality_expression> // reserved\r
+*/\r
+and_expression\r
+ equality_expression/* .and .loop and_expression_1*/;\r
+/*and_expression_1\r
+ ampersand .and equality_expression .and .true .emit OP_BITAND;*/\r
+\r
+/*\r
+ <exclusive_or_expression> ::= <and_expression>\r
+ | <exclusive_or_expression> "^" <and_expression> // reserved\r
+*/\r
+exclusive_or_expression\r
+ and_expression/* .and .loop exclusive_or_expression_1*/;\r
+/*exclusive_or_expression_1\r
+ caret .and and_expression .and .true .emit OP_BITXOR;*/\r
+\r
+/*\r
+ <inclusive_or_expression> ::= <exclusive_or_expression>\r
+ | <inclusive_or_expression> "|" <exclusive_or_expression> // reserved\r
+*/\r
+inclusive_or_expression\r
+ exclusive_or_expression/* .and .loop inclusive_or_expression_1*/;\r
+/*inclusive_or_expression_1\r
+ bar .and exclusive_or_expression .and .true .emit OP_BITOR;*/\r
+\r
+/*\r
+ <logical_and_expression> ::= <inclusive_or_expression>\r
+ | <logical_and_expression> "&&" <inclusive_or_expression>\r
+*/\r
+logical_and_expression\r
+ inclusive_or_expression .and .loop logical_and_expression_1;\r
+logical_and_expression_1\r
+ ampersandampersand .and inclusive_or_expression .and .true .emit OP_LOGICALAND;\r
+\r
+/*\r
+ <logical_xor_expression> ::= <logical_and_expression>\r
+ | <logical_xor_expression> "^^" <logical_and_expression>\r
+*/\r
+logical_xor_expression\r
+ logical_and_expression .and .loop logical_xor_expression_1;\r
+logical_xor_expression_1\r
+ caretcaret .and logical_and_expression .and .true .emit OP_LOGICALXOR;\r
+\r
+/*\r
+ <logical_or_expression> ::= <logical_xor_expression>\r
+ | <logical_or_expression> "||" <logical_xor_expression>\r
+*/\r
+logical_or_expression\r
+ logical_xor_expression .and .loop logical_or_expression_1;\r
+logical_or_expression_1\r
+ barbar .and logical_xor_expression .and .true .emit OP_LOGICALOR;\r
+\r
+/*\r
+ <conditional_expression> ::= <logical_or_expression>\r
+ | <logical_or_expression> "?" <expression> ":"\r
+ <conditional_expression>\r
+*/\r
+conditional_expression\r
+ logical_or_expression .and .loop conditional_expression_1;\r
+conditional_expression_1\r
+ question .and expression .and colon .and conditional_expression .and .true .emit OP_SELECT;\r
+\r
+/*\r
+ <assignment_expression> ::= <conditional_expression>\r
+ | <unary_expression> <assignment_operator>\r
+ <assignment_expression>\r
+\r
+ <assignment_operator> ::= "="\r
+ | "*="\r
+ | "/="\r
+ | "+="\r
+ | "-="\r
+ | "%=" // reserved\r
+ | "<<=" // reserved\r
+ | ">>=" // reserved\r
+ | "&=" // reserved\r
+ | "^=" // reserved\r
+ | "|=" // reserved\r
+*/\r
+assignment_expression\r
+ assignment_expression_1 .or assignment_expression_2 .or assignment_expression_3 .or\r
+ assignment_expression_4 .or assignment_expression_5/* .or assignment_expression_6 .or\r
+ assignment_expression_7 .or assignment_expression_8 .or assignment_expression_9 .or\r
+ assignment_expression_10 .or assignment_expression_11*/ .or conditional_expression;\r
+assignment_expression_1\r
+ unary_expression .and equals .and assignment_expression .and .true .emit OP_ASSIGN;\r
+assignment_expression_2\r
+ unary_expression .and starequals .and assignment_expression .and .true .emit OP_MULASSIGN;\r
+assignment_expression_3\r
+ unary_expression .and slashequals .and assignment_expression .and .true .emit OP_DIVASSIGN;\r
+assignment_expression_4\r
+ unary_expression .and plusequals .and assignment_expression .and .true .emit OP_ADDASSIGN;\r
+assignment_expression_5\r
+ unary_expression .and minusequals .and assignment_expression .and .true .emit OP_SUBASSIGN;\r
+/*assignment_expression_6\r
+ unary_expression .and percentequals .and assignment_expression .and .true .emit OP_MODASSIGN;*/\r
+/*assignment_expression_7\r
+ unary_expression .and lesslessequals .and assignment_expression .and .true .emit OP_LSHASSIGN;*/\r
+/*assignment_expression_8\r
+ unary_expression .and greatergreaterequals .and assignment_expression .and\r
+ .true .emit OP_RSHASSIGN;*/\r
+/*assignment_expression_9\r
+ unary_expression .and ampersandequals .and assignment_expression .and .true .emit OP_ANDASSIGN;*/\r
+/*assignment_expression_10\r
+ unary_expression .and caretequals .and assignment_expression .and .true .emit OP_XORASSIGN;*/\r
+/*assignment_expression_11\r
+ unary_expression .and barequals .and assignment_expression .and .true .emit OP_ORASSIGN;*/\r
+\r
+/*\r
+ <expression> ::= <assignment_expression>\r
+ | <expression> "," <assignment_expression>\r
+*/\r
+expression\r
+ assignment_expression .and .loop expression_1;\r
+expression_1\r
+ comma .and assignment_expression .and .true .emit OP_SEQUENCE;\r
+\r
+/*\r
+ <constant_expression> ::= <conditional_expression>\r
+*/\r
+constant_expression\r
+ conditional_expression .and .true .emit OP_END;\r
+\r
+/*\r
+ <declaration> ::= <function_prototype> ";"\r
+ | <init_declarator_list> ";"\r
+*/\r
+declaration\r
+ declaration_1 .or declaration_2;\r
+declaration_1\r
+ function_prototype .emit DECLARATION_FUNCTION_PROTOTYPE .and semicolon;\r
+declaration_2\r
+ init_declarator_list .emit DECLARATION_INIT_DECLARATOR_LIST .and semicolon;\r
+\r
+/*\r
+ <function_prototype> ::= <function_declarator> ")"\r
+*/\r
+function_prototype\r
+ function_declarator .and rparen .error RPAREN_EXPECTED .emit PARAMETER_NONE;\r
+\r
+/*\r
+ <function_declarator> ::= <function_header>\r
+ | <function_header_with_parameters>\r
+*/\r
+function_declarator\r
+ function_header_with_parameters .or function_header;\r
+\r
+/*\r
+ <function_header_with_parameters> ::= <function_header> <parameter_declaration>\r
+ | <function_header_with_parameters> ","\r
+ <parameter_declaration>\r
+*/\r
+function_header_with_parameters\r
+ function_header .and parameter_declaration .and .loop function_header_with_parameters_1;\r
+function_header_with_parameters_1\r
+ comma .and parameter_declaration;\r
+\r
+/*\r
+ <function_header> ::= <fully_specified_type> <identifier> "("\r
+*/\r
+function_header\r
+ function_header_nospace .or function_header_space;\r
+function_header_space\r
+ fully_specified_type_space .and space .and function_decl_identifier .and lparen;\r
+function_header_nospace\r
+ fully_specified_type_nospace .and function_decl_identifier .and lparen;\r
+\r
+/*\r
+ <function_decl_identifier> ::= "__constructor"\r
+ | <__operator>\r
+ | <identifier>\r
+\r
+note: this is an extension to the standard language specification - normally slang disallows\r
+ operator and constructor prototypes and definitions\r
+*/\r
+function_decl_identifier\r
+ .if (parsing_builtin != 0) __operator .emit FUNCTION_OPERATOR .or\r
+ .if (parsing_builtin != 0) "__constructor" .emit FUNCTION_CONSTRUCTOR .or\r
+ identifier .emit FUNCTION_ORDINARY;\r
+\r
+/*\r
+ <__operator> ::= "__operator" <overriden_op>\r
+\r
+note: this is an extension to the standard language specification - normally slang disallows\r
+ operator prototypes and definitions\r
+*/\r
+__operator\r
+ "__operator" .and overriden_operator .error INVALID_OPERATOR_OVERRIDE;\r
+\r
+/*\r
+ <overriden_op> ::= "="\r
+ | "+="\r
+ | "-="\r
+ | "*="\r
+ | "/="\r
+ | "%=" // reserved\r
+ | "<<=" // reserved\r
+ | ">>=" // reserved\r
+ | "&=" // reserved\r
+ | "^=" // reserved\r
+ | "|=" // reserved\r
+ | "^^"\r
+ | "|" // reserved\r
+ | "^" // reserved\r
+ | "&" // reserved\r
+ | "=="\r
+ | "!="\r
+ | "<"\r
+ | ">"\r
+ | "<="\r
+ | ">="\r
+ | "<<" // reserved\r
+ | ">>" // reserved\r
+ | "*"\r
+ | "/"\r
+ | "%" // reserved\r
+ | "++"\r
+ | "--"\r
+ | "+"\r
+ | "-"\r
+ | "~" // reserved\r
+ | "!"\r
+\r
+note: this is an extension to the standard language specification - normally slang disallows\r
+ operator prototypes and definitions\r
+*/\r
+overriden_operator\r
+ plusplus .emit OPERATOR_INCREMENT .or\r
+ plusequals .emit OPERATOR_ADDASSIGN .or\r
+ plus .emit OPERATOR_PLUS .or\r
+ minusminus .emit OPERATOR_DECREMENT .or\r
+ minusequals .emit OPERATOR_SUBASSIGN .or\r
+ minus .emit OPERATOR_MINUS .or\r
+ bangequals .emit OPERATOR_NOTEQUAL .or\r
+ bang .emit OPERATOR_NOT .or\r
+ starequals .emit OPERATOR_MULASSIGN .or\r
+ star .emit OPERATOR_MULTIPLY .or\r
+ slashequals .emit OPERATOR_DIVASSIGN .or\r
+ slash .emit OPERATOR_DIVIDE .or\r
+ lessequals .emit OPERATOR_LESSEQUAL .or\r
+ /*lesslessequals .emit OPERATOR_LSHASSIGN .or*/\r
+ /*lessless .emit OPERATOR_LSHIFT .or*/\r
+ less .emit OPERATOR_LESS .or\r
+ greaterequals .emit OPERATOR_GREATEREQUAL .or\r
+ /*greatergreaterequals .emit OPERATOR_RSHASSIGN .or*/\r
+ /*greatergreater .emit OPERATOR_RSHIFT .or*/\r
+ greater .emit OPERATOR_GREATER .or\r
+ equalsequals .emit OPERATOR_EQUAL .or\r
+ equals .emit OPERATOR_ASSIGN .or\r
+ /*percentequals .emit OPERATOR_MODASSIGN .or*/\r
+ /*percent .emit OPERATOR_MODULUS .or*/\r
+ /*ampersandequals .emit OPERATOR_ANDASSIGN */\r
+ /*ampersand .emit OPERATOR_BITAND .or*/\r
+ /*barequals .emit OPERATOR_ORASSIGN .or*/\r
+ /*bar .emit OPERATOR_BITOR .or*/\r
+ /*tilde .emit OPERATOR_COMPLEMENT .or*/\r
+ /*caretequals .emit OPERATOR_XORASSIGN .or*/\r
+ caretcaret .emit OPERATOR_LOGICALXOR /*.or\r
+ caret .emit OPERATOR_BITXOR*/;\r
+\r
+/*\r
+ <parameter_declarator> ::= <type_specifier> <identifier>\r
+ | <type_specifier> <identifier> "[" <constant_expression>\r
+ "]"\r
+*/\r
+parameter_declarator\r
+ parameter_declarator_nospace .or parameter_declarator_space;\r
+parameter_declarator_nospace\r
+ type_specifier_nospace .and identifier .and parameter_declarator_1;\r
+parameter_declarator_space\r
+ type_specifier_space .and space .and identifier .and parameter_declarator_1;\r
+parameter_declarator_1\r
+ parameter_declarator_2 .emit PARAMETER_ARRAY_PRESENT .or\r
+ .true .emit PARAMETER_ARRAY_NOT_PRESENT;\r
+parameter_declarator_2\r
+ lbracket .and constant_expression .and rbracket;\r
+\r
+/*\r
+ <parameter_declaration> ::= <type_qualifier> <parameter_qualifier>\r
+ <parameter_declarator>\r
+ | <type_qualifier> <parameter_qualifier>\r
+ <parameter_type_specifier>\r
+ | <parameter_qualifier> <parameter_declarator>\r
+ | <parameter_qualifier> <parameter_type_specifier>\r
+*/\r
+parameter_declaration\r
+ parameter_declaration_1 .emit PARAMETER_NEXT;\r
+parameter_declaration_1\r
+ parameter_declaration_2 .or parameter_declaration_3;\r
+parameter_declaration_2\r
+ type_qualifier .and space .and parameter_qualifier .and parameter_declaration_4;\r
+parameter_declaration_3\r
+ parameter_qualifier .emit TYPE_QUALIFIER_NONE .and parameter_declaration_4;\r
+parameter_declaration_4\r
+ parameter_declarator .or parameter_type_specifier;\r
+\r
+/*\r
+ <parameter_qualifier> ::= "in"\r
+ | "out"\r
+ | "inout"\r
+ | ""\r
+*/\r
+parameter_qualifier\r
+ parameter_qualifier_1 .or .true .emit PARAM_QUALIFIER_IN;\r
+parameter_qualifier_1\r
+ parameter_qualifier_2 .and space;\r
+parameter_qualifier_2\r
+ "in" .emit PARAM_QUALIFIER_IN .or\r
+ "out" .emit PARAM_QUALIFIER_OUT .or\r
+ "inout" .emit PARAM_QUALIFIER_INOUT;\r
+\r
+/*\r
+ <parameter_type_specifier> ::= <type_specifier>\r
+ | <type_specifier> "[" <constant_expression> "]"\r
+*/\r
+parameter_type_specifier\r
+ parameter_type_specifier_1 .and .true .emit '\0' .and parameter_type_specifier_2;\r
+parameter_type_specifier_1\r
+ type_specifier_nospace .or type_specifier_space;\r
+parameter_type_specifier_2\r
+ parameter_type_specifier_3 .emit PARAMETER_ARRAY_PRESENT .or\r
+ .true .emit PARAMETER_ARRAY_NOT_PRESENT;\r
+parameter_type_specifier_3\r
+ lbracket .and constant_expression .and rbracket;\r
+\r
+/*\r
+ <init_declarator_list> ::= <single_declaration>\r
+ | <init_declarator_list> "," <identifier>\r
+ | <init_declarator_list> "," <identifier> "[" "]"\r
+ | <init_declarator_list> "," <identifier> "["\r
+ <constant_expression> "]"\r
+ | <init_declarator_list> "," <identifier> "="\r
+ <initializer>\r
+*/\r
+init_declarator_list\r
+ single_declaration .and .loop init_declarator_list_1 .emit DECLARATOR_NEXT .and\r
+ .true .emit DECLARATOR_NONE;\r
+init_declarator_list_1\r
+ comma .and identifier .emit VARIABLE_IDENTIFIER .and init_declarator_list_2;\r
+init_declarator_list_2\r
+ init_declarator_list_3 .or init_declarator_list_4 .or .true .emit VARIABLE_NONE;\r
+init_declarator_list_3\r
+ equals .and initializer .emit VARIABLE_INITIALIZER;\r
+init_declarator_list_4\r
+ lbracket .and init_declarator_list_5 .and rbracket;\r
+init_declarator_list_5\r
+ constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\r
+\r
+/*\r
+ <single_declaration> ::= <fully_specified_type>\r
+ | <fully_specified_type> <identifier>\r
+ | <fully_specified_type> <identifier> "[" "]"\r
+ | <fully_specified_type> <identifier> "["\r
+ <constant_expression> "]"\r
+ | <fully_specified_type> <identifier> "=" <initializer>\r
+*/\r
+single_declaration\r
+ single_declaration_nospace .or single_declaration_space;\r
+single_declaration_space\r
+ fully_specified_type_space .and single_declaration_space_1;\r
+single_declaration_nospace\r
+ fully_specified_type_nospace .and single_declaration_nospace_1;\r
+single_declaration_space_1\r
+ single_declaration_space_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\r
+single_declaration_nospace_1\r
+ single_declaration_nospace_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\r
+single_declaration_space_2\r
+ space .and identifier .and single_declaration_3;\r
+single_declaration_nospace_2\r
+ identifier .and single_declaration_3;\r
+single_declaration_3\r
+ single_declaration_4 .or single_declaration_5 .or .true .emit VARIABLE_NONE;\r
+single_declaration_4\r
+ equals .and initializer .emit VARIABLE_INITIALIZER;\r
+single_declaration_5\r
+ lbracket .and single_declaration_6 .and rbracket;\r
+single_declaration_6\r
+ constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\r
+\r
+/*\r
+ <fully_specified_type> ::= <type_specifier>\r
+ | <type_qualifier> <type_specifier>\r
+*/\r
+fully_specified_type_space\r
+ fully_specified_type_1 .and type_specifier_space;\r
+fully_specified_type_nospace\r
+ fully_specified_type_1 .and type_specifier_nospace;\r
+fully_specified_type_1\r
+ fully_specified_type_2 .or .true .emit TYPE_QUALIFIER_NONE;\r
+fully_specified_type_2\r
+ type_qualifier .and space;\r
+\r
+/*\r
+ <type_qualifier> ::= "const"\r
+ | "attribute" // Vertex only.\r
+ | "varying"\r
+ | "uniform"\r
+*/\r
+type_qualifier\r
+ "const" .emit TYPE_QUALIFIER_CONST .or\r
+ .if (shader_type == 2) "attribute" .emit TYPE_QUALIFIER_ATTRIBUTE .or\r
+ "varying" .emit TYPE_QUALIFIER_VARYING .or\r
+ "uniform" .emit TYPE_QUALIFIER_UNIFORM;\r
+\r
+/*\r
+ <type_specifier> ::= "void"\r
+ | "float"\r
+ | "int"\r
+ | "bool"\r
+ | "vec2"\r
+ | "vec3"\r
+ | "vec4"\r
+ | "bvec2"\r
+ | "bvec3"\r
+ | "bvec4"\r
+ | "ivec2"\r
+ | "ivec3"\r
+ | "ivec4"\r
+ | "mat2"\r
+ | "mat3"\r
+ | "mat4"\r
+ | "sampler1D"\r
+ | "sampler2D"\r
+ | "sampler3D"\r
+ | "samplerCube"\r
+ | "sampler1DShadow"\r
+ | "sampler2DShadow"\r
+ | <struct_specifier>\r
+ | <type_name>\r
+*/\r
+type_specifier_space\r
+ "void" .emit TYPE_SPECIFIER_VOID .or\r
+ "float" .emit TYPE_SPECIFIER_FLOAT .or\r
+ "int" .emit TYPE_SPECIFIER_INT .or\r
+ "bool" .emit TYPE_SPECIFIER_BOOL .or\r
+ "vec2" .emit TYPE_SPECIFIER_VEC2 .or\r
+ "vec3" .emit TYPE_SPECIFIER_VEC3 .or\r
+ "vec4" .emit TYPE_SPECIFIER_VEC4 .or\r
+ "bvec2" .emit TYPE_SPECIFIER_BVEC2 .or\r
+ "bvec3" .emit TYPE_SPECIFIER_BVEC3 .or\r
+ "bvec4" .emit TYPE_SPECIFIER_BVEC4 .or\r
+ "ivec2" .emit TYPE_SPECIFIER_IVEC2 .or\r
+ "ivec3" .emit TYPE_SPECIFIER_IVEC3 .or\r
+ "ivec4" .emit TYPE_SPECIFIER_IVEC4 .or\r
+ "mat2" .emit TYPE_SPECIFIER_MAT2 .or\r
+ "mat3" .emit TYPE_SPECIFIER_MAT3 .or\r
+ "mat4" .emit TYPE_SPECIFIER_MAT4 .or\r
+ "sampler1D" .emit TYPE_SPECIFIER_SAMPLER1D .or\r
+ "sampler2D" .emit TYPE_SPECIFIER_SAMPLER2D .or\r
+ "sampler3D" .emit TYPE_SPECIFIER_SAMPLER3D .or\r
+ "samplerCube" .emit TYPE_SPECIFIER_SAMPLERCUBE .or\r
+ "sampler1DShadow" .emit TYPE_SPECIFIER_SAMPLER1DSHADOW .or\r
+ "sampler2DShadow" .emit TYPE_SPECIFIER_SAMPLER2DSHADOW .or\r
+ type_name .emit TYPE_SPECIFIER_TYPENAME;\r
+type_specifier_nospace\r
+ struct_specifier .emit TYPE_SPECIFIER_STRUCT;\r
+\r
+/*\r
+ <struct_specifier> ::= "struct" <identifier> "{" <struct_declaration_list> "}"\r
+ | "struct" "{" <struct_declaration_list> "}"\r
+*/\r
+struct_specifier\r
+ "struct" .and struct_specifier_1 .and optional_space .and lbrace .error LBRACE_EXPECTED .and\r
+ struct_declaration_list .and rbrace .emit FIELD_NONE;\r
+struct_specifier_1\r
+ struct_specifier_2 .or .true .emit '\0';\r
+struct_specifier_2\r
+ space .and identifier;\r
+\r
+/*\r
+ <struct_declaration_list> ::= <struct_declaration>\r
+ | <struct_declaration_list> <struct_declaration>\r
+*/\r
+struct_declaration_list\r
+ struct_declaration .and .loop struct_declaration .emit FIELD_NEXT;\r
+\r
+/*\r
+ <struct_declaration> ::= <type_specifier> <struct_declarator_list> ";"\r
+*/\r
+struct_declaration\r
+ struct_declaration_nospace .or struct_declaration_space;\r
+struct_declaration_space\r
+ type_specifier_space .and space .and struct_declarator_list .and semicolon .emit FIELD_NONE;\r
+struct_declaration_nospace\r
+ type_specifier_nospace .and struct_declarator_list .and semicolon .emit FIELD_NONE;\r
+\r
+/*\r
+ <struct_declarator_list> ::= <struct_declarator>\r
+ | <struct_declarator_list> "," <struct_declarator>\r
+*/\r
+struct_declarator_list\r
+ struct_declarator .and .loop struct_declarator_list_1 .emit FIELD_NEXT;\r
+struct_declarator_list_1\r
+ comma .and struct_declarator;\r
+\r
+/*\r
+ <struct_declarator> ::= <identifier>\r
+ | <identifier> "[" <constant_expression> "]"\r
+*/\r
+struct_declarator\r
+ identifier .and struct_declarator_1;\r
+struct_declarator_1\r
+ struct_declarator_2 .emit FIELD_ARRAY .or .true .emit FIELD_NONE;\r
+struct_declarator_2\r
+ lbracket .and constant_expression .and rbracket;\r
+\r
+/*\r
+ <initializer> ::= <assignment_expression>\r
+*/\r
+initializer\r
+ assignment_expression .and .true .emit OP_END;\r
+\r
+/*\r
+ <declaration_statement> ::= <declaration>\r
+*/\r
+declaration_statement\r
+ declaration;\r
+\r
+/*\r
+ <statement> ::= <compound_statement>\r
+ | <simple_statement>\r
+*/\r
+statement\r
+ compound_statement .or simple_statement;\r
+statement_space\r
+ compound_statement .or statement_space_1;\r
+statement_space_1\r
+ space .and simple_statement;\r
+\r
+/*\r
+ <simple_statement> ::= <__asm_statement>\r
+ | <selection_statement>\r
+ | <iteration_statement>\r
+ | <jump_statement>\r
+ | <expression_statement>\r
+ | <declaration_statement>\r
+\r
+note: this is an extension to the standard language specification - normally slang disallows\r
+ use of __asm statements\r
+*/\r
+simple_statement\r
+ .if (parsing_builtin != 0) __asm_statement .emit OP_ASM .or\r
+ selection_statement .or\r
+ iteration_statement .or\r
+ jump_statement .or\r
+ expression_statement .emit OP_EXPRESSION .or\r
+ declaration_statement .emit OP_DECLARE;\r
+\r
+/*\r
+ <compound_statement> ::= "{" "}"\r
+ | "{" <statement_list> "}"\r
+*/\r
+compound_statement\r
+ compound_statement_1 .emit OP_BLOCK_BEGIN_NEW_SCOPE .and .true .emit OP_END;\r
+compound_statement_1\r
+ compound_statement_2 .or compound_statement_3;\r
+compound_statement_2\r
+ lbrace .and rbrace;\r
+compound_statement_3\r
+ lbrace .and statement_list .and rbrace;\r
+\r
+/*\r
+ <statement_no_new_scope> ::= <compound_statement_no_new_scope>\r
+ | <simple_statement>\r
+*/\r
+statement_no_new_scope\r
+ compound_statement_no_new_scope .or simple_statement;\r
+\r
+/*\r
+ <compound_statement_no_new_scope> ::= "{" "}"\r
+ | "{" <statement_list> "}"\r
+*/\r
+compound_statement_no_new_scope\r
+ compound_statement_no_new_scope_1 .emit OP_BLOCK_BEGIN_NO_NEW_SCOPE .and .true .emit OP_END;\r
+compound_statement_no_new_scope_1\r
+ compound_statement_no_new_scope_2 .or compound_statement_no_new_scope_3;\r
+compound_statement_no_new_scope_2\r
+ lbrace .and rbrace;\r
+compound_statement_no_new_scope_3\r
+ lbrace .and statement_list .and rbrace;\r
+\r
+/*\r
+ <statement_list> ::= <statement>\r
+ | <statement_list> <statement>\r
+*/\r
+statement_list\r
+ statement .and .loop statement;\r
+\r
+/*\r
+ <expression_statement> ::= ";"\r
+ | <expression> ";"\r
+*/\r
+expression_statement\r
+ expression_statement_1 .or expression_statement_2;\r
+expression_statement_1\r
+ semicolon .emit OP_PUSH_VOID .emit OP_END;\r
+expression_statement_2\r
+ expression .and semicolon .emit OP_END;\r
+\r
+/*\r
+ <selection_statement> ::= "if" "(" <expression> ")" <selection_rest_statement>\r
+*/\r
+selection_statement\r
+ "if" .emit OP_IF .and lparen .error LPAREN_EXPECTED .and expression .and\r
+ rparen .error RPAREN_EXPECTED .emit OP_END .and selection_rest_statement;\r
+\r
+/*\r
+ <selection_rest_statement> ::= <statement> "else" <statement>\r
+ | <statement>\r
+*/\r
+selection_rest_statement\r
+ statement .and selection_rest_statement_1;\r
+selection_rest_statement_1\r
+ selection_rest_statement_2 .or .true .emit OP_EXPRESSION .emit OP_PUSH_VOID .emit OP_END;\r
+selection_rest_statement_2\r
+ "else" .and optional_space .and statement;\r
+\r
+/*\r
+ <condition> ::= <expression>\r
+ | <fully_specified_type> <identifier> "=" <initializer>\r
+\r
+note: if <condition_1> is executed, the emit format must match <declaration> emit format\r
+*/\r
+condition\r
+ condition_1 .emit OP_DECLARE .emit DECLARATION_INIT_DECLARATOR_LIST .or\r
+ condition_3 .emit OP_EXPRESSION;\r
+condition_1\r
+ condition_1_nospace .or condition_1_space;\r
+condition_1_nospace\r
+ fully_specified_type_nospace .and condition_2;\r
+condition_1_space\r
+ fully_specified_type_space .and space .and condition_2;\r
+condition_2\r
+ identifier .emit VARIABLE_IDENTIFIER .and equals .emit VARIABLE_INITIALIZER .and\r
+ initializer .and .true .emit DECLARATOR_NONE;\r
+condition_3\r
+ expression .and .true .emit OP_END;\r
+\r
+/*\r
+ <iteration_statement> ::= "while" "(" <condition> ")" <statement_no_new_scope>\r
+ | "do" <statement> "while" "(" <expression> ")" ";"\r
+ | "for" "(" <for_init_statement> <for_rest_statement> ")"\r
+ <statement_no_new_scope>\r
+*/\r
+iteration_statement\r
+ iteration_statement_1 .or iteration_statement_2 .or iteration_statement_3;\r
+iteration_statement_1\r
+ "while" .emit OP_WHILE .and lparen .error LPAREN_EXPECTED .and condition .and\r
+ rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\r
+iteration_statement_2\r
+ "do" .emit OP_DO .and statement_space .and "while" .and lparen .error LPAREN_EXPECTED .and\r
+ expression .and rparen .error RPAREN_EXPECTED .emit OP_END .and semicolon;\r
+iteration_statement_3\r
+ "for" .emit OP_FOR .and lparen .error LPAREN_EXPECTED .and for_init_statement .and\r
+ for_rest_statement .and rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\r
+\r
+/*\r
+ <for_init_statement> ::= <expression_statement>\r
+ | <declaration_statement>\r
+*/\r
+for_init_statement\r
+ expression_statement .or declaration_statement;\r
+\r
+/*\r
+ <conditionopt> ::= <condition>\r
+ | ""\r
+\r
+note: <conditionopt> is used only by "for" statement - if <condition> is ommitted, parser\r
+ simulates default behaviour, that is simulates "true" expression\r
+*/\r
+conditionopt\r
+ condition .or\r
+ .true .emit OP_EXPRESSION .emit OP_PUSH_BOOL .emit 2 .emit '1' .emit '\0' .emit OP_END;\r
+\r
+/*\r
+ <for_rest_statement> ::= <conditionopt> ";"\r
+ | <conditionopt> ";" <expression>\r
+*/\r
+for_rest_statement\r
+ conditionopt .and semicolon .and for_rest_statement_1;\r
+for_rest_statement_1\r
+ for_rest_statement_2 .or .true .emit OP_PUSH_VOID .emit OP_END;\r
+for_rest_statement_2\r
+ expression .and .true .emit OP_END;\r
+\r
+/*\r
+ <jump_statement> ::= "continue" ";"\r
+ | "break" ";"\r
+ | "return" ";"\r
+ | "return" <expression> ";"\r
+ | "discard" ";" // Fragment shader only.\r
+*/\r
+jump_statement\r
+ jump_statement_1 .or jump_statement_2 .or jump_statement_3 .or jump_statement_4 .or\r
+ .if (shader_type == 1) jump_statement_5;\r
+jump_statement_1\r
+ "continue" .and semicolon .emit OP_CONTINUE;\r
+jump_statement_2\r
+ "break" .and semicolon .emit OP_BREAK;\r
+jump_statement_3\r
+ "return" .emit OP_RETURN .and optional_space .and expression .and semicolon .emit OP_END;\r
+jump_statement_4\r
+ "return" .emit OP_RETURN .and semicolon .emit OP_PUSH_VOID .emit OP_END;\r
+jump_statement_5\r
+ "discard" .and semicolon .emit OP_DISCARD;\r
+\r
+/*\r
+ <__asm_statement> ::= "__asm" <identifier> <asm_arguments> ";"\r
+\r
+note: this is an extension to the standard language specification - normally slang disallows\r
+ __asm statements\r
+*/\r
+__asm_statement\r
+ "__asm" .and space .and identifier .and space .and asm_arguments .and semicolon .emit OP_END;\r
+\r
+/*\r
+ <asm_arguments> ::= <identifier>\r
+ | <asm_arguments> "," <identifier>\r
+\r
+note: this is an extension to the standard language specification - normally slang disallows\r
+ __asm statements\r
+*/\r
+asm_arguments\r
+ variable_identifier .and .true .emit OP_END .and .loop asm_arguments_1;\r
+asm_arguments_1\r
+ comma .and variable_identifier .and .true .emit OP_END;\r
+\r
+/*\r
+ <translation_unit> ::= <external_declaration>\r
+ | <translation_unit> <external_declaration>\r
+*/\r
+translation_unit\r
+ optional_space .emit REVISION .and external_declaration .error INVALID_EXTERNAL_DECLARATION .and\r
+ .loop external_declaration .and optional_space .and\r
+ '\0' .error INVALID_EXTERNAL_DECLARATION .emit EXTERNAL_NULL;\r
+\r
+/*\r
+ <external_declaration> ::= <function_definition>\r
+ | <declaration>\r
+*/\r
+external_declaration\r
+ function_definition .emit EXTERNAL_FUNCTION_DEFINITION .or\r
+ declaration .emit EXTERNAL_DECLARATION;\r
+\r
+/*\r
+ <function_definition> :: <function_prototype> <compound_statement_no_new_scope>\r
+*/\r
+function_definition\r
+ function_prototype .and compound_statement_no_new_scope;\r
+\r
+/* helper rulez, not part of the official language syntax */\r
+\r
+digit_oct\r
+ '0'-'7';\r
+\r
+digit_dec\r
+ '0'-'9';\r
+\r
+digit_hex\r
+ '0'-'9' .or 'A'-'F' .or 'a'-'f';\r
+\r
+id_character_first\r
+ 'a'-'z' .or 'A'-'Z' .or '_';\r
+\r
+id_character_next\r
+ id_character_first .or digit_dec;\r
+\r
+identifier\r
+ id_character_first .emit * .and .loop id_character_next .emit * .and .true .emit '\0';\r
+\r
+float\r
+ float_1 .or float_2;\r
+float_1\r
+ float_fractional_constant .and float_optional_exponent_part;\r
+float_2\r
+ float_digit_sequence .and .true .emit '\0' .and float_exponent_part;\r
+\r
+float_fractional_constant\r
+ float_fractional_constant_1 .or float_fractional_constant_2 .or float_fractional_constant_3;\r
+float_fractional_constant_1\r
+ float_digit_sequence .and '.' .and float_digit_sequence;\r
+float_fractional_constant_2\r
+ float_digit_sequence .and '.' .and .true .emit '\0';\r
+float_fractional_constant_3\r
+ '.' .emit '\0' .and float_digit_sequence;\r
+\r
+float_optional_exponent_part\r
+ float_exponent_part .or .true .emit '\0';\r
+\r
+float_digit_sequence\r
+ digit_dec .emit * .and .loop digit_dec .emit * .and .true .emit '\0';\r
+\r
+float_exponent_part\r
+ float_exponent_part_1 .or float_exponent_part_2;\r
+float_exponent_part_1\r
+ 'e' .and float_optional_sign .and float_digit_sequence;\r
+float_exponent_part_2\r
+ 'E' .and float_optional_sign .and float_digit_sequence;\r
+\r
+float_optional_sign\r
+ float_sign .or .true;\r
+\r
+float_sign\r
+ '+' .or '-' .emit '-';\r
+\r
+integer\r
+ integer_hex .or integer_oct .or integer_dec;\r
+\r
+integer_hex\r
+ '0' .and integer_hex_1 .emit 0x10 .and digit_hex .emit * .and .loop digit_hex .emit * .and\r
+ .true .emit '\0';\r
+integer_hex_1\r
+ 'x' .or 'X';\r
+\r
+integer_oct\r
+ '0' .emit 8 .emit * .and .loop digit_oct .emit * .and .true .emit '\0';\r
+\r
+integer_dec\r
+ digit_dec .emit 10 .emit * .and .loop digit_dec .emit * .and .true .emit '\0';\r
+\r
+boolean\r
+ "true" .emit 2 .emit '1' .emit '\0' .or\r
+ "false" .emit 2 .emit '0' .emit '\0';\r
+\r
+type_name\r
+ identifier;\r
+\r
+field_selection\r
+ identifier;\r
+\r
+floatconstant\r
+ float .emit OP_PUSH_FLOAT;\r
+\r
+intconstant\r
+ integer .emit OP_PUSH_INT;\r
+\r
+boolconstant\r
+ boolean .emit OP_PUSH_BOOL;\r
+\r
+optional_space\r
+ .loop single_space;\r
+\r
+space\r
+ single_space .and .loop single_space;\r
+\r
+single_space\r
+ white_char .or c_style_comment_block .or cpp_style_comment_block;\r
+\r
+white_char\r
+ ' ' .or '\t' .or new_line .or '\v' .or '\f';\r
+\r
+new_line\r
+ cr_lf .or lf_cr .or '\n' .or '\r';\r
+\r
+cr_lf\r
+ '\r' .and '\n';\r
+\r
+lf_cr\r
+ '\n' .and '\r';\r
+\r
+c_style_comment_block\r
+ '/' .and '*' .and c_style_comment_rest;\r
+\r
+c_style_comment_rest\r
+ .loop c_style_comment_char_no_star .and c_style_comment_rest_1;\r
+c_style_comment_rest_1\r
+ c_style_comment_end .or c_style_comment_rest_2;\r
+c_style_comment_rest_2\r
+ '*' .and c_style_comment_rest;\r
+\r
+c_style_comment_char_no_star\r
+ '\x2B'-'\xFF' .or '\x01'-'\x29';\r
+\r
+c_style_comment_end\r
+ '*' .and '/';\r
+\r
+cpp_style_comment_block\r
+ '/' .and '/' .and cpp_style_comment_block_1;\r
+cpp_style_comment_block_1\r
+ cpp_style_comment_block_2 .or cpp_style_comment_block_3;\r
+cpp_style_comment_block_2\r
+ .loop cpp_style_comment_char .and new_line;\r
+cpp_style_comment_block_3\r
+ .loop cpp_style_comment_char;\r
+\r
+cpp_style_comment_char\r
+ '\x0E'-'\xFF' .or '\x01'-'\x09' .or '\x0B'-'\x0C';\r
+\r
+/* lexical rulez */\r
+\r
+/*ampersand\r
+ optional_space .and '&' .and optional_space;*/\r
+\r
+ampersandampersand\r
+ optional_space .and '&' .and '&' .and optional_space;\r
+\r
+/*ampersandequals\r
+ optional_space .and '&' .and '=' .and optional_space;*/\r
+\r
+/*bar\r
+ optional_space .and '|' .and optional_space;*/\r
+\r
+barbar\r
+ optional_space .and '|' .and '|' .and optional_space;\r
+\r
+/*barequals\r
+ optional_space .and '|' .and '=' .and optional_space;*/\r
+\r
+bang\r
+ optional_space .and '!' .and optional_space;\r
+\r
+bangequals\r
+ optional_space .and '!' .and '=' .and optional_space;\r
+\r
+/*caret\r
+ optional_space .and '^' .and optional_space;*/\r
+\r
+caretcaret\r
+ optional_space .and '^' .and '^' .and optional_space;\r
+\r
+/*caretequals\r
+ optional_space .and '^' .and '=' .and optional_space;*/\r
+\r
+colon\r
+ optional_space .and ':' .and optional_space;\r
+\r
+comma\r
+ optional_space .and ',' .and optional_space;\r
+\r
+dot\r
+ optional_space .and '.' .and optional_space;\r
+\r
+equals\r
+ optional_space .and '=' .and optional_space;\r
+\r
+equalsequals\r
+ optional_space .and '=' .and '=' .and optional_space;\r
+\r
+greater\r
+ optional_space .and '>' .and optional_space;\r
+\r
+greaterequals\r
+ optional_space .and '>' .and '=' .and optional_space;\r
+\r
+/*greatergreater\r
+ optional_space .and '>' .and '>' .and optional_space;*/\r
+\r
+/*greatergreaterequals\r
+ optional_space .and '>' .and '>' .and '=' .and optional_space;*/\r
+\r
+lbrace\r
+ optional_space .and '{' .and optional_space;\r
+\r
+lbracket\r
+ optional_space .and '[' .and optional_space;\r
+\r
+less\r
+ optional_space .and '<' .and optional_space;\r
+\r
+lessequals\r
+ optional_space .and '<' .and '=' .and optional_space;\r
+\r
+/*lessless\r
+ optional_space .and '<' .and '<' .and optional_space;*/\r
+\r
+/*lesslessequals\r
+ optional_space .and '<' .and '<' .and '=' .and optional_space;*/\r
+\r
+lparen\r
+ optional_space .and '(' .and optional_space;\r
+\r
+minus\r
+ optional_space .and '-' .and optional_space;\r
+\r
+minusequals\r
+ optional_space .and '-' .and '=' .and optional_space;\r
+\r
+minusminus\r
+ optional_space .and '-' .and '-' .and optional_space;\r
+\r
+/*percent\r
+ optional_space .and '%' .and optional_space;*/\r
+\r
+/*percentequals\r
+ optional_space .and '%' .and '=' .and optional_space;*/\r
+\r
+plus\r
+ optional_space .and '+' .and optional_space;\r
+\r
+plusequals\r
+ optional_space .and '+' .and '=' .and optional_space;\r
+\r
+plusplus\r
+ optional_space .and '+' .and '+' .and optional_space;\r
+\r
+question\r
+ optional_space .and '?' .and optional_space;\r
+\r
+rbrace\r
+ optional_space .and '}' .and optional_space;\r
+\r
+rbracket\r
+ optional_space .and ']' .and optional_space;\r
+\r
+rparen\r
+ optional_space .and ')' .and optional_space;\r
+\r
+semicolon\r
+ optional_space .and ';' .and optional_space;\r
+\r
+slash\r
+ optional_space .and '/' .and optional_space;\r
+\r
+slashequals\r
+ optional_space .and '/' .and '=' .and optional_space;\r
+\r
+star\r
+ optional_space .and '*' .and optional_space;\r
+\r
+starequals\r
+ optional_space .and '*' .and '=' .and optional_space;\r
+\r
+/*tilde\r
+ optional_space .and '~' .and optional_space;*/\r
+\r
+/* string rulez - these are used internally by the parser when parsing quoted strings */\r
+\r
+.string string_lexer;\r
+\r
+string_lexer\r
+ lex_first_identifier_character .and .loop lex_next_identifier_character;\r
+\r
+lex_first_identifier_character\r
+ 'a'-'z' .or 'A'-'Z' .or '_';\r
+\r
+lex_next_identifier_character\r
+ 'a'-'z' .or 'A'-'Z' .or '0'-'9' .or '_';\r
+\r
+/* error rulez - these are used by error messages */\r
+\r
+err_token\r
+ '~' .or '`' .or '!' .or '@' .or '#' .or '$' .or '%' .or '^' .or '&' .or '*' .or '(' .or ')' .or\r
+ '-' .or '+' .or '=' .or '|' .or '\\' .or '[' .or ']' .or '{' .or '}' .or ':' .or ';' .or '"' .or\r
+ '\'' .or '<' .or ',' .or '>' .or '.' .or '/' .or '?' .or err_identifier;\r
+\r
+err_identifier\r
+ id_character_first .and .loop id_character_next;\r
+\r
--- /dev/null
+".syntax translation_unit;\n"\r
+".emtcode REVISION 1\n"\r
+".emtcode EXTERNAL_NULL 0\n"\r
+".emtcode EXTERNAL_FUNCTION_DEFINITION 1\n"\r
+".emtcode EXTERNAL_DECLARATION 2\n"\r
+".emtcode DECLARATION_FUNCTION_PROTOTYPE 1\n"\r
+".emtcode DECLARATION_INIT_DECLARATOR_LIST 2\n"\r
+".emtcode FUNCTION_ORDINARY 0\n"\r
+".emtcode FUNCTION_CONSTRUCTOR 1\n"\r
+".emtcode FUNCTION_OPERATOR 2\n"\r
+".emtcode OPERATOR_ASSIGN 1\n"\r
+".emtcode OPERATOR_ADDASSIGN 2\n"\r
+".emtcode OPERATOR_SUBASSIGN 3\n"\r
+".emtcode OPERATOR_MULASSIGN 4\n"\r
+".emtcode OPERATOR_DIVASSIGN 5\n"\r
+".emtcode OPERATOR_LOGICALXOR 12\n"\r
+".emtcode OPERATOR_EQUAL 16\n"\r
+".emtcode OPERATOR_NOTEQUAL 17\n"\r
+".emtcode OPERATOR_LESS 18\n"\r
+".emtcode OPERATOR_GREATER 19\n"\r
+".emtcode OPERATOR_LESSEQUAL 20\n"\r
+".emtcode OPERATOR_GREATEREQUAL 21\n"\r
+".emtcode OPERATOR_MULTIPLY 24\n"\r
+".emtcode OPERATOR_DIVIDE 25\n"\r
+".emtcode OPERATOR_INCREMENT 27\n"\r
+".emtcode OPERATOR_DECREMENT 28\n"\r
+".emtcode OPERATOR_PLUS 29\n"\r
+".emtcode OPERATOR_MINUS 30\n"\r
+".emtcode OPERATOR_NOT 32\n"\r
+".emtcode DECLARATOR_NONE 0\n"\r
+".emtcode DECLARATOR_NEXT 1\n"\r
+".emtcode VARIABLE_NONE 0\n"\r
+".emtcode VARIABLE_IDENTIFIER 1\n"\r
+".emtcode VARIABLE_INITIALIZER 2\n"\r
+".emtcode VARIABLE_ARRAY_EXPLICIT 3\n"\r
+".emtcode VARIABLE_ARRAY_UNKNOWN 4\n"\r
+".emtcode TYPE_QUALIFIER_NONE 0\n"\r
+".emtcode TYPE_QUALIFIER_CONST 1\n"\r
+".emtcode TYPE_QUALIFIER_ATTRIBUTE 2\n"\r
+".emtcode TYPE_QUALIFIER_VARYING 3\n"\r
+".emtcode TYPE_QUALIFIER_UNIFORM 4\n"\r
+".emtcode TYPE_SPECIFIER_VOID 0\n"\r
+".emtcode TYPE_SPECIFIER_BOOL 1\n"\r
+".emtcode TYPE_SPECIFIER_BVEC2 2\n"\r
+".emtcode TYPE_SPECIFIER_BVEC3 3\n"\r
+".emtcode TYPE_SPECIFIER_BVEC4 4\n"\r
+".emtcode TYPE_SPECIFIER_INT 5\n"\r
+".emtcode TYPE_SPECIFIER_IVEC2 6\n"\r
+".emtcode TYPE_SPECIFIER_IVEC3 7\n"\r
+".emtcode TYPE_SPECIFIER_IVEC4 8\n"\r
+".emtcode TYPE_SPECIFIER_FLOAT 9\n"\r
+".emtcode TYPE_SPECIFIER_VEC2 10\n"\r
+".emtcode TYPE_SPECIFIER_VEC3 11\n"\r
+".emtcode TYPE_SPECIFIER_VEC4 12\n"\r
+".emtcode TYPE_SPECIFIER_MAT2 13\n"\r
+".emtcode TYPE_SPECIFIER_MAT3 14\n"\r
+".emtcode TYPE_SPECIFIER_MAT4 15\n"\r
+".emtcode TYPE_SPECIFIER_SAMPLER1D 16\n"\r
+".emtcode TYPE_SPECIFIER_SAMPLER2D 17\n"\r
+".emtcode TYPE_SPECIFIER_SAMPLER3D 18\n"\r
+".emtcode TYPE_SPECIFIER_SAMPLERCUBE 19\n"\r
+".emtcode TYPE_SPECIFIER_SAMPLER1DSHADOW 20\n"\r
+".emtcode TYPE_SPECIFIER_SAMPLER2DSHADOW 21\n"\r
+".emtcode TYPE_SPECIFIER_STRUCT 22\n"\r
+".emtcode TYPE_SPECIFIER_TYPENAME 23\n"\r
+".emtcode FIELD_NONE 0\n"\r
+".emtcode FIELD_NEXT 1\n"\r
+".emtcode FIELD_ARRAY 2\n"\r
+".emtcode OP_END 0\n"\r
+".emtcode OP_BLOCK_BEGIN_NO_NEW_SCOPE 1\n"\r
+".emtcode OP_BLOCK_BEGIN_NEW_SCOPE 2\n"\r
+".emtcode OP_DECLARE 3\n"\r
+".emtcode OP_ASM 4\n"\r
+".emtcode OP_BREAK 5\n"\r
+".emtcode OP_CONTINUE 6\n"\r
+".emtcode OP_DISCARD 7\n"\r
+".emtcode OP_RETURN 8\n"\r
+".emtcode OP_EXPRESSION 9\n"\r
+".emtcode OP_IF 10\n"\r
+".emtcode OP_WHILE 11\n"\r
+".emtcode OP_DO 12\n"\r
+".emtcode OP_FOR 13\n"\r
+".emtcode OP_PUSH_VOID 14\n"\r
+".emtcode OP_PUSH_BOOL 15\n"\r
+".emtcode OP_PUSH_INT 16\n"\r
+".emtcode OP_PUSH_FLOAT 17\n"\r
+".emtcode OP_PUSH_IDENTIFIER 18\n"\r
+".emtcode OP_SEQUENCE 19\n"\r
+".emtcode OP_ASSIGN 20\n"\r
+".emtcode OP_ADDASSIGN 21\n"\r
+".emtcode OP_SUBASSIGN 22\n"\r
+".emtcode OP_MULASSIGN 23\n"\r
+".emtcode OP_DIVASSIGN 24\n"\r
+".emtcode OP_SELECT 31\n"\r
+".emtcode OP_LOGICALOR 32\n"\r
+".emtcode OP_LOGICALXOR 33\n"\r
+".emtcode OP_LOGICALAND 34\n"\r
+".emtcode OP_EQUAL 38\n"\r
+".emtcode OP_NOTEQUAL 39\n"\r
+".emtcode OP_LESS 40\n"\r
+".emtcode OP_GREATER 41\n"\r
+".emtcode OP_LESSEQUAL 42\n"\r
+".emtcode OP_GREATEREQUAL 43\n"\r
+".emtcode OP_ADD 46\n"\r
+".emtcode OP_SUBTRACT 47\n"\r
+".emtcode OP_MULTIPLY 48\n"\r
+".emtcode OP_DIVIDE 49\n"\r
+".emtcode OP_PREINCREMENT 51\n"\r
+".emtcode OP_PREDECREMENT 52\n"\r
+".emtcode OP_PLUS 53\n"\r
+".emtcode OP_MINUS 54\n"\r
+".emtcode OP_NOT 56\n"\r
+".emtcode OP_SUBSCRIPT 57\n"\r
+".emtcode OP_CALL 58\n"\r
+".emtcode OP_FIELD 59\n"\r
+".emtcode OP_POSTINCREMENT 60\n"\r
+".emtcode OP_POSTDECREMENT 61\n"\r
+".emtcode PARAM_QUALIFIER_IN 0\n"\r
+".emtcode PARAM_QUALIFIER_OUT 1\n"\r
+".emtcode PARAM_QUALIFIER_INOUT 2\n"\r
+".emtcode PARAMETER_NONE 0\n"\r
+".emtcode PARAMETER_NEXT 1\n"\r
+".emtcode PARAMETER_ARRAY_NOT_PRESENT 0\n"\r
+".emtcode PARAMETER_ARRAY_PRESENT 1\n"\r
+".errtext INVALID_EXTERNAL_DECLARATION \"error 2001: invalid external declaration\"\n"\r
+".errtext INVALID_OPERATOR_OVERRIDE \"error 2002: invalid operator override\"\n"\r
+".errtext LBRACE_EXPECTED \"error 2003: '{' expected but '$err_token$' found\"\n"\r
+".errtext LPAREN_EXPECTED \"error 2004: '(' expected but '$err_token$' found\"\n"\r
+".errtext RPAREN_EXPECTED \"error 2005: ')' expected but '$err_token$' found\"\n"\r
+".regbyte parsing_builtin 0\n"\r
+".regbyte shader_type 0\n"\r
+"variable_identifier\n"\r
+" identifier .emit OP_PUSH_IDENTIFIER;\n"\r
+"primary_expression\n"\r
+" floatconstant .or boolconstant .or intconstant .or variable_identifier .or primary_expression_1;\n"\r
+"primary_expression_1\n"\r
+" lparen .and expression .and rparen;\n"\r
+"postfix_expression\n"\r
+" postfix_expression_1 .and .loop postfix_expression_2;\n"\r
+"postfix_expression_1\n"\r
+" function_call .or primary_expression;\n"\r
+"postfix_expression_2\n"\r
+" postfix_expression_3 .or postfix_expression_4 .or\n"\r
+" plusplus .emit OP_POSTINCREMENT .or\n"\r
+" minusminus .emit OP_POSTDECREMENT;\n"\r
+"postfix_expression_3\n"\r
+" lbracket .and integer_expression .and rbracket .emit OP_SUBSCRIPT;\n"\r
+"postfix_expression_4\n"\r
+" dot .and field_selection .emit OP_FIELD;\n"\r
+"integer_expression\n"\r
+" expression;\n"\r
+"function_call\n"\r
+" function_call_generic .emit OP_CALL .and .true .emit OP_END;\n"\r
+"function_call_generic\n"\r
+" function_call_generic_1 .or function_call_generic_2;\n"\r
+"function_call_generic_1\n"\r
+" function_call_header_with_parameters .and rparen .error RPAREN_EXPECTED;\n"\r
+"function_call_generic_2\n"\r
+" function_call_header_no_parameters .and rparen .error RPAREN_EXPECTED;\n"\r
+"function_call_header_no_parameters\n"\r
+" function_call_header .and function_call_header_no_parameters_1;\n"\r
+"function_call_header_no_parameters_1\n"\r
+" \"void\" .or .true;\n"\r
+"function_call_header_with_parameters\n"\r
+" function_call_header .and assignment_expression .and .true .emit OP_END .and\n"\r
+" .loop function_call_header_with_parameters_1;\n"\r
+"function_call_header_with_parameters_1\n"\r
+" comma .and assignment_expression .and .true .emit OP_END;\n"\r
+"function_call_header\n"\r
+" function_identifier .and lparen;\n"\r
+"function_identifier\n"\r
+" identifier;\n"\r
+"unary_expression\n"\r
+" postfix_expression .or unary_expression_1 .or unary_expression_2 .or unary_expression_3 .or\n"\r
+" unary_expression_4 .or unary_expression_5;\n"\r
+"unary_expression_1\n"\r
+" plusplus .and unary_expression .and .true .emit OP_PREINCREMENT;\n"\r
+"unary_expression_2\n"\r
+" minusminus .and unary_expression .and .true .emit OP_PREDECREMENT;\n"\r
+"unary_expression_3\n"\r
+" plus .and unary_expression .and .true .emit OP_PLUS;\n"\r
+"unary_expression_4\n"\r
+" minus .and unary_expression .and .true .emit OP_MINUS;\n"\r
+"unary_expression_5\n"\r
+" bang .and unary_expression .and .true .emit OP_NOT;\n"\r
+"multiplicative_expression\n"\r
+" unary_expression .and .loop multiplicative_expression_1;\n"\r
+"multiplicative_expression_1\n"\r
+" multiplicative_expression_2 .or multiplicative_expression_3;\n"\r
+"multiplicative_expression_2\n"\r
+" star .and unary_expression .and .true .emit OP_MULTIPLY;\n"\r
+"multiplicative_expression_3\n"\r
+" slash .and unary_expression .and .true .emit OP_DIVIDE;\n"\r
+"additive_expression\n"\r
+" multiplicative_expression .and .loop additive_expression_1;\n"\r
+"additive_expression_1\n"\r
+" additive_expression_2 .or additive_expression_3;\n"\r
+"additive_expression_2\n"\r
+" plus .and multiplicative_expression .and .true .emit OP_ADD;\n"\r
+"additive_expression_3\n"\r
+" minus .and multiplicative_expression .and .true .emit OP_SUBTRACT;\n"\r
+"shift_expression\n"\r
+" additive_expression;\n"\r
+"relational_expression\n"\r
+" shift_expression .and .loop relational_expression_1;\n"\r
+"relational_expression_1\n"\r
+" relational_expression_2 .or relational_expression_3 .or relational_expression_4 .or\n"\r
+" relational_expression_5;\n"\r
+"relational_expression_2\n"\r
+" lessequals .and shift_expression .and .true .emit OP_LESSEQUAL;\n"\r
+"relational_expression_3\n"\r
+" greaterequals .and shift_expression .and .true .emit OP_GREATEREQUAL;\n"\r
+"relational_expression_4\n"\r
+" less .and shift_expression .and .true .emit OP_LESS;\n"\r
+"relational_expression_5\n"\r
+" greater .and shift_expression .and .true .emit OP_GREATER;\n"\r
+"equality_expression\n"\r
+" relational_expression .and .loop equality_expression_1;\n"\r
+"equality_expression_1\n"\r
+" equality_expression_2 .or equality_expression_3;\n"\r
+"equality_expression_2\n"\r
+" equalsequals .and relational_expression .and .true .emit OP_EQUAL;\n"\r
+"equality_expression_3\n"\r
+" bangequals .and relational_expression .and .true .emit OP_NOTEQUAL;\n"\r
+"and_expression\n"\r
+" equality_expression;\n"\r
+"exclusive_or_expression\n"\r
+" and_expression;\n"\r
+"inclusive_or_expression\n"\r
+" exclusive_or_expression;\n"\r
+"logical_and_expression\n"\r
+" inclusive_or_expression .and .loop logical_and_expression_1;\n"\r
+"logical_and_expression_1\n"\r
+" ampersandampersand .and inclusive_or_expression .and .true .emit OP_LOGICALAND;\n"\r
+"logical_xor_expression\n"\r
+" logical_and_expression .and .loop logical_xor_expression_1;\n"\r
+"logical_xor_expression_1\n"\r
+" caretcaret .and logical_and_expression .and .true .emit OP_LOGICALXOR;\n"\r
+"logical_or_expression\n"\r
+" logical_xor_expression .and .loop logical_or_expression_1;\n"\r
+"logical_or_expression_1\n"\r
+" barbar .and logical_xor_expression .and .true .emit OP_LOGICALOR;\n"\r
+"conditional_expression\n"\r
+" logical_or_expression .and .loop conditional_expression_1;\n"\r
+"conditional_expression_1\n"\r
+" question .and expression .and colon .and conditional_expression .and .true .emit OP_SELECT;\n"\r
+"assignment_expression\n"\r
+" assignment_expression_1 .or assignment_expression_2 .or assignment_expression_3 .or\n"\r
+" assignment_expression_4 .or assignment_expression_5 .or conditional_expression;\n"\r
+"assignment_expression_1\n"\r
+" unary_expression .and equals .and assignment_expression .and .true .emit OP_ASSIGN;\n"\r
+"assignment_expression_2\n"\r
+" unary_expression .and starequals .and assignment_expression .and .true .emit OP_MULASSIGN;\n"\r
+"assignment_expression_3\n"\r
+" unary_expression .and slashequals .and assignment_expression .and .true .emit OP_DIVASSIGN;\n"\r
+"assignment_expression_4\n"\r
+" unary_expression .and plusequals .and assignment_expression .and .true .emit OP_ADDASSIGN;\n"\r
+"assignment_expression_5\n"\r
+" unary_expression .and minusequals .and assignment_expression .and .true .emit OP_SUBASSIGN;\n"\r
+"expression\n"\r
+" assignment_expression .and .loop expression_1;\n"\r
+"expression_1\n"\r
+" comma .and assignment_expression .and .true .emit OP_SEQUENCE;\n"\r
+"constant_expression\n"\r
+" conditional_expression .and .true .emit OP_END;\n"\r
+"declaration\n"\r
+" declaration_1 .or declaration_2;\n"\r
+"declaration_1\n"\r
+" function_prototype .emit DECLARATION_FUNCTION_PROTOTYPE .and semicolon;\n"\r
+"declaration_2\n"\r
+" init_declarator_list .emit DECLARATION_INIT_DECLARATOR_LIST .and semicolon;\n"\r
+"function_prototype\n"\r
+" function_declarator .and rparen .error RPAREN_EXPECTED .emit PARAMETER_NONE;\n"\r
+"function_declarator\n"\r
+" function_header_with_parameters .or function_header;\n"\r
+"function_header_with_parameters\n"\r
+" function_header .and parameter_declaration .and .loop function_header_with_parameters_1;\n"\r
+"function_header_with_parameters_1\n"\r
+" comma .and parameter_declaration;\n"\r
+"function_header\n"\r
+" function_header_nospace .or function_header_space;\n"\r
+"function_header_space\n"\r
+" fully_specified_type_space .and space .and function_decl_identifier .and lparen;\n"\r
+"function_header_nospace\n"\r
+" fully_specified_type_nospace .and function_decl_identifier .and lparen;\n"\r
+"function_decl_identifier\n"\r
+" .if (parsing_builtin != 0) __operator .emit FUNCTION_OPERATOR .or\n"\r
+" .if (parsing_builtin != 0) \"__constructor\" .emit FUNCTION_CONSTRUCTOR .or\n"\r
+" identifier .emit FUNCTION_ORDINARY;\n"\r
+"__operator\n"\r
+" \"__operator\" .and overriden_operator .error INVALID_OPERATOR_OVERRIDE;\n"\r
+"overriden_operator\n"\r
+" plusplus .emit OPERATOR_INCREMENT .or\n"\r
+" plusequals .emit OPERATOR_ADDASSIGN .or\n"\r
+" plus .emit OPERATOR_PLUS .or\n"\r
+" minusminus .emit OPERATOR_DECREMENT .or\n"\r
+" minusequals .emit OPERATOR_SUBASSIGN .or\n"\r
+" minus .emit OPERATOR_MINUS .or\n"\r
+" bangequals .emit OPERATOR_NOTEQUAL .or\n"\r
+" bang .emit OPERATOR_NOT .or\n"\r
+" starequals .emit OPERATOR_MULASSIGN .or\n"\r
+" star .emit OPERATOR_MULTIPLY .or\n"\r
+" slashequals .emit OPERATOR_DIVASSIGN .or\n"\r
+" slash .emit OPERATOR_DIVIDE .or\n"\r
+" lessequals .emit OPERATOR_LESSEQUAL .or\n"\r
+" \n"\r
+" \n"\r
+" less .emit OPERATOR_LESS .or\n"\r
+" greaterequals .emit OPERATOR_GREATEREQUAL .or\n"\r
+" \n"\r
+" \n"\r
+" greater .emit OPERATOR_GREATER .or\n"\r
+" equalsequals .emit OPERATOR_EQUAL .or\n"\r
+" equals .emit OPERATOR_ASSIGN .or\n"\r
+" \n"\r
+" \n"\r
+" \n"\r
+" \n"\r
+" \n"\r
+" \n"\r
+" \n"\r
+" \n"\r
+" caretcaret .emit OPERATOR_LOGICALXOR ;\n"\r
+"parameter_declarator\n"\r
+" parameter_declarator_nospace .or parameter_declarator_space;\n"\r
+"parameter_declarator_nospace\n"\r
+" type_specifier_nospace .and identifier .and parameter_declarator_1;\n"\r
+"parameter_declarator_space\n"\r
+" type_specifier_space .and space .and identifier .and parameter_declarator_1;\n"\r
+"parameter_declarator_1\n"\r
+" parameter_declarator_2 .emit PARAMETER_ARRAY_PRESENT .or\n"\r
+" .true .emit PARAMETER_ARRAY_NOT_PRESENT;\n"\r
+"parameter_declarator_2\n"\r
+" lbracket .and constant_expression .and rbracket;\n"\r
+"parameter_declaration\n"\r
+" parameter_declaration_1 .emit PARAMETER_NEXT;\n"\r
+"parameter_declaration_1\n"\r
+" parameter_declaration_2 .or parameter_declaration_3;\n"\r
+"parameter_declaration_2\n"\r
+" type_qualifier .and space .and parameter_qualifier .and parameter_declaration_4;\n"\r
+"parameter_declaration_3\n"\r
+" parameter_qualifier .emit TYPE_QUALIFIER_NONE .and parameter_declaration_4;\n"\r
+"parameter_declaration_4\n"\r
+" parameter_declarator .or parameter_type_specifier;\n"\r
+"parameter_qualifier\n"\r
+" parameter_qualifier_1 .or .true .emit PARAM_QUALIFIER_IN;\n"\r
+"parameter_qualifier_1\n"\r
+" parameter_qualifier_2 .and space;\n"\r
+"parameter_qualifier_2\n"\r
+" \"in\" .emit PARAM_QUALIFIER_IN .or\n"\r
+" \"out\" .emit PARAM_QUALIFIER_OUT .or\n"\r
+" \"inout\" .emit PARAM_QUALIFIER_INOUT;\n"\r
+"parameter_type_specifier\n"\r
+" parameter_type_specifier_1 .and .true .emit '\\0' .and parameter_type_specifier_2;\n"\r
+"parameter_type_specifier_1\n"\r
+" type_specifier_nospace .or type_specifier_space;\n"\r
+"parameter_type_specifier_2\n"\r
+" parameter_type_specifier_3 .emit PARAMETER_ARRAY_PRESENT .or\n"\r
+" .true .emit PARAMETER_ARRAY_NOT_PRESENT;\n"\r
+"parameter_type_specifier_3\n"\r
+" lbracket .and constant_expression .and rbracket;\n"\r
+"init_declarator_list\n"\r
+" single_declaration .and .loop init_declarator_list_1 .emit DECLARATOR_NEXT .and\n"\r
+" .true .emit DECLARATOR_NONE;\n"\r
+"init_declarator_list_1\n"\r
+" comma .and identifier .emit VARIABLE_IDENTIFIER .and init_declarator_list_2;\n"\r
+"init_declarator_list_2\n"\r
+" init_declarator_list_3 .or init_declarator_list_4 .or .true .emit VARIABLE_NONE;\n"\r
+"init_declarator_list_3\n"\r
+" equals .and initializer .emit VARIABLE_INITIALIZER;\n"\r
+"init_declarator_list_4\n"\r
+" lbracket .and init_declarator_list_5 .and rbracket;\n"\r
+"init_declarator_list_5\n"\r
+" constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\n"\r
+"single_declaration\n"\r
+" single_declaration_nospace .or single_declaration_space;\n"\r
+"single_declaration_space\n"\r
+" fully_specified_type_space .and single_declaration_space_1;\n"\r
+"single_declaration_nospace\n"\r
+" fully_specified_type_nospace .and single_declaration_nospace_1;\n"\r
+"single_declaration_space_1\n"\r
+" single_declaration_space_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\n"\r
+"single_declaration_nospace_1\n"\r
+" single_declaration_nospace_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\n"\r
+"single_declaration_space_2\n"\r
+" space .and identifier .and single_declaration_3;\n"\r
+"single_declaration_nospace_2\n"\r
+" identifier .and single_declaration_3;\n"\r
+"single_declaration_3\n"\r
+" single_declaration_4 .or single_declaration_5 .or .true .emit VARIABLE_NONE;\n"\r
+"single_declaration_4\n"\r
+" equals .and initializer .emit VARIABLE_INITIALIZER;\n"\r
+"single_declaration_5\n"\r
+" lbracket .and single_declaration_6 .and rbracket;\n"\r
+"single_declaration_6\n"\r
+" constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\n"\r
+"fully_specified_type_space\n"\r
+" fully_specified_type_1 .and type_specifier_space;\n"\r
+"fully_specified_type_nospace\n"\r
+" fully_specified_type_1 .and type_specifier_nospace;\n"\r
+"fully_specified_type_1\n"\r
+" fully_specified_type_2 .or .true .emit TYPE_QUALIFIER_NONE;\n"\r
+"fully_specified_type_2\n"\r
+" type_qualifier .and space;\n"\r
+"type_qualifier\n"\r
+" \"const\" .emit TYPE_QUALIFIER_CONST .or\n"\r
+" .if (shader_type == 2) \"attribute\" .emit TYPE_QUALIFIER_ATTRIBUTE .or\n"\r
+" \"varying\" .emit TYPE_QUALIFIER_VARYING .or\n"\r
+" \"uniform\" .emit TYPE_QUALIFIER_UNIFORM;\n"\r
+"type_specifier_space\n"\r
+" \"void\" .emit TYPE_SPECIFIER_VOID .or\n"\r
+" \"float\" .emit TYPE_SPECIFIER_FLOAT .or\n"\r
+" \"int\" .emit TYPE_SPECIFIER_INT .or\n"\r
+" \"bool\" .emit TYPE_SPECIFIER_BOOL .or\n"\r
+" \"vec2\" .emit TYPE_SPECIFIER_VEC2 .or\n"\r
+" \"vec3\" .emit TYPE_SPECIFIER_VEC3 .or\n"\r
+" \"vec4\" .emit TYPE_SPECIFIER_VEC4 .or\n"\r
+" \"bvec2\" .emit TYPE_SPECIFIER_BVEC2 .or\n"\r
+" \"bvec3\" .emit TYPE_SPECIFIER_BVEC3 .or\n"\r
+" \"bvec4\" .emit TYPE_SPECIFIER_BVEC4 .or\n"\r
+" \"ivec2\" .emit TYPE_SPECIFIER_IVEC2 .or\n"\r
+" \"ivec3\" .emit TYPE_SPECIFIER_IVEC3 .or\n"\r
+" \"ivec4\" .emit TYPE_SPECIFIER_IVEC4 .or\n"\r
+" \"mat2\" .emit TYPE_SPECIFIER_MAT2 .or\n"\r
+" \"mat3\" .emit TYPE_SPECIFIER_MAT3 .or\n"\r
+" \"mat4\" .emit TYPE_SPECIFIER_MAT4 .or\n"\r
+" \"sampler1D\" .emit TYPE_SPECIFIER_SAMPLER1D .or\n"\r
+" \"sampler2D\" .emit TYPE_SPECIFIER_SAMPLER2D .or\n"\r
+" \"sampler3D\" .emit TYPE_SPECIFIER_SAMPLER3D .or\n"\r
+" \"samplerCube\" .emit TYPE_SPECIFIER_SAMPLERCUBE .or\n"\r
+" \"sampler1DShadow\" .emit TYPE_SPECIFIER_SAMPLER1DSHADOW .or\n"\r
+" \"sampler2DShadow\" .emit TYPE_SPECIFIER_SAMPLER2DSHADOW .or\n"\r
+" type_name .emit TYPE_SPECIFIER_TYPENAME;\n"\r
+"type_specifier_nospace\n"\r
+" struct_specifier .emit TYPE_SPECIFIER_STRUCT;\n"\r
+"struct_specifier\n"\r
+" \"struct\" .and struct_specifier_1 .and optional_space .and lbrace .error LBRACE_EXPECTED .and\n"\r
+" struct_declaration_list .and rbrace .emit FIELD_NONE;\n"\r
+"struct_specifier_1\n"\r
+" struct_specifier_2 .or .true .emit '\\0';\n"\r
+"struct_specifier_2\n"\r
+" space .and identifier;\n"\r
+"struct_declaration_list\n"\r
+" struct_declaration .and .loop struct_declaration .emit FIELD_NEXT;\n"\r
+"struct_declaration\n"\r
+" struct_declaration_nospace .or struct_declaration_space;\n"\r
+"struct_declaration_space\n"\r
+" type_specifier_space .and space .and struct_declarator_list .and semicolon .emit FIELD_NONE;\n"\r
+"struct_declaration_nospace\n"\r
+" type_specifier_nospace .and struct_declarator_list .and semicolon .emit FIELD_NONE;\n"\r
+"struct_declarator_list\n"\r
+" struct_declarator .and .loop struct_declarator_list_1 .emit FIELD_NEXT;\n"\r
+"struct_declarator_list_1\n"\r
+" comma .and struct_declarator;\n"\r
+"struct_declarator\n"\r
+" identifier .and struct_declarator_1;\n"\r
+"struct_declarator_1\n"\r
+" struct_declarator_2 .emit FIELD_ARRAY .or .true .emit FIELD_NONE;\n"\r
+"struct_declarator_2\n"\r
+" lbracket .and constant_expression .and rbracket;\n"\r
+"initializer\n"\r
+" assignment_expression .and .true .emit OP_END;\n"\r
+"declaration_statement\n"\r
+" declaration;\n"\r
+"statement\n"\r
+" compound_statement .or simple_statement;\n"\r
+"statement_space\n"\r
+" compound_statement .or statement_space_1;\n"\r
+"statement_space_1\n"\r
+" space .and simple_statement;\n"\r
+"simple_statement\n"\r
+" .if (parsing_builtin != 0) __asm_statement .emit OP_ASM .or\n"\r
+" selection_statement .or\n"\r
+" iteration_statement .or\n"\r
+" jump_statement .or\n"\r
+" expression_statement .emit OP_EXPRESSION .or\n"\r
+" declaration_statement .emit OP_DECLARE;\n"\r
+"compound_statement\n"\r
+" compound_statement_1 .emit OP_BLOCK_BEGIN_NEW_SCOPE .and .true .emit OP_END;\n"\r
+"compound_statement_1\n"\r
+" compound_statement_2 .or compound_statement_3;\n"\r
+"compound_statement_2\n"\r
+" lbrace .and rbrace;\n"\r
+"compound_statement_3\n"\r
+" lbrace .and statement_list .and rbrace;\n"\r
+"statement_no_new_scope\n"\r
+" compound_statement_no_new_scope .or simple_statement;\n"\r
+"compound_statement_no_new_scope\n"\r
+" compound_statement_no_new_scope_1 .emit OP_BLOCK_BEGIN_NO_NEW_SCOPE .and .true .emit OP_END;\n"\r
+"compound_statement_no_new_scope_1\n"\r
+" compound_statement_no_new_scope_2 .or compound_statement_no_new_scope_3;\n"\r
+"compound_statement_no_new_scope_2\n"\r
+" lbrace .and rbrace;\n"\r
+"compound_statement_no_new_scope_3\n"\r
+" lbrace .and statement_list .and rbrace;\n"\r
+"statement_list\n"\r
+" statement .and .loop statement;\n"\r
+"expression_statement\n"\r
+" expression_statement_1 .or expression_statement_2;\n"\r
+"expression_statement_1\n"\r
+" semicolon .emit OP_PUSH_VOID .emit OP_END;\n"\r
+"expression_statement_2\n"\r
+" expression .and semicolon .emit OP_END;\n"\r
+"selection_statement\n"\r
+" \"if\" .emit OP_IF .and lparen .error LPAREN_EXPECTED .and expression .and\n"\r
+" rparen .error RPAREN_EXPECTED .emit OP_END .and selection_rest_statement;\n"\r
+"selection_rest_statement\n"\r
+" statement .and selection_rest_statement_1;\n"\r
+"selection_rest_statement_1\n"\r
+" selection_rest_statement_2 .or .true .emit OP_EXPRESSION .emit OP_PUSH_VOID .emit OP_END;\n"\r
+"selection_rest_statement_2\n"\r
+" \"else\" .and optional_space .and statement;\n"\r
+"condition\n"\r
+" condition_1 .emit OP_DECLARE .emit DECLARATION_INIT_DECLARATOR_LIST .or\n"\r
+" condition_3 .emit OP_EXPRESSION;\n"\r
+"condition_1\n"\r
+" condition_1_nospace .or condition_1_space;\n"\r
+"condition_1_nospace\n"\r
+" fully_specified_type_nospace .and condition_2;\n"\r
+"condition_1_space\n"\r
+" fully_specified_type_space .and space .and condition_2;\n"\r
+"condition_2\n"\r
+" identifier .emit VARIABLE_IDENTIFIER .and equals .emit VARIABLE_INITIALIZER .and\n"\r
+" initializer .and .true .emit DECLARATOR_NONE;\n"\r
+"condition_3\n"\r
+" expression .and .true .emit OP_END;\n"\r
+"iteration_statement\n"\r
+" iteration_statement_1 .or iteration_statement_2 .or iteration_statement_3;\n"\r
+"iteration_statement_1\n"\r
+" \"while\" .emit OP_WHILE .and lparen .error LPAREN_EXPECTED .and condition .and\n"\r
+" rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\n"\r
+"iteration_statement_2\n"\r
+" \"do\" .emit OP_DO .and statement_space .and \"while\" .and lparen .error LPAREN_EXPECTED .and\n"\r
+" expression .and rparen .error RPAREN_EXPECTED .emit OP_END .and semicolon;\n"\r
+"iteration_statement_3\n"\r
+" \"for\" .emit OP_FOR .and lparen .error LPAREN_EXPECTED .and for_init_statement .and\n"\r
+" for_rest_statement .and rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\n"\r
+"for_init_statement\n"\r
+" expression_statement .or declaration_statement;\n"\r
+"conditionopt\n"\r
+" condition .or\n"\r
+" .true .emit OP_EXPRESSION .emit OP_PUSH_BOOL .emit 2 .emit '1' .emit '\\0' .emit OP_END;\n"\r
+"for_rest_statement\n"\r
+" conditionopt .and semicolon .and for_rest_statement_1;\n"\r
+"for_rest_statement_1\n"\r
+" for_rest_statement_2 .or .true .emit OP_PUSH_VOID .emit OP_END;\n"\r
+"for_rest_statement_2\n"\r
+" expression .and .true .emit OP_END;\n"\r
+"jump_statement\n"\r
+" jump_statement_1 .or jump_statement_2 .or jump_statement_3 .or jump_statement_4 .or\n"\r
+" .if (shader_type == 1) jump_statement_5;\n"\r
+"jump_statement_1\n"\r
+" \"continue\" .and semicolon .emit OP_CONTINUE;\n"\r
+"jump_statement_2\n"\r
+" \"break\" .and semicolon .emit OP_BREAK;\n"\r
+"jump_statement_3\n"\r
+" \"return\" .emit OP_RETURN .and optional_space .and expression .and semicolon .emit OP_END;\n"\r
+"jump_statement_4\n"\r
+" \"return\" .emit OP_RETURN .and semicolon .emit OP_PUSH_VOID .emit OP_END;\n"\r
+"jump_statement_5\n"\r
+" \"discard\" .and semicolon .emit OP_DISCARD;\n"\r
+"__asm_statement\n"\r
+" \"__asm\" .and space .and identifier .and space .and asm_arguments .and semicolon .emit OP_END;\n"\r
+"asm_arguments\n"\r
+" variable_identifier .and .true .emit OP_END .and .loop asm_arguments_1;\n"\r
+"asm_arguments_1\n"\r
+" comma .and variable_identifier .and .true .emit OP_END;\n"\r
+"translation_unit\n"\r
+" optional_space .emit REVISION .and external_declaration .error INVALID_EXTERNAL_DECLARATION .and\n"\r
+" .loop external_declaration .and optional_space .and\n"\r
+" '\\0' .error INVALID_EXTERNAL_DECLARATION .emit EXTERNAL_NULL;\n"\r
+"external_declaration\n"\r
+" function_definition .emit EXTERNAL_FUNCTION_DEFINITION .or\n"\r
+" declaration .emit EXTERNAL_DECLARATION;\n"\r
+"function_definition\n"\r
+" function_prototype .and compound_statement_no_new_scope;\n"\r
+"digit_oct\n"\r
+" '0'-'7';\n"\r
+"digit_dec\n"\r
+" '0'-'9';\n"\r
+"digit_hex\n"\r
+" '0'-'9' .or 'A'-'F' .or 'a'-'f';\n"\r
+"id_character_first\n"\r
+" 'a'-'z' .or 'A'-'Z' .or '_';\n"\r
+"id_character_next\n"\r
+" id_character_first .or digit_dec;\n"\r
+"identifier\n"\r
+" id_character_first .emit * .and .loop id_character_next .emit * .and .true .emit '\\0';\n"\r
+"float\n"\r
+" float_1 .or float_2;\n"\r
+"float_1\n"\r
+" float_fractional_constant .and float_optional_exponent_part;\n"\r
+"float_2\n"\r
+" float_digit_sequence .and .true .emit '\\0' .and float_exponent_part;\n"\r
+"float_fractional_constant\n"\r
+" float_fractional_constant_1 .or float_fractional_constant_2 .or float_fractional_constant_3;\n"\r
+"float_fractional_constant_1\n"\r
+" float_digit_sequence .and '.' .and float_digit_sequence;\n"\r
+"float_fractional_constant_2\n"\r
+" float_digit_sequence .and '.' .and .true .emit '\\0';\n"\r
+"float_fractional_constant_3\n"\r
+" '.' .emit '\\0' .and float_digit_sequence;\n"\r
+"float_optional_exponent_part\n"\r
+" float_exponent_part .or .true .emit '\\0';\n"\r
+"float_digit_sequence\n"\r
+" digit_dec .emit * .and .loop digit_dec .emit * .and .true .emit '\\0';\n"\r
+"float_exponent_part\n"\r
+" float_exponent_part_1 .or float_exponent_part_2;\n"\r
+"float_exponent_part_1\n"\r
+" 'e' .and float_optional_sign .and float_digit_sequence;\n"\r
+"float_exponent_part_2\n"\r
+" 'E' .and float_optional_sign .and float_digit_sequence;\n"\r
+"float_optional_sign\n"\r
+" float_sign .or .true;\n"\r
+"float_sign\n"\r
+" '+' .or '-' .emit '-';\n"\r
+"integer\n"\r
+" integer_hex .or integer_oct .or integer_dec;\n"\r
+"integer_hex\n"\r
+" '0' .and integer_hex_1 .emit 0x10 .and digit_hex .emit * .and .loop digit_hex .emit * .and\n"\r
+" .true .emit '\\0';\n"\r
+"integer_hex_1\n"\r
+" 'x' .or 'X';\n"\r
+"integer_oct\n"\r
+" '0' .emit 8 .emit * .and .loop digit_oct .emit * .and .true .emit '\\0';\n"\r
+"integer_dec\n"\r
+" digit_dec .emit 10 .emit * .and .loop digit_dec .emit * .and .true .emit '\\0';\n"\r
+"boolean\n"\r
+" \"true\" .emit 2 .emit '1' .emit '\\0' .or\n"\r
+" \"false\" .emit 2 .emit '0' .emit '\\0';\n"\r
+"type_name\n"\r
+" identifier;\n"\r
+"field_selection\n"\r
+" identifier;\n"\r
+"floatconstant\n"\r
+" float .emit OP_PUSH_FLOAT;\n"\r
+"intconstant\n"\r
+" integer .emit OP_PUSH_INT;\n"\r
+"boolconstant\n"\r
+" boolean .emit OP_PUSH_BOOL;\n"\r
+"optional_space\n"\r
+" .loop single_space;\n"\r
+"space\n"\r
+" single_space .and .loop single_space;\n"\r
+"single_space\n"\r
+" white_char .or c_style_comment_block .or cpp_style_comment_block;\n"\r
+"white_char\n"\r
+" ' ' .or '\\t' .or new_line .or '\\v' .or '\\f';\n"\r
+"new_line\n"\r
+" cr_lf .or lf_cr .or '\\n' .or '\\r';\n"\r
+"cr_lf\n"\r
+" '\\r' .and '\\n';\n"\r
+"lf_cr\n"\r
+" '\\n' .and '\\r';\n"\r
+"c_style_comment_block\n"\r
+" '/' .and '*' .and c_style_comment_rest;\n"\r
+"c_style_comment_rest\n"\r
+" .loop c_style_comment_char_no_star .and c_style_comment_rest_1;\n"\r
+"c_style_comment_rest_1\n"\r
+" c_style_comment_end .or c_style_comment_rest_2;\n"\r
+"c_style_comment_rest_2\n"\r
+" '*' .and c_style_comment_rest;\n"\r
+"c_style_comment_char_no_star\n"\r
+" '\\x2B'-'\\xFF' .or '\\x01'-'\\x29';\n"\r
+"c_style_comment_end\n"\r
+" '*' .and '/';\n"\r
+"cpp_style_comment_block\n"\r
+" '/' .and '/' .and cpp_style_comment_block_1;\n"\r
+"cpp_style_comment_block_1\n"\r
+" cpp_style_comment_block_2 .or cpp_style_comment_block_3;\n"\r
+"cpp_style_comment_block_2\n"\r
+" .loop cpp_style_comment_char .and new_line;\n"\r
+"cpp_style_comment_block_3\n"\r
+" .loop cpp_style_comment_char;\n"\r
+"cpp_style_comment_char\n"\r
+" '\\x0E'-'\\xFF' .or '\\x01'-'\\x09' .or '\\x0B'-'\\x0C';\n"\r
+"ampersandampersand\n"\r
+" optional_space .and '&' .and '&' .and optional_space;\n"\r
+"barbar\n"\r
+" optional_space .and '|' .and '|' .and optional_space;\n"\r
+"bang\n"\r
+" optional_space .and '!' .and optional_space;\n"\r
+"bangequals\n"\r
+" optional_space .and '!' .and '=' .and optional_space;\n"\r
+"caretcaret\n"\r
+" optional_space .and '^' .and '^' .and optional_space;\n"\r
+"colon\n"\r
+" optional_space .and ':' .and optional_space;\n"\r
+"comma\n"\r
+" optional_space .and ',' .and optional_space;\n"\r
+"dot\n"\r
+" optional_space .and '.' .and optional_space;\n"\r
+"equals\n"\r
+" optional_space .and '=' .and optional_space;\n"\r
+"equalsequals\n"\r
+" optional_space .and '=' .and '=' .and optional_space;\n"\r
+"greater\n"\r
+" optional_space .and '>' .and optional_space;\n"\r
+"greaterequals\n"\r
+" optional_space .and '>' .and '=' .and optional_space;\n"\r
+"lbrace\n"\r
+" optional_space .and '{' .and optional_space;\n"\r
+"lbracket\n"\r
+" optional_space .and '[' .and optional_space;\n"\r
+"less\n"\r
+" optional_space .and '<' .and optional_space;\n"\r
+"lessequals\n"\r
+" optional_space .and '<' .and '=' .and optional_space;\n"\r
+"lparen\n"\r
+" optional_space .and '(' .and optional_space;\n"\r
+"minus\n"\r
+" optional_space .and '-' .and optional_space;\n"\r
+"minusequals\n"\r
+" optional_space .and '-' .and '=' .and optional_space;\n"\r
+"minusminus\n"\r
+" optional_space .and '-' .and '-' .and optional_space;\n"\r
+"plus\n"\r
+" optional_space .and '+' .and optional_space;\n"\r
+"plusequals\n"\r
+" optional_space .and '+' .and '=' .and optional_space;\n"\r
+"plusplus\n"\r
+" optional_space .and '+' .and '+' .and optional_space;\n"\r
+"question\n"\r
+" optional_space .and '?' .and optional_space;\n"\r
+"rbrace\n"\r
+" optional_space .and '}' .and optional_space;\n"\r
+"rbracket\n"\r
+" optional_space .and ']' .and optional_space;\n"\r
+"rparen\n"\r
+" optional_space .and ')' .and optional_space;\n"\r
+"semicolon\n"\r
+" optional_space .and ';' .and optional_space;\n"\r
+"slash\n"\r
+" optional_space .and '/' .and optional_space;\n"\r
+"slashequals\n"\r
+" optional_space .and '/' .and '=' .and optional_space;\n"\r
+"star\n"\r
+" optional_space .and '*' .and optional_space;\n"\r
+"starequals\n"\r
+" optional_space .and '*' .and '=' .and optional_space;\n"\r
+".string string_lexer;\n"\r
+"string_lexer\n"\r
+" lex_first_identifier_character .and .loop lex_next_identifier_character;\n"\r
+"lex_first_identifier_character\n"\r
+" 'a'-'z' .or 'A'-'Z' .or '_';\n"\r
+"lex_next_identifier_character\n"\r
+" 'a'-'z' .or 'A'-'Z' .or '0'-'9' .or '_';\n"\r
+"err_token\n"\r
+" '~' .or '`' .or '!' .or '@' .or '#' .or '$' .or '%' .or '^' .or '&' .or '*' .or '(' .or ')' .or\n"\r
+" '-' .or '+' .or '=' .or '|' .or '\\\\' .or '[' .or ']' .or '{' .or '}' .or ':' .or ';' .or '\"' .or\n"\r
+" '\\'' .or '<' .or ',' .or '>' .or '.' .or '/' .or '?' .or err_identifier;\n"\r
+"err_identifier\n"\r
+" id_character_first .and .loop id_character_next;\n"\r
+""
\ No newline at end of file
--- /dev/null
+
+//
+// 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.10, rev. 59
+//
+// 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\92t 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_MaxTextureCoords
+varying float gl_FogFragCoord;
+
+//
+// For gl_FogFragCoord, the value written will be used as the \93c\94 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 \93c\94, 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 an integral constant
+// expressions, or this array must be re-declared by the shader with a size. The size can be
+// at most gl_MaxTextureCoords. 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:
+//
+// \95 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.
+//
+// \95 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.
+//
+// \95 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\92s
+// 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;
+}
+
+//
+// 8.7 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 that represents a depth texture with depth
+// comparisons turned on, then results are undefined. If a shadow texture call is made to a sampler
+// that represents a depth texture with depth comparisions turned off, the results are undefined.
+// If a shadow texture call is made to a sampler that does not represent a depth texture, then
+// results are 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 \93Lod\94 are allowed only in a vertex shader. For the \93Lod\94 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 \931D\94 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);
+}
+
+++ /dev/null
-
-//
-// 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.10, rev. 59
-//
-// 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.3
-const int gl_MaxTextureCoords = 2; // ARB_fragment_program
-const int gl_MaxVertexAttribs = 16; // ARB_vertex_shader
-const int gl_MaxVertexUniformComponents = 512; // ARB_vertex_shader
-const int gl_MaxVaryingFloats = 32; // ARB_vertex_shader
-const int gl_MaxVertexTextureImageUnits = 0; // ARB_vertex_shader
-const int gl_MaxCombinedTextureImageUnits = 2; // ARB_vertex_shader
-const int gl_MaxTextureImageUnits = 2; // ARB_fragment_shader
-const int gl_MaxFragmentUniformComponents = 64; // ARB_fragment_shader
-const int gl_MaxDrawBuffers = 1; // proposed ARB_draw_buffers
-
-//
-// 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 mat4 gl_TextureMatrix[gl_MaxTextureCoords];
-
-//
-// Derived matrix state that provides inverse and transposed versions
-// of the matrices above. Poorly conditioned matrices may result
-// in unpredictable values in their inverse forms.
-//
-uniform mat3 gl_NormalMatrix; // transpose of the inverse of the
- // upper leftmost 3x3 of gl_ModelViewMatrix
-
-uniform mat4 gl_ModelViewMatrixInverse;
-uniform mat4 gl_ProjectionMatrixInverse;
-uniform mat4 gl_ModelViewProjectionMatrixInverse;
-uniform mat4 gl_TextureMatrixInverse[gl_MaxTextureCoords];
-
-uniform mat4 gl_ModelViewMatrixTranspose;
-uniform mat4 gl_ProjectionMatrixTranspose;
-uniform mat4 gl_ModelViewProjectionMatrixTranspose;
-uniform mat4 gl_TextureMatrixTranspose[gl_MaxTextureCoords];
-
-uniform mat4 gl_ModelViewMatrixInverseTranspose;
-uniform mat4 gl_ProjectionMatrixInverseTranspose;
-uniform mat4 gl_ModelViewProjectionMatrixInverseTranspose;
-uniform mat4 gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];
-
-//
-// 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];
-
-//
-// Texture Environment and Generation, p. 152, p. 40-42.
-//
-
-uniform vec4 gl_TextureEnvColor[gl_MaxTextureImageUnits];
-uniform vec4 gl_EyePlaneS[gl_MaxTextureCoords];
-uniform vec4 gl_EyePlaneT[gl_MaxTextureCoords];
-uniform vec4 gl_EyePlaneR[gl_MaxTextureCoords];
-uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoords];
-uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoords];
-uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoords];
-uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoords];
-uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoords];
-
-//
-// Fog p. 161
-//
-
-struct gl_FogParameters {
- vec4 color;
- float density;
- float start;
- float end;
- float scale; // Derived: 1.0 / (end - start)
-};
-
-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:
-//
-// \95 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.
-//
-// \95 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.
-//
-// \95 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.
-//
-
-//
-// 8.1 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. The description is per component.
-//
-
-//
-// 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
-// [\96PI/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 [\96PI, 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 [\96PI/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));
-}
-
-//
-// 8.2 Exponential Functions
-//
-// These all operate component-wise. The description is per component.
-//
-
-//
-// Returns x raised to the y power, i.e., x^y.
-// Results are undefined if x < 0.
-// Results are undefined if x = 0 and y <= 0.
-//
-// 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 the natural exponentiation of x, i.e., e^x.
-//
-
-float exp (float x) {
- return pow (2.71828183, x);
-}
-vec2 exp (vec2 x) {
- return vec2 (exp (x.x), exp (x.y));
-}
-vec3 exp (vec3 x) {
- return vec3 (exp (x.x), exp (x.y), exp (x.z));
-}
-vec4 exp (vec4 x) {
- return vec4 (exp (x.x), exp (x.y), exp (x.z), exp (x.w));
-}
-
-//
-// Returns the natural logarithm of x, i.e., returns the value y which satisfies the equation
-// x = e^y.
-// Results are undefined if x <= 0.
-//
-
-float log (float x) {
- return log2 (x) / log2 (2.71828183);
-}
-vec2 log (vec2 x) {
- return vec2 (log (x.x), log (x.y));
-}
-vec3 log (vec3 x) {
- return vec3 (log (x.x), log (x.y), log (x.z));
-}
-vec4 log (vec4 x) {
- return vec4 (log (x.x), log (x.y), log (x.z), log (x.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 logarithm of x, i.e., returns the value y which satisfies the equation
-// x = 2^y.
-// Results are undefined if x <= 0.
-//
-// 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.
-// Results are undefined if x < 0.
-//
-
-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.
-// Results are undefined if x <= 0.
-//
-
-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));
-}
-
-//
-// 8.3 Common Functions
-//
-// These all operate component-wise. The description is per component.
-//
-
-//
-// Returns x if x >= 0, otherwise it returns \96x
-//
-
-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 \961.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 \96 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 \96 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 \96 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 \96 edge0) / (edge1 \96 edge0), 0, 1);
-// return t * t * (3 \96 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));
-}
-
-//
-// 8.4 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 \96 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 \96N
-//
-
-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 must already 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;
-}
-
-//
-// For the incident vector I and surface normal N, and the ratio of inidices of refraction eta,
-// return the refraction vector. The returned result is computed by
-//
-// k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I))
-// if (k < 0.0)
-// result = genType (0.0)
-// else
-// result = eta * I - (eta * dot (N, I) + sqrt (k)) * N
-//
-// The input parameters for the incident vector I and the surface normal N must already be
-// normalized to get the desired results.
-//
-
-float refract (float I, float N, float eta) {
- const float 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;
-}
-vec2 refract (vec2 I, vec2 N, float eta) {
- const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
- if (k < 0.0)
- return vec2 (0.0);
- return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
-}
-vec3 refract (vec3 I, vec3 N, float eta) {
- const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
- if (k < 0.0)
- return vec3 (0.0);
- return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
-}
-vec4 refract (vec4 I, vec4 N, float eta) {
- const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
- if (k < 0.0)
- return vec4 (0.0);
- return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
-}
-
-//
-// 8.5 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
- );
-}
-
-//
-// 8.6 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);
-}
-
-//
-// 8.7 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 that represents a depth texture with depth
-// comparisons turned on, then results are undefined. If a shadow texture call is made to a sampler
-// that represents a depth texture with depth comparisions turned off, the results are undefined.
-// If a shadow texture call is made to a sampler that does not represent a depth texture, then
-// results are 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 \93Lod\94 are allowed only in a vertex shader. For the \93Lod\94 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 \931D\94 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));
-}
-
-//
-// 8.9 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], and cover at least the range [-0.6, 0.6],
-// with a gaussian-like distribution.
-// \95 The return value(s) have an overall average of 0.0
-// \95 They are repeatable, in that a particular input value will always produce the same return value
-// \95 They are statistically invariant under rotation (i.e., no matter how the domain is rotated, it
-// has the same statistical character)
-// \95 They have a statistical invariance under translation (i.e., no matter how the domain is
-// translated, it has the same statistical character)
-// \95 They typically give different results under translation.
-// - The spatial frequency is narrowly concentrated, centered somewhere between 0.5 to 1.0.
-//
-
-//
-// 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);
-}
-
+++ /dev/null
-
-//
-// This file defines nearly all constructors and operators for built-in data types, using
-// extended language syntax. In general, compiler treats constructors and operators as
-// ordinary functions with some exceptions. For example, the language does not allow
-// functions to be called in constant expressions - here the exception is made to allow it.
-//
-// Each implementation provides its own version of this file. Each implementation can define
-// the required set of operators and constructors in its own fashion.
-//
-// The extended language syntax is only present when compiling this file. It is implicitly
-// included at the very beginning of the compiled shader, so no built-in functions can be
-// used.
-//
-// To communicate with the implementation, a special extended "__asm" keyword is used, followed
-// by an instruction name (any valid identifier), a destination variable identifier and a
-// a list of zero or more source variable identifiers. A variable identifier is a variable name
-// declared earlier in the code (as a function parameter, local or global variable).
-// An instruction name designates an instruction that must be exported by the implementation.
-// Each instruction receives data from destination and source variable identifiers and returns
-// data in the destination variable identifier.
-//
-// It is up to the implementation how to define a particular operator or constructor. If it is
-// expected to being used rarely, it can be defined in terms of other operators and constructors,
-// for example:
-//
-// ivec2 __operator + (const ivec2 x, const ivec2 y) {
-// return ivec2 (x[0] + y[0], x[1] + y[1]);
-// }
-//
-// If a particular operator or constructor is expected to be used very often or is an atomic
-// operation (that is, an operation that cannot be expressed in terms of other operations or
-// would create a dependency cycle) it must be defined using one or more __asm constructs.
-//
-// Each implementation must define constructors for all scalar types (bool, float, int).
-// There are 9 scalar-to-scalar constructors (including identity constructors). However,
-// since the language introduces special constructors (like matrix constructor with a single
-// scalar value), implementations must also implement these cases.
-// The compiler provides the following algorithm when resolving a constructor:
-// - try to find a constructor with a prototype matching ours,
-// - if no constructor is found and this is a scalar-to-scalar constructor, raise an error,
-// - if a constructor is found, execute it and return,
-// - count the size of the constructor parameter list - if it is less than the size of
-// our constructor's type, raise an error,
-// - for each parameter in the list do a recursive constructor matching for appropriate
-// scalar fields in the constructed variable,
-//
-// Each implementation must also define a set of operators that deal with built-in data types.
-// There are four kinds of operators:
-// 1) Operators that are implemented only by the compiler: "()" (function call), "," (sequence)
-// and "?:" (selection).
-// 2) Operators that are implemented by the compiler by expressing it in terms of other operators:
-// - "." (field selection) - translated to subscript access,
-// - "&&" (logical and) - translated to "<left_expr> ? <right_expr> : false",
-// - "||" (logical or) - translated to "<left_expr> ? true : <right_expr>",
-// 3) Operators that can be defined by the implementation and if the required prototype is not
-// found, standard behaviour is used:
-// - "==", "!=", "=" (equality, assignment) - compare or assign matching fields one-by-one;
-// note that at least operators for scalar data types must be defined by the implementation
-// to get it work,
-// 4) All other operators not mentioned above. If no required prototype is found, an error is
-// raised. An implementation must follow the language specification to provide all valid
-// operator prototypes.
-//
-
-//
-// From Shader Spec, ver. 1.10, rev. 59
-//
-
-//
-// 5.4.1 Conversion and Scalar Constructors
-//
-
-//
-// When constructors are used to convert a float to an int, the fractional part of the
-// floating-point value is dropped.
-//
-
-int __constructor (const float _f) {
- int _i;
- __asm float_to_int _i, _f;
- return _i;
-}
-
-//
-// When a constructor is used to convert an int or a float to bool, 0 and 0.0 are converted to
-// false, and nonzero values are converted to true.
-//
-
-bool __constructor (const int _i) {
- return _i != 0;
-}
-
-bool __constructor (const float _f) {
- return _f != 0.0;
-}
-
-//
-// When a constructor is used to convert a bool to an int or float, false is converted to 0 or
-// 0.0, and true is converted to 1 or 1.0.
-//
-
-int __constructor (const bool _b) {
- return _b ? 1 : 0;
-}
-
-float __constructor (const bool _b) {
- return _b ? 1.0 : 0.0;
-}
-
-//
-// Int to float constructor.
-//
-
-float __constructor (const int _i) {
- float _f;
- __asm int_to_float _f, _i;
- return _f;
-}
-
-//
-// Identity constructors, like float(float) are also legal, but of little use.
-//
-
-bool __constructor (const bool _b) {
- return _b;
-}
-
-int __constructor (const int _i) {
- return _i;
-}
-
-float __constructor (const float _f) {
- return _f;
-}
-
-//
-// Scalar constructors with non-scalar parameters can be used to take the first element from
-// a non-scalar. For example, the constructor float(vec3) will select the first component of the
-// vec3 parameter.
-//
-
-// [These scalar conversions will be handled internally by the compiler.]
-
-//
-// 5.4.2 Vector and Matrix Constructors
-//
-// Constructors can be used to create vectors or matrices from a set of scalars, vectors,
-// or matrices. This includes the ability to shorten vectors.
-//
-
-//
-// If there is a single scalar parameter to a vector constructor, it is used to initialize all
-// components of the constructed vector to that scalar\92s value.
-//
-// If the basic type (bool, int, or float) of a parameter to a constructor does not match the basic
-// type of the object being constructed, the scalar construction rules (above) are used to convert
-// the parameters.
-//
-
-vec2 __constructor (const float _f) {
- return vec2 (_f, _f);
-}
-
-vec2 __constructor (const int _i) {
- return vec2 (_i, _i);
-}
-
-vec2 __constructor (const bool _b) {
- return vec2 (_b, _b);
-}
-
-vec3 __constructor (const float _f) {
- return vec3 (_f, _f, _f);
-}
-
-vec3 __constructor (const int _i) {
- return vec3 (_i, _i, _i);
-}
-
-vec3 __constructor (const bool _b) {
- return vec3 (_b, _b, _b);
-}
-
-vec4 __constructor (const float _f) {
- return vec4 (_f, _f, _f, _f);
-}
-
-vec4 __constructor (const int _i) {
- return vec4 (_i, _i, _i, _i);
-}
-
-vec4 __constructor (const bool _b) {
- return vec4 (_b, _b, _b, _b);
-}
-
-ivec2 __constructor (const int _i) {
- return ivec2 (_i, _i);
-}
-
-ivec2 __constructor (const float _f) {
- return ivec2 (_f, _f);
-}
-
-ivec2 __constructor (const bool _b) {
- return ivec2 (_b, _b);
-}
-
-ivec3 __constructor (const int _i) {
- return ivec3 (_i, _i, _i);
-}
-
-ivec3 __constructor (const float _f) {
- return ivec3 (_f, _f, _f);
-}
-
-ivec3 __constructor (const bool _b) {
- return ivec3 (_b, _b, _b);
-}
-
-ivec4 __constructor (const int _i) {
- return ivec4 (_i, _i, _i, _i);
-}
-
-ivec4 __constructor (const float _f) {
- return ivec4 (_f, _f, _f, _f);
-}
-
-ivec4 __constructor (const bool _b) {
- return ivec4 (_b, _b, _b, _b);
-}
-
-bvec2 __constructor (const bool _b) {
- return bvec2 (_b, _b);
-}
-
-bvec2 __constructor (const float _f) {
- return bvec2 (_f, _f);
-}
-
-bvec2 __constructor (const int _i) {
- return bvec2 (_i, _i);
-}
-
-bvec3 __constructor (const bool _b) {
- return bvec3 (_b, _b, _b);
-}
-
-bvec3 __constructor (const float _f) {
- return bvec3 (_f, _f, _f);
-}
-
-bvec3 __constructor (const int _i) {
- return bvec3 (_i, _i, _i);
-}
-
-bvec4 __constructor (const bool _b) {
- return bvec4 (_b, _b, _b, _b);
-}
-
-bvec4 __constructor (const float _f) {
- return bvec4 (_f, _f, _f, _f);
-}
-
-bvec4 __constructor (const int _i) {
- return bvec4 (_i, _i, _i, _i);
-}
-
-//
-// If there is a single scalar parameter to a matrix constructor, it is used to initialize all the
-// components on the matrix\92s diagonal, with the remaining components initialized to 0.0.
-// (...) Matrices will be constructed in column major order. It is an error to construct matrices
-// from other matrices. This is reserved for future use.
-//
-// If the basic type (bool, int, or float) of a parameter to a constructor does not match the basic
-// type of the object being constructed, the scalar construction rules (above) are used to convert
-// the parameters.
-//
-
-mat2 __constructor (const float _f) {
- return mat2 (
- _f, .0,
- .0, _f
- );
-}
-
-mat2 __constructor (const int _i) {
- return mat2 (
- _i, .0,
- .0, _i
- );
-}
-
-mat2 __constructor (const bool _b) {
- return mat2 (
- _b, .0,
- .0, _b
- );
-}
-
-mat3 __constructor (const float _f) {
- return mat3 (
- _f, .0, .0,
- .0, _f, .0,
- .0, .0, _f
- );
-}
-
-mat3 __constructor (const int _i) {
- return mat3 (
- _i, .0, .0,
- .0, _i, .0,
- .0, .0, _i
- );
-}
-
-mat3 __constructor (const bool _b) {
- return mat3 (
- _b, .0, .0,
- .0, _b, .0,
- .0, .0, _b
- );
-}
-
-mat4 __constructor (const float _f) {
- return mat4 (
- _f, .0, .0, .0,
- .0, _f, .0, .0,
- .0, .0, _f, .0,
- .0, .0, .0, _f
- );
-}
-
-mat4 __constructor (const int _i) {
- return mat4 (
- _i, .0, .0, .0,
- .0, _i, .0, .0,
- .0, .0, _i, .0,
- .0, .0, .0, _i
- );
-}
-
-mat4 __constructor (const bool _b) {
- return mat4 (
- _b, .0, .0, .0,
- .0, _b, .0, .0,
- .0, .0, _b, .0,
- .0, .0, .0, _b
- );
-}
-
-//
-// 5.8 Assignments
-//
-// Assignments of values to variable names are done with the assignment operator ( = ), like
-//
-// lvalue = expression
-//
-// The assignment operator stores the value of expression into lvalue. It will compile only if
-// expression and lvalue have the same type. All desired type-conversions must be specified
-// explicitly via a constructor. Lvalues must be writable. Variables that are built-in types,
-// entire structures, structure fields, l-values with the field selector ( . ) applied to select
-// components or swizzles without repeated fields, and l-values dereferenced with the array
-// subscript operator ( [ ] ) are all possible l-values. Other binary or unary expressions,
-// non-dereferenced arrays, function names, swizzles with repeated fields, and constants cannot
-// be l-values.
-//
-// Expressions on the left of an assignment are evaluated before expressions on the right of the
-// assignment.
-//
-
-void __operator = (inout float a, const float b) {
- __asm float_copy a, b;
-}
-
-void __operator = (inout int a, const int b) {
- __asm int_copy a, b;
-}
-
-void __operator = (inout bool a, const bool b) {
- __asm bool_copy a, b;
-}
-
-void __operator = (inout vec2 v, const vec2 u) {
- v.x = u.x, v.y = u.y;
-}
-
-void __operator = (inout vec3 v, const vec3 u) {
- v.x = u.x, v.y = u.y, v.z = u.z;
-}
-
-void __operator = (inout vec4 v, const vec4 u) {
- v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
-}
-
-void __operator = (inout ivec2 v, const ivec2 u) {
- v.x = u.x, v.y = u.y;
-}
-
-void __operator = (inout ivec3 v, const ivec3 u) {
- v.x = u.x, v.y = u.y, v.z = u.z;
-}
-
-void __operator = (inout ivec4 v, const ivec4 u) {
- v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
-}
-
-void __operator = (inout bvec2 v, const bvec2 u) {
- v.x = u.x, v.y = u.y;
-}
-
-void __operator = (inout bvec3 v, const bvec3 u) {
- v.x = u.x, v.y = u.y, v.z = u.z;
-}
-
-void __operator = (inout bvec4 v, const bvec4 u) {
- v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
-}
-
-void __operator = (inout mat2 m, const mat2 n) {
- m[0] = n[0], m[1] = n[1];
-}
-
-void __operator = (inout mat3 m, const mat3 n) {
- m[0] = n[0], m[1] = n[1], m[2] = n[2];
-}
-
-void __operator = (inout mat4 m, const mat4 n) {
- m[0] = n[0], m[1] = n[1], m[2] = n[2], m[3] = n[3];
-}
-
-//
-// \95 The arithmetic assignments add into (+=), subtract from (-=), multiply into (*=), and divide
-// into (/=). The variable and expression must be the same floating-point or integer type, ...
-//
-
-void __operator += (inout float a, const float b) {
- __asm float_add a, b;
-}
-
-void __operator -= (inout float a, const float b) {
- a += -b;
-}
-
-void __operator *= (inout float a, const float b) {
- __asm float_multiply a, b;
-}
-
-void __operator /= (inout float a, const float b) {
- __asm float_divide a, b;
-}
-
-void __operator += (inout int x, const int y) {
- __asm int_add x, y;
-}
-
-void __operator -= (inout int x, const int y) {
- x += -y;
-}
-
-void __operator *= (inout int x, const int y) {
- __asm int_multiply x, y;
-}
-
-void __operator /= (inout int x, const int y) {
- __asm int_divide x, y;
-}
-
-void __operator += (inout vec2 v, const vec2 u) {
- v.x += u.x, v.y += u.y;
-}
-
-void __operator -= (inout vec2 v, const vec2 u) {
- v.x -= u.x, v.y -= u.y;
-}
-
-void __operator *= (inout vec2 v, const vec2 u) {
- v.x *= u.x, v.y *= u.y;
-}
-
-void __operator /= (inout vec2 v, const vec2 u) {
- v.x /= u.x, v.y /= u.y;
-}
-
-void __operator += (inout vec3 v, const vec3 u) {
- v.x += u.x, v.y += u.y, v.z += u.z;
-}
-
-void __operator -= (inout vec3 v, const vec3 u) {
- v.x -= u.x, v.y -= u.y, v.z -= u.z;
-}
-
-void __operator *= (inout vec3 v, const vec3 u) {
- v.x *= u.x, v.y *= u.y, v.z *= u.z;
-}
-
-void __operator /= (inout vec3 v, const vec3 u) {
- v.x /= u.x, v.y /= u.y, v.z /= u.z;
-}
-
-void __operator += (inout vec4 v, const vec4 u) {
- v.x += u.x, v.y += u.y, v.z += u.z, v.w += u.w;
-}
-
-void __operator -= (inout vec4 v, const vec4 u) {
- v.x -= u.x, v.y -= u.y, v.z -= u.z, v.w -= u.w;
-}
-
-void __operator *= (inout vec4 v, const vec4 u) {
- v.x *= u.x, v.y *= u.y, v.z *= u.z, v.w *= u.w;
-}
-
-void __operator /= (inout vec4 v, const vec4 u) {
- v.x /= u.x, v.y /= u.y, v.z /= u.z, v.w /= u.w;
-}
-
-void __operator += (inout ivec2 v, const ivec2 u) {
- v.x += u.x, v.y += u.y;
-}
-
-void __operator -= (inout ivec2 v, const ivec2 u) {
- v.x -= u.x, v.y -= u.y;
-}
-
-void __operator *= (inout ivec2 v, const ivec2 u) {
- v.x *= u.x, v.y *= u.y;
-}
-
-void __operator /= (inout ivec2 v, const ivec2 u) {
- v.x /= u.x, v.y /= u.y;
-}
-
-void __operator += (inout ivec3 v, const ivec3 u) {
- v.x += u.x, v.y += u.y, v.z += u.z;
-}
-
-void __operator -= (inout ivec3 v, const ivec3 u) {
- v.x -= u.x, v.y -= u.y, v.z -= u.z;
-}
-
-void __operator *= (inout ivec3 v, const ivec3 u) {
- v.x *= u.x, v.y *= u.y, v.z *= u.z;
-}
-
-void __operator /= (inout ivec3 v, const ivec3 u) {
- v.x /= u.x, v.y /= u.y, v.z /= u.z;
-}
-
-void __operator += (inout ivec4 v, const ivec4 u) {
- v.x += u.x, v.y += u.y, v.z += u.z, v.w += u.w;
-}
-
-void __operator -= (inout ivec4 v, const ivec4 u) {
- v.x -= u.x, v.y -= u.y, v.z -= u.z, v.w -= u.w;
-}
-
-void __operator *= (inout ivec4 v, const ivec4 u) {
- v.x *= u.x, v.y *= u.y, v.z *= u.z, v.w *= u.w;
-}
-
-void __operator /= (inout ivec4 v, const ivec4 u) {
- v.x /= u.x, v.y /= u.y, v.z /= u.z, v.w /= u.w;
-}
-
-void __operator += (inout mat2 m, const mat2 n) {
- m[0] += n[0], m[1] += n[1];
-}
-
-void __operator -= (inout mat2 v, const mat2 n) {
- m[0] -= n[0], m[1] -= n[1];
-}
-
-void __operator *= (inout mat2 m, const mat2 n) {
- m = m * n;
-}
-
-void __operator /= (inout mat2 m, const mat2 n) {
- m[0] /= n[0], m[1] /= n[1];
-}
-
-void __operator += (inout mat3 m, const mat3 n) {
- m[0] += n[0], m[1] += n[1], m[2] += n[2];
-}
-
-void __operator -= (inout mat3 m, const mat3 n) {
- m[0] -= n[0], m[1] -= n[1], m[2] -= n[2];
-}
-
-void __operator *= (inout mat3 m, const mat3 n) {
- m = m * n;
-}
-
-void __operator /= (inout mat3 m, const mat3 n) {
- m[0] /= n[0], m[1] /= n[1], m[2] /= n[2];
-}
-
-void __operator += (inout mat4 m, const mat4 n) {
- m[0] += n[0], m[1] += n[1], m[2] += n[2], m[3] += n[3];
-}
-
-void __operator -= (inout mat4 m, const mat4 n) {
- m[0] -= n[0], m[1] -= n[1], m[2] -= n[2], m[3] -= n[3];
-}
-
-void __operator *= (inout mat4 m, const mat4 n) {
- m = m * n;
-}
-
-void __operator /= (inout mat4 m, const mat4 n) {
- m[0] /= n[0], m[1] /= n[1], m[2] /= n[2], m[3] /= n[3];
-}
-
-//
-// ... or if the expression is a float, then the variable can be floating-point, a vector, or
-// a matrix, ...
-//
-
-void __operator += (inout vec2 v, const float a) {
- v.x += a, v.y += a;
-}
-
-void __operator -= (inout vec2 v, const float a) {
- v.x -= a, v.y -= a;
-}
-
-void __operator *= (inout vec2 v, const float a) {
- v.x *= a, v.y *= a;
-}
-
-void __operator /= (inout vec2 v, const float a) {
- v.x /= a, v.y /= a;
-}
-
-void __operator += (inout vec3 v, const float a) {
- v.x += a, v.y += a, v.z += a;
-}
-
-void __operator -= (inout vec3 v, const float a) {
- v.x -= a, v.y -= a, v.z -= a;
-}
-
-void __operator *= (inout vec3 v, const float a) {
- v.x *= a, v.y *= a, v.z *= a;
-}
-
-void __operator /= (inout vec3 v, const float a) {
- v.x /= a, v.y /= a, v.z /= a;
-}
-
-void __operator += (inout vec4 v, const float a) {
- v.x += a, v.y += a, v.z += a, v.w += a;
-}
-
-void __operator -= (inout vec4 v, const float a) {
- v.x -= a, v.y -= a, v.z -= a, v.w -= a;
-}
-
-void __operator *= (inout vec4 v, const float a) {
- v.x *= a, v.y *= a, v.z *= a, v.w *= a;
-}
-
-void __operator /= (inout vec4 v, const float a) {
- v.x /= a, v.y /= a, v.z /= a, v.w /= a;
-}
-
-void __operator += (inout mat2 m, const float a) {
- m[0] += a, m[1] += a;
-}
-
-void __operator -= (inout mat2 m, const float a) {
- m[0] -= a, m[1] -= a;
-}
-
-void __operator *= (inout mat2 m, const float a) {
- m[0] *= a, m[1] *= a;
-}
-
-void __operator /= (inout mat2 m, const float a) {
- m[0] /= a, m[1] /= a;
-}
-
-void __operator += (inout mat3 m, const float a) {
- m[0] += a, m[1] += a, m[2] += a;
-}
-
-void __operator -= (inout mat3 m, const float a) {
- m[0] -= a, m[1] -= a, m[2] -= a;
-}
-
-void __operator *= (inout mat3 m, const float a) {
- m[0] *= a, m[1] *= a, m[2] *= a;
-}
-
-void __operator /= (inout mat3 m, const float a) {
- m[0] /= a, m[1] /= a, m[2] /= a;
-}
-
-void __operator += (inout mat4 m, const float a) {
- m[0] += a, m[1] += a, m[2] += a, m[3] += a;
-}
-
-void __operator -= (inout mat4 m, const float a) {
- m[0] -= a, m[1] -= a, m[2] -= a, m[3] -= a;
-}
-
-void __operator *= (inout mat4 m, const float a) {
- m[0] *= a, m[1] *= a, m[2] *= a, m[3] *= a;
-}
-
-void __operator /= (inout mat4 m, const float a) {
- m[0] /= a, m[1] /= a, m[2] /= a, m[3] /= a;
-}
-
-//
-// ... or if the operation is multiply into (*=), then the variable can be a vector and the
-// expression can be a matrix of matching size.
-//
-
-void __operator *= (inout vec2 v, const mat2 m) {
- v = v * m;
-}
-
-void __operator *= (inout vec3 v, const mat3 m) {
- v = v * m;
-}
-
-void __operator *= (inout vec4 v, const mat4 m) {
- v = v * m;
-}
-
-//
-// 5.9 Expressions
-//
-// Expressions in the shading language include the following:
-//
-
-//
-// \95 The arithmetic binary operators add (+), subtract (-), multiply (*), and divide (/), that
-// operate on integer and floating-point typed expressions (including vectors and matrices).
-// The two operands must be the same type, (...) Additionally, for multiply (*) (...) If one
-// operand is scalar and the other is a vector or matrix, the scalar is applied component-wise
-// to the vector or matrix, resulting in the same type as the vector or matrix.
-//
-
-float __operator + (const float a, const float b) {
- float c = a;
- return c += b;
-}
-
-float __operator - (const float a, const float b) {
- return a + -b;
-}
-
-float __operator * (const float a, const float b) {
- float c = a;
- return c *= b;
-}
-
-float __operator / (const float a, const float b) {
- float c = a;
- return c /= b;
-}
-
-int __operator + (const int a, const int b) {
- int c = a;
- return c += b;
-}
-
-int __operator - (const int x, const int y) {
- return x + -y;
-}
-
-int __operator * (const int x, const int y) {
- int z = x;
- return z *= y;
-}
-
-int __operator / (const int x, const int y) {
- int z = x;
- return z /= y;
-}
-
-vec2 __operator + (const vec2 v, const vec2 u) {
- return vec2 (v.x + u.x, v.y + u.y);
-}
-
-vec2 __operator - (const vec2 v, const vec2 u) {
- return vec2 (v.x - u.x, v.y - u.y);
-}
-
-vec3 __operator + (const vec3 v, const vec3 u) {
- return vec3 (v.x + u.x, v.y + u.y, v.z + u.z);
-}
-
-vec3 __operator - (const vec3 v, const vec3 u) {
- return vec3 (v.x - u.x, v.y - u.y, v.z - u.z);
-}
-
-vec4 __operator + (const vec4 v, const vec4 u) {
- return vec4 (v.x + u.x, v.y + u.y, v.z + u.z, v.w + u.w);
-}
-
-vec4 __operator - (const vec4 v, const vec4 u) {
- return vec4 (v.x - u.x, v.y - u.y, v.z - u.z, v.w - u.w);
-}
-
-ivec2 __operator + (const ivec2 v, const ivec2 u) {
- return ivec2 (v.x + u.x, v.y + u.y);
-}
-
-ivec2 __operator - (const ivec2 v, const ivec2 u) {
- return ivec2 (v.x - u.x, v.y - u.y);
-}
-
-ivec3 __operator + (const ivec3 v, const ivec3 u) {
- return ivec3 (v.x + u.x, v.y + u.y, v.z + u.z);
-}
-
-ivec3 __operator - (const ivec3 v, const ivec3 u) {
- return ivec3 (v.x - u.x, v.y - u.y, v.z - u.z);
-}
-
-ivec4 __operator + (const ivec4 v, const ivec4 u) {
- return ivec4 (v.x + u.x, v.y + u.y, v.z + u.z, v.w + u.w);
-}
-
-ivec4 __operator - (const ivec4 v, const ivec4 u) {
- return ivec4 (v.x - u.x, v.y - u.y, v.z - u.z, v.w - u.w);
-}
-
-mat2 __operator + (const mat2 m, const mat2 n) {
- return mat2 (m[0] + n[0], m[1] + n[1]);
-}
-
-mat2 __operator - (const mat2 m, const mat2 n) {
- return mat2 (m[0] - n[0], m[1] - n[1]);
-}
-
-mat3 __operator + (const mat3 m, const mat3 n) {
- return mat3 (m[0] + n[0], m[1] + n[1], m[2] + n[2]);
-}
-
-mat3 __operator - (const mat3 m, const mat3 n) {
- return mat3 (m[0] - n[0], m[1] - n[1], m[2] - n[2]);
-}
-
-mat4 __operator + (const mat4 m, const mat4 n) {
- return mat4 (m[0] + n[0], m[1] + n[1], m[2] + n[2], m[3] + n[3]);
-}
-
-mat4 __operator - (const mat4 m, const mat4 n) {
- return mat4 (m[0] - n[0], m[1] - n[1], m[2] - n[2], m[3] - n[3]);
-}
-
-//
-// ... or one can be a scalar float and the other a float vector or matrix, ...
-//
-
-vec2 __operator + (const float a, const vec2 u) {
- return vec2 (a + u.x, a + u.y);
-}
-
-vec2 __operator + (const vec2 v, const float b) {
- return vec2 (v.x + b, v.y + b);
-}
-
-vec2 __operator - (const float a, const vec2 u) {
- return vec2 (a - u.x, a - u.y);
-}
-
-vec2 __operator - (const vec2 v, const float b) {
- return vec2 (v.x - b, v.y - b);
-}
-
-vec2 __operator * (const float a, const vec2 u) {
- return vec2 (a * u.x, a * u.y);
-}
-
-vec2 __operator * (const vec2 v, const float b) {
- return vec2 (v.x * b, v.y * b);
-}
-
-vec2 __operator / (const float a, const vec2 u) {
- return vec2 (a / u.x, a / u.y);
-}
-
-vec2 __operator / (const vec2 v, const float b) {
- return vec2 (v.x / b, v.y / b);
-}
-
-vec3 __operator + (const float a, const vec3 u) {
- return vec3 (a + u.x, a + u.y, a + u.z);
-}
-
-vec3 __operator + (const vec3 v, const float b) {
- return vec3 (v.x + b, v.y + b, v.z + b);
-}
-
-vec3 __operator - (const float a, const vec3 u) {
- return vec3 (a - u.x, a - u.y, a - u.z);
-}
-
-vec3 __operator - (const vec3 v, const float b) {
- return vec3 (v.x - b, v.y - b, v.z - b);
-}
-
-vec3 __operator * (const float a, const vec3 u) {
- return vec3 (a * u.x, a * u.y, a * u.z);
-}
-
-vec3 __operator * (const vec3 v, const float b) {
- return vec3 (v.x * b, v.y * b, v.z * b);
-}
-
-vec3 __operator / (const float a, const vec3 u) {
- return vec3 (a / u.x, a / u.y, a / u.z);
-}
-
-vec3 __operator / (const vec3 v, const float b) {
- return vec3 (v.x / b, v.y / b, v.z / b);
-}
-
-vec4 __operator + (const float a, const vec4 u) {
- return vec4 (a + u.x, a + u.y, a + u.z, a + u.w);
-}
-
-vec4 __operator + (const vec4 v, const float b) {
- return vec4 (v.x + b, v.y + b, v.z + b, v.w + b);
-}
-
-vec4 __operator - (const float a, const vec4 u) {
- return vec4 (a - u.x, a - u.y, a - u.z, a - u.w);
-}
-
-vec4 __operator - (const vec4 v, const float b) {
- return vec4 (v.x - b, v.y - b, v.z - b, v.w - b);
-}
-
-vec4 __operator * (const float a, const vec4 u) {
- return vec4 (a * u.x, a * u.y, a * u.z, a * u.w);
-}
-
-vec4 __operator * (const vec4 v, const float b) {
- return vec4 (v.x * b, v.y * b, v.z * b, v.w * b);
-}
-
-vec4 __operator / (const float a, const vec4 u) {
- return vec4 (a / u.x, a / u.y, a / u.z, a / u.w);
-}
-
-vec4 __operator / (const vec4 v, const float b) {
- return vec4 (v.x / b, v.y / b, v.z / b, v.w / b);
-}
-
-mat2 __operator + (const float a, const mat2 n) {
- return mat2 (a + n[0], a + n[1]);
-}
-
-mat2 __operator + (const mat2 m, const float b) {
- return mat2 (m[0] + b, m[1] + b);
-}
-
-mat2 __operator - (const float a, const mat2 n) {
- return mat2 (a - n[0], a - n[1]);
-}
-
-mat2 __operator - (const mat2 m, const float b) {
- return mat2 (m[0] - b, m[1] - b);
-}
-
-mat2 __operator * (const float a, const mat2 n) {
- return mat2 (a * n[0], a * n[1]);
-}
-
-mat2 __operator * (const mat2 m, const float b) {
- return mat2 (m[0] * b, m[1] * b);
-}
-
-mat2 __operator / (const float a, const mat2 n) {
- return mat2 (a / n[0], a / n[1]);
-}
-
-mat2 __operator / (const mat2 m, const float b) {
- return mat2 (m[0] / b, m[1] / b);
-}
-
-mat3 __operator + (const float a, const mat3 n) {
- return mat3 (a + n[0], a + n[1], a + n[2]);
-}
-
-mat3 __operator + (const mat3 m, const float b) {
- return mat3 (m[0] + b, m[1] + b, m[2] + b);
-}
-
-mat3 __operator - (const float a, const mat3 n) {
- return mat3 (a - n[0], a - n[1], a - n[2]);
-}
-
-mat3 __operator - (const mat3 m, const float b) {
- return mat3 (m[0] - b, m[1] - b, m[2] - b);
-}
-
-mat3 __operator * (const float a, const mat3 n) {
- return mat3 (a * n[0], a * n[1], a * n[2]);
-}
-
-mat3 __operator * (const mat3 m, const float b) {
- return mat3 (m[0] * b, m[1] * b, m[2] * b);
-}
-
-mat3 __operator / (const float a, const mat3 n) {
- return mat3 (a / n[0], a / n[1], a / n[2]);
-}
-
-mat3 __operator / (const mat3 m, const float b) {
- return mat3 (m[0] / b, m[1] / b, m[2] / b);
-}
-
-mat4 __operator + (const float a, const mat4 n) {
- return mat4 (a + n[0], a + n[1], a + n[2], a + n[3]);
-}
-
-mat4 __operator + (const mat4 m, const float b) {
- return mat4 (m[0] + b, m[1] + b, m[2] + b, m[3] + b);
-}
-
-mat4 __operator - (const float a, const mat4 n) {
- return mat4 (a - n[0], a - n[1], a - n[2], a - n[3]);
-}
-
-mat4 __operator - (const mat4 m, const float b) {
- return mat4 (m[0] - b, m[1] - b, m[2] - b, m[3] - b);
-}
-
-mat4 __operator * (const float a, const mat4 n) {
- return mat4 (a * n[0], a * n[1], a * n[2], a * n[3]);
-}
-
-mat4 __operator * (const mat4 m, const float b) {
- return mat4 (m[0] * b, m[1] * b, m[2] * b, m[3] * b);
-}
-
-mat4 __operator / (const float a, const mat4 n) {
- return mat4 (a / n[0], a / n[1], a / n[2], a / n[3]);
-}
-
-mat4 __operator / (const mat4 m, const float b) {
- return mat4 (m[0] / b, m[1] / b, m[2] / b, m[3] / b);
-}
-
-//
-// ... or one can be a scalar integer and the other an integer vector.
-//
-
-ivec2 __operator + (const int a, const ivec2 u) {
- return ivec2 (a + u.x, a + u.y);
-}
-
-ivec2 __operator + (const ivec2 v, const int b) {
- return ivec2 (v.x + b, v.y + b);
-}
-
-ivec2 __operator - (const int a, const ivec2 u) {
- return ivec2 (a - u.x, a - u.y);
-}
-
-ivec2 __operator - (const ivec2 v, const int b) {
- return ivec2 (v.x - b, v.y - b);
-}
-
-ivec2 __operator * (const int a, const ivec2 u) {
- return ivec2 (a * u.x, a * u.y);
-}
-
-ivec2 __operator * (const ivec2 v, const int b) {
- return ivec2 (v.x * b, v.y * b);
-}
-
-ivec2 __operator / (const int a, const ivec2 u) {
- return ivec2 (a / u.x, a / u.y);
-}
-
-ivec2 __operator / (const ivec2 v, const int b) {
- return ivec2 (v.x / b, v.y / b);
-}
-
-ivec3 __operator + (const int a, const ivec3 u) {
- return ivec3 (a + u.x, a + u.y, a + u.z);
-}
-
-ivec3 __operator + (const ivec3 v, const int b) {
- return ivec3 (v.x + b, v.y + b, v.z + b);
-}
-
-ivec3 __operator - (const int a, const ivec3 u) {
- return ivec3 (a - u.x, a - u.y, a - u.z);
-}
-
-ivec3 __operator - (const ivec3 v, const int b) {
- return ivec3 (v.x - b, v.y - b, v.z - b);
-}
-
-ivec3 __operator * (const int a, const ivec3 u) {
- return ivec3 (a * u.x, a * u.y, a * u.z);
-}
-
-ivec3 __operator * (const ivec3 v, const int b) {
- return ivec3 (v.x * b, v.y * b, v.z * b);
-}
-
-ivec3 __operator / (const int a, const ivec3 u) {
- return ivec3 (a / u.x, a / u.y, a / u.z);
-}
-
-ivec3 __operator / (const ivec3 v, const int b) {
- return ivec3 (v.x / b, v.y / b, v.z / b);
-}
-
-ivec4 __operator + (const int a, const ivec4 u) {
- return ivec4 (a + u.x, a + u.y, a + u.z, a + u.w);
-}
-
-ivec4 __operator + (const ivec4 v, const int b) {
- return ivec4 (v.x + b, v.y + b, v.z + b, v.w + b);
-}
-
-ivec4 __operator - (const int a, const ivec4 u) {
- return ivec4 (a - u.x, a - u.y, a - u.z, a - u.w);
-}
-
-ivec4 __operator - (const ivec4 v, const int b) {
- return ivec4 (v.x - b, v.y - b, v.z - b, v.w - b);
-}
-
-ivec4 __operator * (const int a, const ivec4 u) {
- return ivec4 (a * u.x, a * u.y, a * u.z, a * u.w);
-}
-
-ivec4 __operator * (const ivec4 v, const int b) {
- return ivec4 (v.x * b, v.y * b, v.z * b, v.w * b);
-}
-
-ivec4 __operator / (const int a, const ivec4 u) {
- return ivec4 (a / u.x, a / u.y, a / u.z, a / u.w);
-}
-
-ivec4 __operator / (const ivec4 v, const int b) {
- return ivec4 (v.x / b, v.y / b, v.z / b, v.w / b);
-}
-
-//
-// Additionally, for multiply (*) one can be a vector and the other a matrix with the same
-// dimensional size of the vector. These result in the same fundamental type (integer or float)
-// as the expressions they operate on.
-//
-// [When:]
-// \95 the left argument is a floating-point vector and the right is a matrix with a compatible
-// dimension in which case the * operator will do a row vector matrix multiplication.
-// \95 the left argument is a matrix and the right is a floating-point vector with a compatible
-// dimension in which case the * operator will do a column vector matrix multiplication.
-//
-
-vec2 __operator * (const mat2 m, const vec2 v) {
- return vec2 (
- v.x * m[0].x + v.y * m[1].x,
- v.x * m[0].y + v.y * m[1].y
- );
-}
-
-vec2 __operator * (const vec2 v, const mat2 m) {
- return vec2 (
- v.x * m[0].x + v.y * m[0].y,
- v.x * m[1].x + v.y * m[1].y
- );
-}
-
-vec3 __operator * (const mat3 m, const vec3 v) {
- return vec3 (
- v.x * m[0].x + v.y * m[1].x + v.z * m[2].x,
- v.x * m[0].y + v.y * m[1].y + v.z * m[2].y,
- v.x * m[0].z + v.y * m[1].z + v.z * m[2].z
- );
-}
-
-vec3 __operator * (const vec3 v, const mat3 m) {
- return vec3 (
- v.x * m[0].x + v.y * m[0].y + v.z * m[0].z,
- v.x * m[1].x + v.y * m[1].y + v.z * m[1].z,
- v.x * m[2].x + v.y * m[2].y + v.z * m[2].z
- );
-}
-
-vec4 __operator * (const mat4 m, const vec4 v) {
- return vec4 (
- v.x * m[0].x + v.y * m[1].x + v.z * m[2].x + v.w * m[3].x,
- v.x * m[0].y + v.y * m[1].y + v.z * m[2].y + v.w * m[3].y,
- v.x * m[0].z + v.y * m[1].z + v.z * m[2].z + v.w * m[3].z,
- v.x * m[0].w + v.y * m[1].w + v.z * m[2].w + v.w * m[3].w
- );
-}
-
-vec4 __operator * (const vec4 v, const mat4 m) {
- return vec4 (
- v.x * m[0].x + v.y * m[0].y + v.z * m[0].z + v.w * m[0].w,
- v.x * m[1].x + v.y * m[1].y + v.z * m[1].z + v.w * m[1].w,
- v.x * m[2].x + v.y * m[2].y + v.z * m[2].z + v.w * m[2].w,
- v.x * m[3].x + v.y * m[3].y + v.z * m[3].z + v.w * m[3].w
- );
-}
-
-//
-// Multiply (*) applied to two vectors yields a component-wise multiply.
-//
-
-vec2 __operator * (const vec2 v, const vec2 u) {
- return vec2 (v.x * u.x, v.y * u.y);
-}
-
-vec3 __operator * (const vec3 v, const vec3 u) {
- return vec3 (v.x * u.x, v.y * u.y, v.z * u.z);
-}
-
-vec4 __operator * (const vec4 v, const vec4 u) {
- return vec4 (v.x * u.x, v.y * u.y, v.z * u.z, v.w * u.w);
-}
-
-ivec2 __operator * (const ivec2 v, const ivec2 u) {
- return ivec2 (v.x * u.x, v.y * u.y);
-}
-
-ivec3 __operator * (const ivec3 v, const ivec3 u) {
- return ivec3 (v.x * u.x, v.y * u.y, v.z * u.z);
-}
-
-ivec4 __operator * (const ivec4 v, const ivec4 u) {
- return ivec4 (v.x * u.x, v.y * u.y, v.z * u.z, v.w * u.w);
-}
-
-//
-// Dividing by zero does not cause an exception but does result in an unspecified value.
-//
-
-vec2 __operator / (const vec2 v, const vec2 u) {
- return vec2 (v.x / u.x, v.y / u.y);
-}
-
-vec3 __operator / (const vec3 v, const vec3 u) {
- return vec3 (v.x / u.x, v.y / u.y, v.z / u.z);
-}
-
-vec4 __operator / (const vec4 v, const vec4 u) {
- return vec4 (v.x / u.x, v.y / u.y, v.z / u.z, v.w / u.w);
-}
-
-ivec2 __operator / (const ivec2 v, const ivec2 u) {
- return ivec2 (v.x / u.x, v.y / u.y);
-}
-
-ivec3 __operator / (const ivec3 v, const ivec3 u) {
- return ivec3 (v.x / u.x, v.y / u.y, v.z / u.z);
-}
-
-ivec4 __operator / (const ivec4 v, const ivec4 u) {
- return ivec4 (v.x / u.x, v.y / u.y, v.z / u.z, v.w / u.w);
-}
-
-mat2 __operator / (const mat2 m, const mat2 n) {
- return mat2 (m[0] / n[0], m[1] / n[1]);
-}
-
-mat3 __operator / (const mat3 m, const mat3 n) {
- return mat3 (m[0] / n[0], m[1] / n[1], m[2] / n[2]);
-}
-
-mat4 __operator / (const mat4 m, const mat4 n) {
- return mat4 (m[0] / n[0], m[1] / n[1], m[2] / n[2], m[3] / n[3]);
-}
-
-//
-// Multiply (*) applied to two matrices yields a linear algebraic matrix multiply, not
-// a component-wise multiply.
-//
-
-mat2 __operator * (const mat2 m, const mat2 n) {
- return mat2 (m * n[0], m * n[1]);
-}
-
-mat3 __operator * (const mat3 m, const mat3 n) {
- return mat3 (m * n[0], m * n[1], m * n[2]);
-}
-
-mat4 __operator * (const mat4 m, const mat4 n) {
- return mat4 (m * n[0], m * n[1], m * n[2], m * n[3]);
-}
-
-//
-// \95 The arithmetic unary operators negate (-), post- and pre-increment and decrement (-- and
-// ++) that operate on integer or floating-point values (including vectors and matrices). These
-// result with the same type they operated on. For post- and pre-increment and decrement, the
-// expression must be one that could be assigned to (an l-value). Pre-increment and predecrement
-// add or subtract 1 or 1.0 to the contents of the expression they operate on, and the
-// value of the pre-increment or pre-decrement expression is the resulting value of that
-// modification. Post-increment and post-decrement expressions add or subtract 1 or 1.0 to
-// the contents of the expression they operate on, but the resulting expression has the
-// expression\92s value before the post-increment or post-decrement was executed.
-//
-// [NOTE: postfix increment and decrement operators take additional dummy int parameter to
-// distinguish their prototypes from prefix ones.]
-//
-
-float __operator - (const float a) {
- float c = a;
- __asm float_negate c;
- return c;
-}
-
-int __operator - (const int a) {
- int c = a;
- __asm int_negate c;
- return c;
-}
-
-vec2 __operator - (const vec2 v) {
- return vec2 (-v.x, -v.y);
-}
-
-vec3 __operator - (const vec3 v) {
- return vec3 (-v.x, -v.y, -v.z);
-}
-
-vec4 __operator - (const vec4 v) {
- return vec4 (-v.x, -v.y, -v.z, -v.w);
-}
-
-ivec2 __operator - (const ivec2 v) {
- return ivec2 (-v.x, -v.y);
-}
-
-ivec3 __operator - (const ivec3 v) {
- return ivec3 (-v.x, -v.y, -v.z);
-}
-
-ivec4 __operator - (const ivec4 v) {
- return ivec4 (-v.x, -v.y, -v.z, -v.w);
-}
-
-mat2 __operator - (const mat2 m) {
- return mat2 (-m[0], -m[1]);
-}
-
-mat3 __operator - (const mat3 m) {
- return mat3 (-m[0], -m[1], -m[2]);
-}
-
-mat4 __operator - (const mat4 m) {
- return mat4 (-m[0], -m[1], -m[2], -m[3]);
-}
-
-void __operator -- (inout float a) {
- a -= 1.0;
-}
-
-void __operator -- (inout int a) {
- a -= 1;
-}
-
-void __operator -- (inout vec2 v) {
- --v.x, --v.y;
-}
-
-void __operator -- (inout vec3 v) {
- --v.x, --v.y, --v.z;
-}
-
-void __operator -- (inout vec4 v) {
- --v.x, --v.y, --v.z, --v.w;
-}
-
-void __operator -- (inout ivec2 v) {
- --v.x, --v.y;
-}
-
-void __operator -- (inout ivec3 v) {
- --v.x, --v.y, --v.z;
-}
-
-void __operator -- (inout ivec4 v) {
- --v.x, --v.y, --v.z, --v.w;
-}
-
-void __operator -- (inout mat2 m) {
- --m[0], --m[1];
-}
-
-void __operator -- (inout mat3 m) {
- --m[0], --m[1], --m[2];
-}
-
-void __operator -- (inout mat4 m) {
- --m[0], --m[1], --m[2], --m[3];
-}
-
-void __operator ++ (inout float a) {
- a += 1.0;
-}
-
-void __operator ++ (inout int a) {
- a += 1;
-}
-
-void __operator ++ (inout vec2 v) {
- ++v.x, ++v.y;
-}
-
-void __operator ++ (inout vec3 v) {
- ++v.x, ++v.y, ++v.z;
-}
-
-void __operator ++ (inout vec4 v) {
- ++v.x, ++v.y, ++v.z, ++v.w;
-}
-
-void __operator ++ (inout ivec2 v) {
- ++v.x, ++v.y;
-}
-
-void __operator ++ (inout ivec3 v) {
- ++v.x, ++v.y, ++v.z;
-}
-
-void __operator ++ (inout ivec4 v) {
- ++v.x, ++v.y, ++v.z, ++v.w;
-}
-
-void __operator ++ (inout mat2 m) {
- ++m[0], ++m[1];
-}
-
-void __operator ++ (inout mat3 m) {
- ++m[0], ++m[1], ++m[2];
-}
-
-void __operator ++ (inout mat4 m) {
- ++m[0], ++m[1], ++m[2], ++m[3];
-}
-
-float __operator -- (inout float a, const int) {
- const float c = a;
- --a;
- return c;
-}
-
-int __operator -- (inout int a, const int) {
- const int c = a;
- --a;
- return c;
-}
-
-vec2 __operator -- (inout vec2 v, const int) {
- return vec2 (v.x--, v.y--);
-}
-
-vec3 __operator -- (inout vec3 v, const int) {
- return vec3 (v.x--, v.y--, v.z--);
-}
-
-vec4 __operator -- (inout vec4 v, const int) {
- return vec4 (v.x--, v.y--, v.z--, v.w--);
-}
-
-ivec2 __operator -- (inout ivec2 v, const int) {
- return ivec2 (v.x--, v.y--);
-}
-
-ivec3 __operator -- (inout ivec3 v, const int) {
- return ivec3 (v.x--, v.y--, v.z--);
-}
-
-ivec4 __operator -- (inout ivec4 v, const int) {
- return ivec4 (v.x--, v.y--, v.z--, v.w--);
-}
-
-mat2 __operator -- (inout mat2 m, const int) {
- return mat2 (m[0]--, m[1]--);
-}
-
-mat3 __operator -- (inout mat3 m, const int) {
- return mat3 (m[0]--, m[1]--, m[2]--);
-}
-
-mat4 __operator -- (inout mat4 m, const int) {
- return mat4 (m[0]--, m[1]--, m[2]--, m[3]--);
-}
-
-float __operator ++ (inout float a, const int) {
- const float c = a;
- ++a;
- return c;
-}
-
-int __operator ++ (inout int a, const int) {
- const int c = a;
- ++a;
- return c;
-}
-
-vec2 __operator ++ (inout vec2 v, const int) {
- return vec2 (v.x++, v.y++);
-}
-
-vec3 __operator ++ (inout vec3 v, const int) {
- return vec3 (v.x++, v.y++, v.z++);
-}
-
-vec4 __operator ++ (inout vec4 v, const int) {
- return vec4 (v.x++, v.y++, v.z++, v.w++);
-}
-
-ivec2 __operator ++ (inout ivec2 v, const int) {
- return ivec2 (v.x++, v.y++);
-}
-
-ivec3 __operator ++ (inout ivec3 v, const int) {
- return ivec3 (v.x++, v.y++, v.z++);
-}
-
-ivec4 __operator ++ (inout ivec4 v, const int) {
- return ivec4 (v.x++, v.y++, v.z++, v.w++);
-}
-
-mat2 __operator ++ (inout mat2 m, const int) {
- return mat2 (m[0]++, m[1]++);
-}
-
-mat3 __operator ++ (inout mat3 m, const int) {
- return mat3 (m[0]++, m[1]++, m[2]++);
-}
-
-mat4 __operator ++ (inout mat4 m, const int) {
- return mat4 (m[0]++, m[1]++, m[2]++, m[3]++);
-}
-
-//
-// \95 The relational operators greater than (>), less than (<), greater than or equal (>=), and less
-// than or equal (<=) operate only on scalar integer and scalar floating-point expressions. The
-// result is scalar Boolean. The operands\92 types must match. To do component-wise
-// comparisons on vectors, use the built-in functions lessThan, lessThanEqual,
-// greaterThan, and greaterThanEqual.
-//
-
-bool __operator < (const float a, const float b) {
- bool c;
- __asm float_less c, a, b;
- return c;
-}
-
-bool __operator < (const int a, const int b) {
- bool c;
- __asm int_less c, a, b;
- return c;
-}
-
-bool __operator > (const float a, const float b) {
- return b < a;
-}
-
-bool __operator > (const int a, const int b) {
- return b < a;
-}
-
-bool __operator >= (const float a, const float b) {
- return a > b || a == b;
-}
-
-bool __operator >= (const int a, const int b) {
- return a > b || a == b;
-}
-
-bool __operator <= (const float a, const float b) {
- return a < b || a == b;
-}
-
-bool __operator <= (const int a, const int b) {
- return a < b || a == b;
-}
-
-//
-// \95 The equality operators equal (==), and not equal (!=) operate on all types except arrays.
-// They result in a scalar Boolean. For vectors, matrices, and structures, all components of the
-// operands must be equal for the operands to be considered equal. To get component-wise
-// equality results for vectors, use the built-in functions equal and notEqual.
-//
-
-bool __operator == (const float a, const float b) {
- bool c;
- __asm float_equal c, a, b;
- return c;
-}
-
-bool __operator == (const int a, const int b) {
- bool c;
- __asm int_equal c, a, b;
- return c;
-}
-
-bool __operator == (const bool a, const bool b) {
- bool c;
- __asm bool_equal c, a, b;
- return c;
-}
-
-bool __operator == (const vec2 v, const vec2 u) {
- return v.x == u.x && v.y == u.y;
-}
-
-bool __operator == (const vec3 v, const vec3 u) {
- return v.x == u.x && v.y == u.y && v.z == u.z;
-}
-
-bool __operator == (const vec4 v, const vec4 u) {
- return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;
-}
-
-bool __operator == (const ivec2 v, const ivec2 u) {
- return v.x == u.x && v.y == u.y;
-}
-
-bool __operator == (const ivec3 v, const ivec3 u) {
- return v.x == u.x && v.y == u.y && v.z == u.z;
-}
-
-bool __operator == (const ivec4 v, const ivec4 u) {
- return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;
-}
-
-bool __operator == (const bvec2 v, const bvec2 u) {
- return v.x == u.x && v.y == u.y;
-}
-
-bool __operator == (const bvec3 v, const bvec3 u) {
- return v.x == u.x && v.y == u.y && v.z == u.z;
-}
-
-bool __operator == (const bvec4 v, const bvec4 u) {
- return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;
-}
-
-bool __operator == (const mat2 m, const mat2 n) {
- return m[0] == n[0] && m[1] == n[1];
-}
-
-bool __operator == (const mat3 m, const mat3 n) {
- return m[0] == n[0] && m[1] == n[1] && m[2] == n[2];
-}
-
-bool __operator == (const mat4 m, const mat4 n) {
- return m[0] == n[0] && m[1] == n[1] && m[2] == n[2] && m[3] == n[3];
-}
-
-bool __operator != (const float a, const float b) {
- return !(a == b);
-}
-
-bool __operator != (const int a, const int b) {
- return !(a == b);
-}
-
-bool __operator != (const bool a, const bool b) {
- return !(a == b);
-}
-
-bool __operator != (const vec2 v, const vec2 u) {
- return v.x != u.x || v.y != u.y;
-}
-
-bool __operator != (const vec3 v, const vec3 u) {
- return v.x != u.x || v.y != u.y || v.z != u.z;
-}
-
-bool __operator != (const vec4 v, const vec4 u) {
- return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;
-}
-
-bool __operator != (const ivec2 v, const ivec2 u) {
- return v.x != u.x || v.y != u.y;
-}
-
-bool __operator != (const ivec3 v, const ivec3 u) {
- return v.x != u.x || v.y != u.y || v.z != u.z;
-}
-
-bool __operator != (const ivec4 v, const ivec4 u) {
- return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;
-}
-
-bool __operator != (const bvec2 v, const bvec2 u) {
- return v.x != u.x || v.y != u.y;
-}
-
-bool __operator != (const bvec3 v, const bvec3 u) {
- return v.x != u.x || v.y != u.y || v.z != u.z;
-}
-
-bool __operator != (const bvec4 v, const bvec4 u) {
- return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;
-}
-
-bool __operator != (const mat2 m, const mat2 n) {
- return m[0] != n[0] || m[1] != n[1];
-}
-
-bool __operator != (const mat3 m, const mat3 n) {
- return m[0] != n[0] || m[1] != n[1] || m[2] != n[2];
-}
-
-bool __operator != (const mat4 m, const mat4 n) {
- return m[0] != n[0] || m[1] != n[1] || m[2] != n[2] || m[3] != n[3];
-}
-
-//
-// \95 The logical binary operators and (&&), or ( | | ), and exclusive or (^^). They operate only
-// on two Boolean expressions and result in a Boolean expression. And (&&) will only
-// evaluate the right hand operand if the left hand operand evaluated to true. Or ( | | ) will
-// only evaluate the right hand operand if the left hand operand evaluated to false. Exclusive or
-// (^^) will always evaluate both operands.
-//
-
-bool __operator ^^ (const bool a, const bool b) {
- return a != b;
-}
-
-//
-// [These operators are handled internally by the compiler:]
-//
-// bool __operator && (bool a, bool b) {
-// return a ? b : false;
-// }
-// bool __operator || (bool a, bool b) {
-// return a ? true : b;
-// }
-//
-
-//
-// \95 The logical unary operator not (!). It operates only on a Boolean expression and results in a
-// Boolean expression. To operate on a vector, use the built-in function not.
-//
-
-bool __operator ! (const bool a) {
- return a == false;
-}
-
+++ /dev/null
-
-//
-// TODO:
-// - implement texture1D, texture2D, texture3D, textureCube,
-// - implement shadow1D, shadow2D,
-// - implement dFdx, dFdy,
-//
-
-//
-// From Shader Spec, ver. 1.10, rev. 59
-//
-// The output of the fragment shader is processed by the fixed function operations at the back end
-// of the OpenGL pipeline. Fragment shaders output values to the OpenGL pipeline using the built-in
-// variables gl_FragColor, gl_FragData and gl_FragDepth, unless the discard keyword is executed.
-//
-// 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\92s 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 executions of the
-// shader that take that path. That is, if a shader statically contains a write gl_FragDepth, then
-// it is responsible for always writing it.
-//
-// (A shader contains a static assignment to a variable x if, after pre-processing, the shader
-// contains statement that would write x, whether or not run-time flow of control will cause
-// that statement to be executed.)
-//
-// The variable gl_FragData is an array. Writing to gl_FragData[n] specifies the fragment data
-// that will be used by the subsequent fixed functionality pipeline for data n. If subsequent
-// fixed functionality consumes fragment data and an execution of a fragment shader does not
-// write a value to it, then the fragment data consumed is undefined.
-//
-// If a shader statically assigns a value to gl_FragColor, it may not assign a value to any element
-// of gl_FragData. If a shader statically writes a value to any element of gl_FragData, it may not
-// assign a value to gl_FragColor. That is, a shader may assign values to either gl_FragColor or
-// gl_FragData, but not both.
-//
-// If a shader executes the discard keyword, the fragment is discarded, and the values of
-// gl_FragDepth, gl_FragColor and gl_FragData 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\92s 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;
-vec4 gl_FragData[gl_MaxDrawBuffers];
-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\92t 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_MaxTextureCoords
-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:
-//
-// \95 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.
-//
-// \95 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.
-//
-// \95 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.
-//
-
-//
-// 8.7 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 that represents a depth texture with depth
-// comparisons turned on, then results are undefined. If a shadow texture call is made to a sampler
-// that represents a depth texture with depth comparisions turned off, the results are undefined.
-// If a shadow texture call is made to a sampler that does not represent a depth texture, then
-// results are 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 \93Lod\94 are allowed only in a vertex shader. For the \93Lod\94 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 \931D\94 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);
-}
-
-//
-// 8.8 Fragment Processing Functions
-//
-// 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));
-}
-
+++ /dev/null
-/*\r
- * Mesa 3-D graphics library\r
- * Version: 6.2\r
- *\r
- * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.\r
- *\r
- * Permission is hereby granted, free of charge, to any person obtaining a\r
- * copy of this software and associated documentation files (the "Software"),\r
- * to deal in the Software without restriction, including without limitation\r
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
- * and/or sell copies of the Software, and to permit persons to whom the\r
- * Software is furnished to do so, subject to the following conditions:\r
- *\r
- * The above copyright notice and this permission notice shall be included\r
- * in all copies or substantial portions of the Software.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN\r
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
- */\r
-\r
-/*\r
- * \file slang_shader.syn\r
- * slang shader syntax\r
- * \author Michal Krol\r
- */\r
-\r
-/*\r
- * usage:\r
- * syn2c slang_shader.syn > slang_shader_syn.h\r
- *\r
- * when modifying or extending this file, several things must be taken into consideration:\r
- * - when adding new operators that were marked as reserved in the initial specification,\r
- * one must only uncomment particular lines of code that refer to operators being added;\r
- * - when adding new shader target, one must reserve new value for shader_type register and\r
- * use it in .if constructs for symbols that are exclusive for that shader;\r
- * - some symbols mimic output of other symbols - the best example is the "for" construct:\r
- * expression "for (foo(); ; bar())" is seen as "for (foo(); true; bar())" by the output\r
- * processor - hence, special care must be taken when rearranging output of essential symbols;\r
- * - order of single-quoted tokens does matter in alternatives - so do not parse "<" operator\r
- * before "<<" and "<<" before "<<=";\r
- * - all double-quoted tokens are internally preprocessed to eliminate problems with parsing\r
- * strings that are prefixes of other strings, like "sampler1D" and "sampler1DShadow";\r
- */\r
-\r
-.syntax translation_unit;\r
-\r
-/* revision number - increment after each change affecting emitted output */\r
-.emtcode REVISION 1\r
-\r
-/* external declaration */\r
-.emtcode EXTERNAL_NULL 0\r
-.emtcode EXTERNAL_FUNCTION_DEFINITION 1\r
-.emtcode EXTERNAL_DECLARATION 2\r
-\r
-/* declaration */\r
-.emtcode DECLARATION_FUNCTION_PROTOTYPE 1\r
-.emtcode DECLARATION_INIT_DECLARATOR_LIST 2\r
-\r
-/* function type */\r
-.emtcode FUNCTION_ORDINARY 0\r
-.emtcode FUNCTION_CONSTRUCTOR 1\r
-.emtcode FUNCTION_OPERATOR 2\r
-\r
-/* operator type */\r
-.emtcode OPERATOR_ASSIGN 1\r
-.emtcode OPERATOR_ADDASSIGN 2\r
-.emtcode OPERATOR_SUBASSIGN 3\r
-.emtcode OPERATOR_MULASSIGN 4\r
-.emtcode OPERATOR_DIVASSIGN 5\r
-/*.emtcode OPERATOR_MODASSIGN 6*/\r
-/*.emtcode OPERATOR_LSHASSIGN 7*/\r
-/*.emtcode OPERATOR_RSHASSIGN 8*/\r
-/*.emtcode OPERATOR_ORASSIGN 9*/\r
-/*.emtcode OPERATOR_XORASSIGN 10*/\r
-/*.emtcode OPERATOR_ANDASSIGN 11*/\r
-.emtcode OPERATOR_LOGICALXOR 12\r
-/*.emtcode OPERATOR_BITOR 13*/\r
-/*.emtcode OPERATOR_BITXOR 14*/\r
-/*.emtcode OPERATOR_BITAND 15*/\r
-.emtcode OPERATOR_EQUAL 16\r
-.emtcode OPERATOR_NOTEQUAL 17\r
-.emtcode OPERATOR_LESS 18\r
-.emtcode OPERATOR_GREATER 19\r
-.emtcode OPERATOR_LESSEQUAL 20\r
-.emtcode OPERATOR_GREATEREQUAL 21\r
-/*.emtcode OPERATOR_LSHIFT 22*/\r
-/*.emtcode OPERATOR_RSHIFT 23*/\r
-.emtcode OPERATOR_MULTIPLY 24\r
-.emtcode OPERATOR_DIVIDE 25\r
-/*.emtcode OPERATOR_MODULUS 26*/\r
-.emtcode OPERATOR_INCREMENT 27\r
-.emtcode OPERATOR_DECREMENT 28\r
-.emtcode OPERATOR_PLUS 29\r
-.emtcode OPERATOR_MINUS 30\r
-/*.emtcode OPERATOR_COMPLEMENT 31*/\r
-.emtcode OPERATOR_NOT 32\r
-\r
-/* init declarator list */\r
-.emtcode DECLARATOR_NONE 0\r
-.emtcode DECLARATOR_NEXT 1\r
-\r
-/* variable declaration */\r
-.emtcode VARIABLE_NONE 0\r
-.emtcode VARIABLE_IDENTIFIER 1\r
-.emtcode VARIABLE_INITIALIZER 2\r
-.emtcode VARIABLE_ARRAY_EXPLICIT 3\r
-.emtcode VARIABLE_ARRAY_UNKNOWN 4\r
-\r
-/* type qualifier */\r
-.emtcode TYPE_QUALIFIER_NONE 0\r
-.emtcode TYPE_QUALIFIER_CONST 1\r
-.emtcode TYPE_QUALIFIER_ATTRIBUTE 2\r
-.emtcode TYPE_QUALIFIER_VARYING 3\r
-.emtcode TYPE_QUALIFIER_UNIFORM 4\r
-\r
-/* type specifier */\r
-.emtcode TYPE_SPECIFIER_VOID 0\r
-.emtcode TYPE_SPECIFIER_BOOL 1\r
-.emtcode TYPE_SPECIFIER_BVEC2 2\r
-.emtcode TYPE_SPECIFIER_BVEC3 3\r
-.emtcode TYPE_SPECIFIER_BVEC4 4\r
-.emtcode TYPE_SPECIFIER_INT 5\r
-.emtcode TYPE_SPECIFIER_IVEC2 6\r
-.emtcode TYPE_SPECIFIER_IVEC3 7\r
-.emtcode TYPE_SPECIFIER_IVEC4 8\r
-.emtcode TYPE_SPECIFIER_FLOAT 9\r
-.emtcode TYPE_SPECIFIER_VEC2 10\r
-.emtcode TYPE_SPECIFIER_VEC3 11\r
-.emtcode TYPE_SPECIFIER_VEC4 12\r
-.emtcode TYPE_SPECIFIER_MAT2 13\r
-.emtcode TYPE_SPECIFIER_MAT3 14\r
-.emtcode TYPE_SPECIFIER_MAT4 15\r
-.emtcode TYPE_SPECIFIER_SAMPLER1D 16\r
-.emtcode TYPE_SPECIFIER_SAMPLER2D 17\r
-.emtcode TYPE_SPECIFIER_SAMPLER3D 18\r
-.emtcode TYPE_SPECIFIER_SAMPLERCUBE 19\r
-.emtcode TYPE_SPECIFIER_SAMPLER1DSHADOW 20\r
-.emtcode TYPE_SPECIFIER_SAMPLER2DSHADOW 21\r
-.emtcode TYPE_SPECIFIER_STRUCT 22\r
-.emtcode TYPE_SPECIFIER_TYPENAME 23\r
-\r
-/* structure field */\r
-.emtcode FIELD_NONE 0\r
-.emtcode FIELD_NEXT 1\r
-.emtcode FIELD_ARRAY 2\r
-\r
-/* operation */\r
-.emtcode OP_END 0\r
-.emtcode OP_BLOCK_BEGIN_NO_NEW_SCOPE 1\r
-.emtcode OP_BLOCK_BEGIN_NEW_SCOPE 2\r
-.emtcode OP_DECLARE 3\r
-.emtcode OP_ASM 4\r
-.emtcode OP_BREAK 5\r
-.emtcode OP_CONTINUE 6\r
-.emtcode OP_DISCARD 7\r
-.emtcode OP_RETURN 8\r
-.emtcode OP_EXPRESSION 9\r
-.emtcode OP_IF 10\r
-.emtcode OP_WHILE 11\r
-.emtcode OP_DO 12\r
-.emtcode OP_FOR 13\r
-.emtcode OP_PUSH_VOID 14\r
-.emtcode OP_PUSH_BOOL 15\r
-.emtcode OP_PUSH_INT 16\r
-.emtcode OP_PUSH_FLOAT 17\r
-.emtcode OP_PUSH_IDENTIFIER 18\r
-.emtcode OP_SEQUENCE 19\r
-.emtcode OP_ASSIGN 20\r
-.emtcode OP_ADDASSIGN 21\r
-.emtcode OP_SUBASSIGN 22\r
-.emtcode OP_MULASSIGN 23\r
-.emtcode OP_DIVASSIGN 24\r
-/*.emtcode OP_MODASSIGN 25*/\r
-/*.emtcode OP_LSHASSIGN 26*/\r
-/*.emtcode OP_RSHASSIGN 27*/\r
-/*.emtcode OP_ORASSIGN 28*/\r
-/*.emtcode OP_XORASSIGN 29*/\r
-/*.emtcode OP_ANDASSIGN 30*/\r
-.emtcode OP_SELECT 31\r
-.emtcode OP_LOGICALOR 32\r
-.emtcode OP_LOGICALXOR 33\r
-.emtcode OP_LOGICALAND 34\r
-/*.emtcode OP_BITOR 35*/\r
-/*.emtcode OP_BITXOR 36*/\r
-/*.emtcode OP_BITAND 37*/\r
-.emtcode OP_EQUAL 38\r
-.emtcode OP_NOTEQUAL 39\r
-.emtcode OP_LESS 40\r
-.emtcode OP_GREATER 41\r
-.emtcode OP_LESSEQUAL 42\r
-.emtcode OP_GREATEREQUAL 43\r
-/*.emtcode OP_LSHIFT 44*/\r
-/*.emtcode OP_RSHIFT 45*/\r
-.emtcode OP_ADD 46\r
-.emtcode OP_SUBTRACT 47\r
-.emtcode OP_MULTIPLY 48\r
-.emtcode OP_DIVIDE 49\r
-/*.emtcode OP_MODULUS 50*/\r
-.emtcode OP_PREINCREMENT 51\r
-.emtcode OP_PREDECREMENT 52\r
-.emtcode OP_PLUS 53\r
-.emtcode OP_MINUS 54\r
-/*.emtcode OP_COMPLEMENT 55*/\r
-.emtcode OP_NOT 56\r
-.emtcode OP_SUBSCRIPT 57\r
-.emtcode OP_CALL 58\r
-.emtcode OP_FIELD 59\r
-.emtcode OP_POSTINCREMENT 60\r
-.emtcode OP_POSTDECREMENT 61\r
-\r
-/* parameter qualifier */\r
-.emtcode PARAM_QUALIFIER_IN 0\r
-.emtcode PARAM_QUALIFIER_OUT 1\r
-.emtcode PARAM_QUALIFIER_INOUT 2\r
-\r
-/* function parameter */\r
-.emtcode PARAMETER_NONE 0\r
-.emtcode PARAMETER_NEXT 1\r
-\r
-/* function parameter array presence */\r
-.emtcode PARAMETER_ARRAY_NOT_PRESENT 0\r
-.emtcode PARAMETER_ARRAY_PRESENT 1\r
-\r
-.errtext INVALID_EXTERNAL_DECLARATION "error 2001: invalid external declaration"\r
-.errtext INVALID_OPERATOR_OVERRIDE "error 2002: invalid operator override"\r
-.errtext LBRACE_EXPECTED "error 2003: '{' expected but '$err_token$' found"\r
-.errtext LPAREN_EXPECTED "error 2004: '(' expected but '$err_token$' found"\r
-.errtext RPAREN_EXPECTED "error 2005: ')' expected but '$err_token$' found"\r
-\r
-/* tells whether the shader that is being parsed is a built-in shader or not */\r
-/* 0 - normal behaviour */\r
-/* 1 - accepts constructor and operator definitions and __asm statements */\r
-/* the implementation will set it to 1 when compiling internal built-in shaders */\r
-.regbyte parsing_builtin 0\r
-\r
-/* holds the type of shader that is being parsed, possible values are listed below */\r
-/* FRAGMENT_SHADER 1 */\r
-/* VERTEX_SHADER 2 */\r
-/* shader type is set by the caller before parsing */\r
-.regbyte shader_type 0\r
-\r
-/*\r
- <variable_identifier> ::= <identifier>\r
-*/\r
-variable_identifier\r
- identifier .emit OP_PUSH_IDENTIFIER;\r
-\r
-/*\r
- <primary_expression> ::= <variable_identifier>\r
- | <intconstant>\r
- | <floatconstant>\r
- | <boolconstant>\r
- | "(" <expression> ")"\r
-*/\r
-primary_expression\r
- floatconstant .or boolconstant .or intconstant .or variable_identifier .or primary_expression_1;\r
-primary_expression_1\r
- lparen .and expression .and rparen;\r
-\r
-/*\r
- <postfix_expression> ::= <primary_expression>\r
- | <postfix_expression> "[" <integer_expression> "]"\r
- | <function_call>\r
- | <postfix_expression> "." <field_selection>\r
- | <postfix_expression> "++"\r
- | <postfix_expression> "--"\r
-*/\r
-postfix_expression\r
- postfix_expression_1 .and .loop postfix_expression_2;\r
-postfix_expression_1\r
- function_call .or primary_expression;\r
-postfix_expression_2\r
- postfix_expression_3 .or postfix_expression_4 .or\r
- plusplus .emit OP_POSTINCREMENT .or\r
- minusminus .emit OP_POSTDECREMENT;\r
-postfix_expression_3\r
- lbracket .and integer_expression .and rbracket .emit OP_SUBSCRIPT;\r
-postfix_expression_4\r
- dot .and field_selection .emit OP_FIELD;\r
-\r
-/*\r
- <integer_expression> ::= <expression>\r
-*/\r
-integer_expression\r
- expression;\r
-\r
-/*\r
- <function_call> ::= <function_call_generic>\r
-*/\r
-function_call\r
- function_call_generic .emit OP_CALL .and .true .emit OP_END;\r
-\r
-/*\r
- <function_call_generic> ::= <function_call_header_with_parameters> ")"\r
- | <function_call_header_no_parameters> ")"\r
-*/\r
-function_call_generic\r
- function_call_generic_1 .or function_call_generic_2;\r
-function_call_generic_1\r
- function_call_header_with_parameters .and rparen .error RPAREN_EXPECTED;\r
-function_call_generic_2\r
- function_call_header_no_parameters .and rparen .error RPAREN_EXPECTED;\r
-\r
-/*\r
- <function_call_header_no_parameters>::= <function_call_header> "void"\r
- | <function_call_header>\r
-*/\r
-function_call_header_no_parameters\r
- function_call_header .and function_call_header_no_parameters_1;\r
-function_call_header_no_parameters_1\r
- "void" .or .true;\r
-\r
-/*\r
- <function_call_header_with_parameters>::= <function_call_header> <assignment_expression>\r
- | <function_call_header_with_parameters> ","\r
- <assignment_expression>\r
-*/\r
-function_call_header_with_parameters\r
- function_call_header .and assignment_expression .and .true .emit OP_END .and\r
- .loop function_call_header_with_parameters_1;\r
-function_call_header_with_parameters_1\r
- comma .and assignment_expression .and .true .emit OP_END;\r
-\r
-/*\r
- <function_call_header> ::= <function_identifier> "("\r
-*/\r
-function_call_header\r
- function_identifier .and lparen;\r
-\r
-/*\r
- <function_identifier> ::= <constructor_identifier>\r
- | <identifier>\r
-\r
-note: <constructor_identifier> has been deleted\r
-*/\r
-function_identifier\r
- identifier;\r
-\r
-/*\r
- <unary_expression> ::= <postfix_expression>\r
- | "++" <unary_expression>\r
- | "--" <unary_expression>\r
- | <unary_operator> <unary_expression>\r
-\r
- <unary_operator> ::= "+"\r
- | "-"\r
- | "!"\r
- | "~" // reserved\r
-*/\r
-unary_expression\r
- postfix_expression .or unary_expression_1 .or unary_expression_2 .or unary_expression_3 .or\r
- unary_expression_4 .or unary_expression_5/* .or unary_expression_6*/;\r
-unary_expression_1\r
- plusplus .and unary_expression .and .true .emit OP_PREINCREMENT;\r
-unary_expression_2\r
- minusminus .and unary_expression .and .true .emit OP_PREDECREMENT;\r
-unary_expression_3\r
- plus .and unary_expression .and .true .emit OP_PLUS;\r
-unary_expression_4\r
- minus .and unary_expression .and .true .emit OP_MINUS;\r
-unary_expression_5\r
- bang .and unary_expression .and .true .emit OP_NOT;\r
-/*unary_expression_6\r
- tilde .and unary_expression .and .true .emit OP_COMPLEMENT;*/\r
-\r
-/*\r
- <multiplicative_expression> ::= <unary_expression>\r
- | <multiplicative_expression> "*" <unary_expression>\r
- | <multiplicative_expression> "/" <unary_expression>\r
- | <multiplicative_expression> "%" <unary_expression> // reserved\r
-*/\r
-multiplicative_expression\r
- unary_expression .and .loop multiplicative_expression_1;\r
-multiplicative_expression_1\r
- multiplicative_expression_2 .or multiplicative_expression_3/* .or multiplicative_expression_4*/;\r
-multiplicative_expression_2\r
- star .and unary_expression .and .true .emit OP_MULTIPLY;\r
-multiplicative_expression_3\r
- slash .and unary_expression .and .true .emit OP_DIVIDE;\r
-/*multiplicative_expression_4\r
- percent .and unary_expression .and .true .emit OP_MODULUS;*/\r
-\r
-/*\r
- <additive_expression> ::= <multiplicative_expression>\r
- | <additive_expression> "+" <multiplicative_expression>\r
- | <additive_expression> "-" <multiplicative_expression>\r
-*/\r
-additive_expression\r
- multiplicative_expression .and .loop additive_expression_1;\r
-additive_expression_1\r
- additive_expression_2 .or additive_expression_3;\r
-additive_expression_2\r
- plus .and multiplicative_expression .and .true .emit OP_ADD;\r
-additive_expression_3\r
- minus .and multiplicative_expression .and .true .emit OP_SUBTRACT;\r
-\r
-/*\r
- <shift_expression> ::= <additive_expression>\r
- | <shift_expression> "<<" <additive_expression> // reserved\r
- | <shift_expression> ">>" <additive_expression> // reserved\r
-*/\r
-shift_expression\r
- additive_expression/* .and .loop shift_expression_1*/;\r
-/*shift_expression_1\r
- shift_expression_2 .or shift_expression_3;*/\r
-/*shift_expression_2\r
- lessless .and additive_expression .and .true .emit OP_LSHIFT;*/\r
-/*shift_expression_3\r
- greatergreater .and additive_expression .and .true .emit OP_RSHIFT;*/\r
-\r
-/*\r
- <relational_expression> ::= <shift_expression>\r
- | <relational_expression> "<" <shift_expression>\r
- | <relational_expression> ">" <shift_expression>\r
- | <relational_expression> "<=" <shift_expression>\r
- | <relational_expression> ">=" <shift_expression>\r
-*/\r
-relational_expression\r
- shift_expression .and .loop relational_expression_1;\r
-relational_expression_1\r
- relational_expression_2 .or relational_expression_3 .or relational_expression_4 .or\r
- relational_expression_5;\r
-relational_expression_2\r
- lessequals .and shift_expression .and .true .emit OP_LESSEQUAL;\r
-relational_expression_3\r
- greaterequals .and shift_expression .and .true .emit OP_GREATEREQUAL;\r
-relational_expression_4\r
- less .and shift_expression .and .true .emit OP_LESS;\r
-relational_expression_5\r
- greater .and shift_expression .and .true .emit OP_GREATER;\r
-\r
-/*\r
- <equality_expression> ::= <relational_expression>\r
- | <equality_expression> "==" <relational_expression>\r
- | <equality_expression> "!=" <relational_expression>\r
-*/\r
-equality_expression\r
- relational_expression .and .loop equality_expression_1;\r
-equality_expression_1\r
- equality_expression_2 .or equality_expression_3;\r
-equality_expression_2\r
- equalsequals .and relational_expression .and .true .emit OP_EQUAL;\r
-equality_expression_3\r
- bangequals .and relational_expression .and .true .emit OP_NOTEQUAL;\r
-\r
-/*\r
- <and_expression> ::= <equality_expression>\r
- | <and_expression> "&" <equality_expression> // reserved\r
-*/\r
-and_expression\r
- equality_expression/* .and .loop and_expression_1*/;\r
-/*and_expression_1\r
- ampersand .and equality_expression .and .true .emit OP_BITAND;*/\r
-\r
-/*\r
- <exclusive_or_expression> ::= <and_expression>\r
- | <exclusive_or_expression> "^" <and_expression> // reserved\r
-*/\r
-exclusive_or_expression\r
- and_expression/* .and .loop exclusive_or_expression_1*/;\r
-/*exclusive_or_expression_1\r
- caret .and and_expression .and .true .emit OP_BITXOR;*/\r
-\r
-/*\r
- <inclusive_or_expression> ::= <exclusive_or_expression>\r
- | <inclusive_or_expression> "|" <exclusive_or_expression> // reserved\r
-*/\r
-inclusive_or_expression\r
- exclusive_or_expression/* .and .loop inclusive_or_expression_1*/;\r
-/*inclusive_or_expression_1\r
- bar .and exclusive_or_expression .and .true .emit OP_BITOR;*/\r
-\r
-/*\r
- <logical_and_expression> ::= <inclusive_or_expression>\r
- | <logical_and_expression> "&&" <inclusive_or_expression>\r
-*/\r
-logical_and_expression\r
- inclusive_or_expression .and .loop logical_and_expression_1;\r
-logical_and_expression_1\r
- ampersandampersand .and inclusive_or_expression .and .true .emit OP_LOGICALAND;\r
-\r
-/*\r
- <logical_xor_expression> ::= <logical_and_expression>\r
- | <logical_xor_expression> "^^" <logical_and_expression>\r
-*/\r
-logical_xor_expression\r
- logical_and_expression .and .loop logical_xor_expression_1;\r
-logical_xor_expression_1\r
- caretcaret .and logical_and_expression .and .true .emit OP_LOGICALXOR;\r
-\r
-/*\r
- <logical_or_expression> ::= <logical_xor_expression>\r
- | <logical_or_expression> "||" <logical_xor_expression>\r
-*/\r
-logical_or_expression\r
- logical_xor_expression .and .loop logical_or_expression_1;\r
-logical_or_expression_1\r
- barbar .and logical_xor_expression .and .true .emit OP_LOGICALOR;\r
-\r
-/*\r
- <conditional_expression> ::= <logical_or_expression>\r
- | <logical_or_expression> "?" <expression> ":"\r
- <conditional_expression>\r
-*/\r
-conditional_expression\r
- logical_or_expression .and .loop conditional_expression_1;\r
-conditional_expression_1\r
- question .and expression .and colon .and conditional_expression .and .true .emit OP_SELECT;\r
-\r
-/*\r
- <assignment_expression> ::= <conditional_expression>\r
- | <unary_expression> <assignment_operator>\r
- <assignment_expression>\r
-\r
- <assignment_operator> ::= "="\r
- | "*="\r
- | "/="\r
- | "+="\r
- | "-="\r
- | "%=" // reserved\r
- | "<<=" // reserved\r
- | ">>=" // reserved\r
- | "&=" // reserved\r
- | "^=" // reserved\r
- | "|=" // reserved\r
-*/\r
-assignment_expression\r
- assignment_expression_1 .or assignment_expression_2 .or assignment_expression_3 .or\r
- assignment_expression_4 .or assignment_expression_5/* .or assignment_expression_6 .or\r
- assignment_expression_7 .or assignment_expression_8 .or assignment_expression_9 .or\r
- assignment_expression_10 .or assignment_expression_11*/ .or conditional_expression;\r
-assignment_expression_1\r
- unary_expression .and equals .and assignment_expression .and .true .emit OP_ASSIGN;\r
-assignment_expression_2\r
- unary_expression .and starequals .and assignment_expression .and .true .emit OP_MULASSIGN;\r
-assignment_expression_3\r
- unary_expression .and slashequals .and assignment_expression .and .true .emit OP_DIVASSIGN;\r
-assignment_expression_4\r
- unary_expression .and plusequals .and assignment_expression .and .true .emit OP_ADDASSIGN;\r
-assignment_expression_5\r
- unary_expression .and minusequals .and assignment_expression .and .true .emit OP_SUBASSIGN;\r
-/*assignment_expression_6\r
- unary_expression .and percentequals .and assignment_expression .and .true .emit OP_MODASSIGN;*/\r
-/*assignment_expression_7\r
- unary_expression .and lesslessequals .and assignment_expression .and .true .emit OP_LSHASSIGN;*/\r
-/*assignment_expression_8\r
- unary_expression .and greatergreaterequals .and assignment_expression .and\r
- .true .emit OP_RSHASSIGN;*/\r
-/*assignment_expression_9\r
- unary_expression .and ampersandequals .and assignment_expression .and .true .emit OP_ANDASSIGN;*/\r
-/*assignment_expression_10\r
- unary_expression .and caretequals .and assignment_expression .and .true .emit OP_XORASSIGN;*/\r
-/*assignment_expression_11\r
- unary_expression .and barequals .and assignment_expression .and .true .emit OP_ORASSIGN;*/\r
-\r
-/*\r
- <expression> ::= <assignment_expression>\r
- | <expression> "," <assignment_expression>\r
-*/\r
-expression\r
- assignment_expression .and .loop expression_1;\r
-expression_1\r
- comma .and assignment_expression .and .true .emit OP_SEQUENCE;\r
-\r
-/*\r
- <constant_expression> ::= <conditional_expression>\r
-*/\r
-constant_expression\r
- conditional_expression .and .true .emit OP_END;\r
-\r
-/*\r
- <declaration> ::= <function_prototype> ";"\r
- | <init_declarator_list> ";"\r
-*/\r
-declaration\r
- declaration_1 .or declaration_2;\r
-declaration_1\r
- function_prototype .emit DECLARATION_FUNCTION_PROTOTYPE .and semicolon;\r
-declaration_2\r
- init_declarator_list .emit DECLARATION_INIT_DECLARATOR_LIST .and semicolon;\r
-\r
-/*\r
- <function_prototype> ::= <function_declarator> ")"\r
-*/\r
-function_prototype\r
- function_declarator .and rparen .error RPAREN_EXPECTED .emit PARAMETER_NONE;\r
-\r
-/*\r
- <function_declarator> ::= <function_header>\r
- | <function_header_with_parameters>\r
-*/\r
-function_declarator\r
- function_header_with_parameters .or function_header;\r
-\r
-/*\r
- <function_header_with_parameters> ::= <function_header> <parameter_declaration>\r
- | <function_header_with_parameters> ","\r
- <parameter_declaration>\r
-*/\r
-function_header_with_parameters\r
- function_header .and parameter_declaration .and .loop function_header_with_parameters_1;\r
-function_header_with_parameters_1\r
- comma .and parameter_declaration;\r
-\r
-/*\r
- <function_header> ::= <fully_specified_type> <identifier> "("\r
-*/\r
-function_header\r
- function_header_nospace .or function_header_space;\r
-function_header_space\r
- fully_specified_type_space .and space .and function_decl_identifier .and lparen;\r
-function_header_nospace\r
- fully_specified_type_nospace .and function_decl_identifier .and lparen;\r
-\r
-/*\r
- <function_decl_identifier> ::= "__constructor"\r
- | <__operator>\r
- | <identifier>\r
-\r
-note: this is an extension to the standard language specification - normally slang disallows\r
- operator and constructor prototypes and definitions\r
-*/\r
-function_decl_identifier\r
- .if (parsing_builtin != 0) __operator .emit FUNCTION_OPERATOR .or\r
- .if (parsing_builtin != 0) "__constructor" .emit FUNCTION_CONSTRUCTOR .or\r
- identifier .emit FUNCTION_ORDINARY;\r
-\r
-/*\r
- <__operator> ::= "__operator" <overriden_op>\r
-\r
-note: this is an extension to the standard language specification - normally slang disallows\r
- operator prototypes and definitions\r
-*/\r
-__operator\r
- "__operator" .and overriden_operator .error INVALID_OPERATOR_OVERRIDE;\r
-\r
-/*\r
- <overriden_op> ::= "="\r
- | "+="\r
- | "-="\r
- | "*="\r
- | "/="\r
- | "%=" // reserved\r
- | "<<=" // reserved\r
- | ">>=" // reserved\r
- | "&=" // reserved\r
- | "^=" // reserved\r
- | "|=" // reserved\r
- | "^^"\r
- | "|" // reserved\r
- | "^" // reserved\r
- | "&" // reserved\r
- | "=="\r
- | "!="\r
- | "<"\r
- | ">"\r
- | "<="\r
- | ">="\r
- | "<<" // reserved\r
- | ">>" // reserved\r
- | "*"\r
- | "/"\r
- | "%" // reserved\r
- | "++"\r
- | "--"\r
- | "+"\r
- | "-"\r
- | "~" // reserved\r
- | "!"\r
-\r
-note: this is an extension to the standard language specification - normally slang disallows\r
- operator prototypes and definitions\r
-*/\r
-overriden_operator\r
- plusplus .emit OPERATOR_INCREMENT .or\r
- plusequals .emit OPERATOR_ADDASSIGN .or\r
- plus .emit OPERATOR_PLUS .or\r
- minusminus .emit OPERATOR_DECREMENT .or\r
- minusequals .emit OPERATOR_SUBASSIGN .or\r
- minus .emit OPERATOR_MINUS .or\r
- bangequals .emit OPERATOR_NOTEQUAL .or\r
- bang .emit OPERATOR_NOT .or\r
- starequals .emit OPERATOR_MULASSIGN .or\r
- star .emit OPERATOR_MULTIPLY .or\r
- slashequals .emit OPERATOR_DIVASSIGN .or\r
- slash .emit OPERATOR_DIVIDE .or\r
- lessequals .emit OPERATOR_LESSEQUAL .or\r
- /*lesslessequals .emit OPERATOR_LSHASSIGN .or*/\r
- /*lessless .emit OPERATOR_LSHIFT .or*/\r
- less .emit OPERATOR_LESS .or\r
- greaterequals .emit OPERATOR_GREATEREQUAL .or\r
- /*greatergreaterequals .emit OPERATOR_RSHASSIGN .or*/\r
- /*greatergreater .emit OPERATOR_RSHIFT .or*/\r
- greater .emit OPERATOR_GREATER .or\r
- equalsequals .emit OPERATOR_EQUAL .or\r
- equals .emit OPERATOR_ASSIGN .or\r
- /*percentequals .emit OPERATOR_MODASSIGN .or*/\r
- /*percent .emit OPERATOR_MODULUS .or*/\r
- /*ampersandequals .emit OPERATOR_ANDASSIGN */\r
- /*ampersand .emit OPERATOR_BITAND .or*/\r
- /*barequals .emit OPERATOR_ORASSIGN .or*/\r
- /*bar .emit OPERATOR_BITOR .or*/\r
- /*tilde .emit OPERATOR_COMPLEMENT .or*/\r
- /*caretequals .emit OPERATOR_XORASSIGN .or*/\r
- caretcaret .emit OPERATOR_LOGICALXOR /*.or\r
- caret .emit OPERATOR_BITXOR*/;\r
-\r
-/*\r
- <parameter_declarator> ::= <type_specifier> <identifier>\r
- | <type_specifier> <identifier> "[" <constant_expression>\r
- "]"\r
-*/\r
-parameter_declarator\r
- parameter_declarator_nospace .or parameter_declarator_space;\r
-parameter_declarator_nospace\r
- type_specifier_nospace .and identifier .and parameter_declarator_1;\r
-parameter_declarator_space\r
- type_specifier_space .and space .and identifier .and parameter_declarator_1;\r
-parameter_declarator_1\r
- parameter_declarator_2 .emit PARAMETER_ARRAY_PRESENT .or\r
- .true .emit PARAMETER_ARRAY_NOT_PRESENT;\r
-parameter_declarator_2\r
- lbracket .and constant_expression .and rbracket;\r
-\r
-/*\r
- <parameter_declaration> ::= <type_qualifier> <parameter_qualifier>\r
- <parameter_declarator>\r
- | <type_qualifier> <parameter_qualifier>\r
- <parameter_type_specifier>\r
- | <parameter_qualifier> <parameter_declarator>\r
- | <parameter_qualifier> <parameter_type_specifier>\r
-*/\r
-parameter_declaration\r
- parameter_declaration_1 .emit PARAMETER_NEXT;\r
-parameter_declaration_1\r
- parameter_declaration_2 .or parameter_declaration_3;\r
-parameter_declaration_2\r
- type_qualifier .and space .and parameter_qualifier .and parameter_declaration_4;\r
-parameter_declaration_3\r
- parameter_qualifier .emit TYPE_QUALIFIER_NONE .and parameter_declaration_4;\r
-parameter_declaration_4\r
- parameter_declarator .or parameter_type_specifier;\r
-\r
-/*\r
- <parameter_qualifier> ::= "in"\r
- | "out"\r
- | "inout"\r
- | ""\r
-*/\r
-parameter_qualifier\r
- parameter_qualifier_1 .or .true .emit PARAM_QUALIFIER_IN;\r
-parameter_qualifier_1\r
- parameter_qualifier_2 .and space;\r
-parameter_qualifier_2\r
- "in" .emit PARAM_QUALIFIER_IN .or\r
- "out" .emit PARAM_QUALIFIER_OUT .or\r
- "inout" .emit PARAM_QUALIFIER_INOUT;\r
-\r
-/*\r
- <parameter_type_specifier> ::= <type_specifier>\r
- | <type_specifier> "[" <constant_expression> "]"\r
-*/\r
-parameter_type_specifier\r
- parameter_type_specifier_1 .and .true .emit '\0' .and parameter_type_specifier_2;\r
-parameter_type_specifier_1\r
- type_specifier_nospace .or type_specifier_space;\r
-parameter_type_specifier_2\r
- parameter_type_specifier_3 .emit PARAMETER_ARRAY_PRESENT .or\r
- .true .emit PARAMETER_ARRAY_NOT_PRESENT;\r
-parameter_type_specifier_3\r
- lbracket .and constant_expression .and rbracket;\r
-\r
-/*\r
- <init_declarator_list> ::= <single_declaration>\r
- | <init_declarator_list> "," <identifier>\r
- | <init_declarator_list> "," <identifier> "[" "]"\r
- | <init_declarator_list> "," <identifier> "["\r
- <constant_expression> "]"\r
- | <init_declarator_list> "," <identifier> "="\r
- <initializer>\r
-*/\r
-init_declarator_list\r
- single_declaration .and .loop init_declarator_list_1 .emit DECLARATOR_NEXT .and\r
- .true .emit DECLARATOR_NONE;\r
-init_declarator_list_1\r
- comma .and identifier .emit VARIABLE_IDENTIFIER .and init_declarator_list_2;\r
-init_declarator_list_2\r
- init_declarator_list_3 .or init_declarator_list_4 .or .true .emit VARIABLE_NONE;\r
-init_declarator_list_3\r
- equals .and initializer .emit VARIABLE_INITIALIZER;\r
-init_declarator_list_4\r
- lbracket .and init_declarator_list_5 .and rbracket;\r
-init_declarator_list_5\r
- constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\r
-\r
-/*\r
- <single_declaration> ::= <fully_specified_type>\r
- | <fully_specified_type> <identifier>\r
- | <fully_specified_type> <identifier> "[" "]"\r
- | <fully_specified_type> <identifier> "["\r
- <constant_expression> "]"\r
- | <fully_specified_type> <identifier> "=" <initializer>\r
-*/\r
-single_declaration\r
- single_declaration_nospace .or single_declaration_space;\r
-single_declaration_space\r
- fully_specified_type_space .and single_declaration_space_1;\r
-single_declaration_nospace\r
- fully_specified_type_nospace .and single_declaration_nospace_1;\r
-single_declaration_space_1\r
- single_declaration_space_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\r
-single_declaration_nospace_1\r
- single_declaration_nospace_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\r
-single_declaration_space_2\r
- space .and identifier .and single_declaration_3;\r
-single_declaration_nospace_2\r
- identifier .and single_declaration_3;\r
-single_declaration_3\r
- single_declaration_4 .or single_declaration_5 .or .true .emit VARIABLE_NONE;\r
-single_declaration_4\r
- equals .and initializer .emit VARIABLE_INITIALIZER;\r
-single_declaration_5\r
- lbracket .and single_declaration_6 .and rbracket;\r
-single_declaration_6\r
- constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\r
-\r
-/*\r
- <fully_specified_type> ::= <type_specifier>\r
- | <type_qualifier> <type_specifier>\r
-*/\r
-fully_specified_type_space\r
- fully_specified_type_1 .and type_specifier_space;\r
-fully_specified_type_nospace\r
- fully_specified_type_1 .and type_specifier_nospace;\r
-fully_specified_type_1\r
- fully_specified_type_2 .or .true .emit TYPE_QUALIFIER_NONE;\r
-fully_specified_type_2\r
- type_qualifier .and space;\r
-\r
-/*\r
- <type_qualifier> ::= "const"\r
- | "attribute" // Vertex only.\r
- | "varying"\r
- | "uniform"\r
-*/\r
-type_qualifier\r
- "const" .emit TYPE_QUALIFIER_CONST .or\r
- .if (shader_type == 2) "attribute" .emit TYPE_QUALIFIER_ATTRIBUTE .or\r
- "varying" .emit TYPE_QUALIFIER_VARYING .or\r
- "uniform" .emit TYPE_QUALIFIER_UNIFORM;\r
-\r
-/*\r
- <type_specifier> ::= "void"\r
- | "float"\r
- | "int"\r
- | "bool"\r
- | "vec2"\r
- | "vec3"\r
- | "vec4"\r
- | "bvec2"\r
- | "bvec3"\r
- | "bvec4"\r
- | "ivec2"\r
- | "ivec3"\r
- | "ivec4"\r
- | "mat2"\r
- | "mat3"\r
- | "mat4"\r
- | "sampler1D"\r
- | "sampler2D"\r
- | "sampler3D"\r
- | "samplerCube"\r
- | "sampler1DShadow"\r
- | "sampler2DShadow"\r
- | <struct_specifier>\r
- | <type_name>\r
-*/\r
-type_specifier_space\r
- "void" .emit TYPE_SPECIFIER_VOID .or\r
- "float" .emit TYPE_SPECIFIER_FLOAT .or\r
- "int" .emit TYPE_SPECIFIER_INT .or\r
- "bool" .emit TYPE_SPECIFIER_BOOL .or\r
- "vec2" .emit TYPE_SPECIFIER_VEC2 .or\r
- "vec3" .emit TYPE_SPECIFIER_VEC3 .or\r
- "vec4" .emit TYPE_SPECIFIER_VEC4 .or\r
- "bvec2" .emit TYPE_SPECIFIER_BVEC2 .or\r
- "bvec3" .emit TYPE_SPECIFIER_BVEC3 .or\r
- "bvec4" .emit TYPE_SPECIFIER_BVEC4 .or\r
- "ivec2" .emit TYPE_SPECIFIER_IVEC2 .or\r
- "ivec3" .emit TYPE_SPECIFIER_IVEC3 .or\r
- "ivec4" .emit TYPE_SPECIFIER_IVEC4 .or\r
- "mat2" .emit TYPE_SPECIFIER_MAT2 .or\r
- "mat3" .emit TYPE_SPECIFIER_MAT3 .or\r
- "mat4" .emit TYPE_SPECIFIER_MAT4 .or\r
- "sampler1D" .emit TYPE_SPECIFIER_SAMPLER1D .or\r
- "sampler2D" .emit TYPE_SPECIFIER_SAMPLER2D .or\r
- "sampler3D" .emit TYPE_SPECIFIER_SAMPLER3D .or\r
- "samplerCube" .emit TYPE_SPECIFIER_SAMPLERCUBE .or\r
- "sampler1DShadow" .emit TYPE_SPECIFIER_SAMPLER1DSHADOW .or\r
- "sampler2DShadow" .emit TYPE_SPECIFIER_SAMPLER2DSHADOW .or\r
- type_name .emit TYPE_SPECIFIER_TYPENAME;\r
-type_specifier_nospace\r
- struct_specifier .emit TYPE_SPECIFIER_STRUCT;\r
-\r
-/*\r
- <struct_specifier> ::= "struct" <identifier> "{" <struct_declaration_list> "}"\r
- | "struct" "{" <struct_declaration_list> "}"\r
-*/\r
-struct_specifier\r
- "struct" .and struct_specifier_1 .and optional_space .and lbrace .error LBRACE_EXPECTED .and\r
- struct_declaration_list .and rbrace .emit FIELD_NONE;\r
-struct_specifier_1\r
- struct_specifier_2 .or .true .emit '\0';\r
-struct_specifier_2\r
- space .and identifier;\r
-\r
-/*\r
- <struct_declaration_list> ::= <struct_declaration>\r
- | <struct_declaration_list> <struct_declaration>\r
-*/\r
-struct_declaration_list\r
- struct_declaration .and .loop struct_declaration .emit FIELD_NEXT;\r
-\r
-/*\r
- <struct_declaration> ::= <type_specifier> <struct_declarator_list> ";"\r
-*/\r
-struct_declaration\r
- struct_declaration_nospace .or struct_declaration_space;\r
-struct_declaration_space\r
- type_specifier_space .and space .and struct_declarator_list .and semicolon .emit FIELD_NONE;\r
-struct_declaration_nospace\r
- type_specifier_nospace .and struct_declarator_list .and semicolon .emit FIELD_NONE;\r
-\r
-/*\r
- <struct_declarator_list> ::= <struct_declarator>\r
- | <struct_declarator_list> "," <struct_declarator>\r
-*/\r
-struct_declarator_list\r
- struct_declarator .and .loop struct_declarator_list_1 .emit FIELD_NEXT;\r
-struct_declarator_list_1\r
- comma .and struct_declarator;\r
-\r
-/*\r
- <struct_declarator> ::= <identifier>\r
- | <identifier> "[" <constant_expression> "]"\r
-*/\r
-struct_declarator\r
- identifier .and struct_declarator_1;\r
-struct_declarator_1\r
- struct_declarator_2 .emit FIELD_ARRAY .or .true .emit FIELD_NONE;\r
-struct_declarator_2\r
- lbracket .and constant_expression .and rbracket;\r
-\r
-/*\r
- <initializer> ::= <assignment_expression>\r
-*/\r
-initializer\r
- assignment_expression .and .true .emit OP_END;\r
-\r
-/*\r
- <declaration_statement> ::= <declaration>\r
-*/\r
-declaration_statement\r
- declaration;\r
-\r
-/*\r
- <statement> ::= <compound_statement>\r
- | <simple_statement>\r
-*/\r
-statement\r
- compound_statement .or simple_statement;\r
-statement_space\r
- compound_statement .or statement_space_1;\r
-statement_space_1\r
- space .and simple_statement;\r
-\r
-/*\r
- <simple_statement> ::= <__asm_statement>\r
- | <selection_statement>\r
- | <iteration_statement>\r
- | <jump_statement>\r
- | <expression_statement>\r
- | <declaration_statement>\r
-\r
-note: this is an extension to the standard language specification - normally slang disallows\r
- use of __asm statements\r
-*/\r
-simple_statement\r
- .if (parsing_builtin != 0) __asm_statement .emit OP_ASM .or\r
- selection_statement .or\r
- iteration_statement .or\r
- jump_statement .or\r
- expression_statement .emit OP_EXPRESSION .or\r
- declaration_statement .emit OP_DECLARE;\r
-\r
-/*\r
- <compound_statement> ::= "{" "}"\r
- | "{" <statement_list> "}"\r
-*/\r
-compound_statement\r
- compound_statement_1 .emit OP_BLOCK_BEGIN_NEW_SCOPE .and .true .emit OP_END;\r
-compound_statement_1\r
- compound_statement_2 .or compound_statement_3;\r
-compound_statement_2\r
- lbrace .and rbrace;\r
-compound_statement_3\r
- lbrace .and statement_list .and rbrace;\r
-\r
-/*\r
- <statement_no_new_scope> ::= <compound_statement_no_new_scope>\r
- | <simple_statement>\r
-*/\r
-statement_no_new_scope\r
- compound_statement_no_new_scope .or simple_statement;\r
-\r
-/*\r
- <compound_statement_no_new_scope> ::= "{" "}"\r
- | "{" <statement_list> "}"\r
-*/\r
-compound_statement_no_new_scope\r
- compound_statement_no_new_scope_1 .emit OP_BLOCK_BEGIN_NO_NEW_SCOPE .and .true .emit OP_END;\r
-compound_statement_no_new_scope_1\r
- compound_statement_no_new_scope_2 .or compound_statement_no_new_scope_3;\r
-compound_statement_no_new_scope_2\r
- lbrace .and rbrace;\r
-compound_statement_no_new_scope_3\r
- lbrace .and statement_list .and rbrace;\r
-\r
-/*\r
- <statement_list> ::= <statement>\r
- | <statement_list> <statement>\r
-*/\r
-statement_list\r
- statement .and .loop statement;\r
-\r
-/*\r
- <expression_statement> ::= ";"\r
- | <expression> ";"\r
-*/\r
-expression_statement\r
- expression_statement_1 .or expression_statement_2;\r
-expression_statement_1\r
- semicolon .emit OP_PUSH_VOID .emit OP_END;\r
-expression_statement_2\r
- expression .and semicolon .emit OP_END;\r
-\r
-/*\r
- <selection_statement> ::= "if" "(" <expression> ")" <selection_rest_statement>\r
-*/\r
-selection_statement\r
- "if" .emit OP_IF .and lparen .error LPAREN_EXPECTED .and expression .and\r
- rparen .error RPAREN_EXPECTED .emit OP_END .and selection_rest_statement;\r
-\r
-/*\r
- <selection_rest_statement> ::= <statement> "else" <statement>\r
- | <statement>\r
-*/\r
-selection_rest_statement\r
- statement .and selection_rest_statement_1;\r
-selection_rest_statement_1\r
- selection_rest_statement_2 .or .true .emit OP_EXPRESSION .emit OP_PUSH_VOID .emit OP_END;\r
-selection_rest_statement_2\r
- "else" .and optional_space .and statement;\r
-\r
-/*\r
- <condition> ::= <expression>\r
- | <fully_specified_type> <identifier> "=" <initializer>\r
-\r
-note: if <condition_1> is executed, the emit format must match <declaration> emit format\r
-*/\r
-condition\r
- condition_1 .emit OP_DECLARE .emit DECLARATION_INIT_DECLARATOR_LIST .or\r
- condition_3 .emit OP_EXPRESSION;\r
-condition_1\r
- condition_1_nospace .or condition_1_space;\r
-condition_1_nospace\r
- fully_specified_type_nospace .and condition_2;\r
-condition_1_space\r
- fully_specified_type_space .and space .and condition_2;\r
-condition_2\r
- identifier .emit VARIABLE_IDENTIFIER .and equals .emit VARIABLE_INITIALIZER .and\r
- initializer .and .true .emit DECLARATOR_NONE;\r
-condition_3\r
- expression .and .true .emit OP_END;\r
-\r
-/*\r
- <iteration_statement> ::= "while" "(" <condition> ")" <statement_no_new_scope>\r
- | "do" <statement> "while" "(" <expression> ")" ";"\r
- | "for" "(" <for_init_statement> <for_rest_statement> ")"\r
- <statement_no_new_scope>\r
-*/\r
-iteration_statement\r
- iteration_statement_1 .or iteration_statement_2 .or iteration_statement_3;\r
-iteration_statement_1\r
- "while" .emit OP_WHILE .and lparen .error LPAREN_EXPECTED .and condition .and\r
- rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\r
-iteration_statement_2\r
- "do" .emit OP_DO .and statement_space .and "while" .and lparen .error LPAREN_EXPECTED .and\r
- expression .and rparen .error RPAREN_EXPECTED .emit OP_END .and semicolon;\r
-iteration_statement_3\r
- "for" .emit OP_FOR .and lparen .error LPAREN_EXPECTED .and for_init_statement .and\r
- for_rest_statement .and rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\r
-\r
-/*\r
- <for_init_statement> ::= <expression_statement>\r
- | <declaration_statement>\r
-*/\r
-for_init_statement\r
- expression_statement .or declaration_statement;\r
-\r
-/*\r
- <conditionopt> ::= <condition>\r
- | ""\r
-\r
-note: <conditionopt> is used only by "for" statement - if <condition> is ommitted, parser\r
- simulates default behaviour, that is simulates "true" expression\r
-*/\r
-conditionopt\r
- condition .or\r
- .true .emit OP_EXPRESSION .emit OP_PUSH_BOOL .emit 2 .emit '1' .emit '\0' .emit OP_END;\r
-\r
-/*\r
- <for_rest_statement> ::= <conditionopt> ";"\r
- | <conditionopt> ";" <expression>\r
-*/\r
-for_rest_statement\r
- conditionopt .and semicolon .and for_rest_statement_1;\r
-for_rest_statement_1\r
- for_rest_statement_2 .or .true .emit OP_PUSH_VOID .emit OP_END;\r
-for_rest_statement_2\r
- expression .and .true .emit OP_END;\r
-\r
-/*\r
- <jump_statement> ::= "continue" ";"\r
- | "break" ";"\r
- | "return" ";"\r
- | "return" <expression> ";"\r
- | "discard" ";" // Fragment shader only.\r
-*/\r
-jump_statement\r
- jump_statement_1 .or jump_statement_2 .or jump_statement_3 .or jump_statement_4 .or\r
- .if (shader_type == 1) jump_statement_5;\r
-jump_statement_1\r
- "continue" .and semicolon .emit OP_CONTINUE;\r
-jump_statement_2\r
- "break" .and semicolon .emit OP_BREAK;\r
-jump_statement_3\r
- "return" .emit OP_RETURN .and optional_space .and expression .and semicolon .emit OP_END;\r
-jump_statement_4\r
- "return" .emit OP_RETURN .and semicolon .emit OP_PUSH_VOID .emit OP_END;\r
-jump_statement_5\r
- "discard" .and semicolon .emit OP_DISCARD;\r
-\r
-/*\r
- <__asm_statement> ::= "__asm" <identifier> <asm_arguments> ";"\r
-\r
-note: this is an extension to the standard language specification - normally slang disallows\r
- __asm statements\r
-*/\r
-__asm_statement\r
- "__asm" .and space .and identifier .and space .and asm_arguments .and semicolon .emit OP_END;\r
-\r
-/*\r
- <asm_arguments> ::= <identifier>\r
- | <asm_arguments> "," <identifier>\r
-\r
-note: this is an extension to the standard language specification - normally slang disallows\r
- __asm statements\r
-*/\r
-asm_arguments\r
- variable_identifier .and .true .emit OP_END .and .loop asm_arguments_1;\r
-asm_arguments_1\r
- comma .and variable_identifier .and .true .emit OP_END;\r
-\r
-/*\r
- <translation_unit> ::= <external_declaration>\r
- | <translation_unit> <external_declaration>\r
-*/\r
-translation_unit\r
- optional_space .emit REVISION .and external_declaration .error INVALID_EXTERNAL_DECLARATION .and\r
- .loop external_declaration .and optional_space .and\r
- '\0' .error INVALID_EXTERNAL_DECLARATION .emit EXTERNAL_NULL;\r
-\r
-/*\r
- <external_declaration> ::= <function_definition>\r
- | <declaration>\r
-*/\r
-external_declaration\r
- function_definition .emit EXTERNAL_FUNCTION_DEFINITION .or\r
- declaration .emit EXTERNAL_DECLARATION;\r
-\r
-/*\r
- <function_definition> :: <function_prototype> <compound_statement_no_new_scope>\r
-*/\r
-function_definition\r
- function_prototype .and compound_statement_no_new_scope;\r
-\r
-/* helper rulez, not part of the official language syntax */\r
-\r
-digit_oct\r
- '0'-'7';\r
-\r
-digit_dec\r
- '0'-'9';\r
-\r
-digit_hex\r
- '0'-'9' .or 'A'-'F' .or 'a'-'f';\r
-\r
-id_character_first\r
- 'a'-'z' .or 'A'-'Z' .or '_';\r
-\r
-id_character_next\r
- id_character_first .or digit_dec;\r
-\r
-identifier\r
- id_character_first .emit * .and .loop id_character_next .emit * .and .true .emit '\0';\r
-\r
-float\r
- float_1 .or float_2;\r
-float_1\r
- float_fractional_constant .and float_optional_exponent_part;\r
-float_2\r
- float_digit_sequence .and .true .emit '\0' .and float_exponent_part;\r
-\r
-float_fractional_constant\r
- float_fractional_constant_1 .or float_fractional_constant_2 .or float_fractional_constant_3;\r
-float_fractional_constant_1\r
- float_digit_sequence .and '.' .and float_digit_sequence;\r
-float_fractional_constant_2\r
- float_digit_sequence .and '.' .and .true .emit '\0';\r
-float_fractional_constant_3\r
- '.' .emit '\0' .and float_digit_sequence;\r
-\r
-float_optional_exponent_part\r
- float_exponent_part .or .true .emit '\0';\r
-\r
-float_digit_sequence\r
- digit_dec .emit * .and .loop digit_dec .emit * .and .true .emit '\0';\r
-\r
-float_exponent_part\r
- float_exponent_part_1 .or float_exponent_part_2;\r
-float_exponent_part_1\r
- 'e' .and float_optional_sign .and float_digit_sequence;\r
-float_exponent_part_2\r
- 'E' .and float_optional_sign .and float_digit_sequence;\r
-\r
-float_optional_sign\r
- float_sign .or .true;\r
-\r
-float_sign\r
- '+' .or '-' .emit '-';\r
-\r
-integer\r
- integer_hex .or integer_oct .or integer_dec;\r
-\r
-integer_hex\r
- '0' .and integer_hex_1 .emit 0x10 .and digit_hex .emit * .and .loop digit_hex .emit * .and\r
- .true .emit '\0';\r
-integer_hex_1\r
- 'x' .or 'X';\r
-\r
-integer_oct\r
- '0' .emit 8 .emit * .and .loop digit_oct .emit * .and .true .emit '\0';\r
-\r
-integer_dec\r
- digit_dec .emit 10 .emit * .and .loop digit_dec .emit * .and .true .emit '\0';\r
-\r
-boolean\r
- "true" .emit 2 .emit '1' .emit '\0' .or\r
- "false" .emit 2 .emit '0' .emit '\0';\r
-\r
-type_name\r
- identifier;\r
-\r
-field_selection\r
- identifier;\r
-\r
-floatconstant\r
- float .emit OP_PUSH_FLOAT;\r
-\r
-intconstant\r
- integer .emit OP_PUSH_INT;\r
-\r
-boolconstant\r
- boolean .emit OP_PUSH_BOOL;\r
-\r
-optional_space\r
- .loop single_space;\r
-\r
-space\r
- single_space .and .loop single_space;\r
-\r
-single_space\r
- white_char .or c_style_comment_block .or cpp_style_comment_block;\r
-\r
-white_char\r
- ' ' .or '\t' .or new_line .or '\v' .or '\f';\r
-\r
-new_line\r
- cr_lf .or lf_cr .or '\n' .or '\r';\r
-\r
-cr_lf\r
- '\r' .and '\n';\r
-\r
-lf_cr\r
- '\n' .and '\r';\r
-\r
-c_style_comment_block\r
- '/' .and '*' .and c_style_comment_rest;\r
-\r
-c_style_comment_rest\r
- .loop c_style_comment_char_no_star .and c_style_comment_rest_1;\r
-c_style_comment_rest_1\r
- c_style_comment_end .or c_style_comment_rest_2;\r
-c_style_comment_rest_2\r
- '*' .and c_style_comment_rest;\r
-\r
-c_style_comment_char_no_star\r
- '\x2B'-'\xFF' .or '\x01'-'\x29';\r
-\r
-c_style_comment_end\r
- '*' .and '/';\r
-\r
-cpp_style_comment_block\r
- '/' .and '/' .and cpp_style_comment_block_1;\r
-cpp_style_comment_block_1\r
- cpp_style_comment_block_2 .or cpp_style_comment_block_3;\r
-cpp_style_comment_block_2\r
- .loop cpp_style_comment_char .and new_line;\r
-cpp_style_comment_block_3\r
- .loop cpp_style_comment_char;\r
-\r
-cpp_style_comment_char\r
- '\x0E'-'\xFF' .or '\x01'-'\x09' .or '\x0B'-'\x0C';\r
-\r
-/* lexical rulez */\r
-\r
-/*ampersand\r
- optional_space .and '&' .and optional_space;*/\r
-\r
-ampersandampersand\r
- optional_space .and '&' .and '&' .and optional_space;\r
-\r
-/*ampersandequals\r
- optional_space .and '&' .and '=' .and optional_space;*/\r
-\r
-/*bar\r
- optional_space .and '|' .and optional_space;*/\r
-\r
-barbar\r
- optional_space .and '|' .and '|' .and optional_space;\r
-\r
-/*barequals\r
- optional_space .and '|' .and '=' .and optional_space;*/\r
-\r
-bang\r
- optional_space .and '!' .and optional_space;\r
-\r
-bangequals\r
- optional_space .and '!' .and '=' .and optional_space;\r
-\r
-/*caret\r
- optional_space .and '^' .and optional_space;*/\r
-\r
-caretcaret\r
- optional_space .and '^' .and '^' .and optional_space;\r
-\r
-/*caretequals\r
- optional_space .and '^' .and '=' .and optional_space;*/\r
-\r
-colon\r
- optional_space .and ':' .and optional_space;\r
-\r
-comma\r
- optional_space .and ',' .and optional_space;\r
-\r
-dot\r
- optional_space .and '.' .and optional_space;\r
-\r
-equals\r
- optional_space .and '=' .and optional_space;\r
-\r
-equalsequals\r
- optional_space .and '=' .and '=' .and optional_space;\r
-\r
-greater\r
- optional_space .and '>' .and optional_space;\r
-\r
-greaterequals\r
- optional_space .and '>' .and '=' .and optional_space;\r
-\r
-/*greatergreater\r
- optional_space .and '>' .and '>' .and optional_space;*/\r
-\r
-/*greatergreaterequals\r
- optional_space .and '>' .and '>' .and '=' .and optional_space;*/\r
-\r
-lbrace\r
- optional_space .and '{' .and optional_space;\r
-\r
-lbracket\r
- optional_space .and '[' .and optional_space;\r
-\r
-less\r
- optional_space .and '<' .and optional_space;\r
-\r
-lessequals\r
- optional_space .and '<' .and '=' .and optional_space;\r
-\r
-/*lessless\r
- optional_space .and '<' .and '<' .and optional_space;*/\r
-\r
-/*lesslessequals\r
- optional_space .and '<' .and '<' .and '=' .and optional_space;*/\r
-\r
-lparen\r
- optional_space .and '(' .and optional_space;\r
-\r
-minus\r
- optional_space .and '-' .and optional_space;\r
-\r
-minusequals\r
- optional_space .and '-' .and '=' .and optional_space;\r
-\r
-minusminus\r
- optional_space .and '-' .and '-' .and optional_space;\r
-\r
-/*percent\r
- optional_space .and '%' .and optional_space;*/\r
-\r
-/*percentequals\r
- optional_space .and '%' .and '=' .and optional_space;*/\r
-\r
-plus\r
- optional_space .and '+' .and optional_space;\r
-\r
-plusequals\r
- optional_space .and '+' .and '=' .and optional_space;\r
-\r
-plusplus\r
- optional_space .and '+' .and '+' .and optional_space;\r
-\r
-question\r
- optional_space .and '?' .and optional_space;\r
-\r
-rbrace\r
- optional_space .and '}' .and optional_space;\r
-\r
-rbracket\r
- optional_space .and ']' .and optional_space;\r
-\r
-rparen\r
- optional_space .and ')' .and optional_space;\r
-\r
-semicolon\r
- optional_space .and ';' .and optional_space;\r
-\r
-slash\r
- optional_space .and '/' .and optional_space;\r
-\r
-slashequals\r
- optional_space .and '/' .and '=' .and optional_space;\r
-\r
-star\r
- optional_space .and '*' .and optional_space;\r
-\r
-starequals\r
- optional_space .and '*' .and '=' .and optional_space;\r
-\r
-/*tilde\r
- optional_space .and '~' .and optional_space;*/\r
-\r
-/* string rulez - these are used internally by the parser when parsing quoted strings */\r
-\r
-.string string_lexer;\r
-\r
-string_lexer\r
- lex_first_identifier_character .and .loop lex_next_identifier_character;\r
-\r
-lex_first_identifier_character\r
- 'a'-'z' .or 'A'-'Z' .or '_';\r
-\r
-lex_next_identifier_character\r
- 'a'-'z' .or 'A'-'Z' .or '0'-'9' .or '_';\r
-\r
-/* error rulez - these are used by error messages */\r
-\r
-err_token\r
- '~' .or '`' .or '!' .or '@' .or '#' .or '$' .or '%' .or '^' .or '&' .or '*' .or '(' .or ')' .or\r
- '-' .or '+' .or '=' .or '|' .or '\\' .or '[' .or ']' .or '{' .or '}' .or ':' .or ';' .or '"' .or\r
- '\'' .or '<' .or ',' .or '>' .or '.' .or '/' .or '?' .or err_identifier;\r
-\r
-err_identifier\r
- id_character_first .and .loop id_character_next;\r
-\r
+++ /dev/null
-".syntax translation_unit;\n"\r
-".emtcode REVISION 1\n"\r
-".emtcode EXTERNAL_NULL 0\n"\r
-".emtcode EXTERNAL_FUNCTION_DEFINITION 1\n"\r
-".emtcode EXTERNAL_DECLARATION 2\n"\r
-".emtcode DECLARATION_FUNCTION_PROTOTYPE 1\n"\r
-".emtcode DECLARATION_INIT_DECLARATOR_LIST 2\n"\r
-".emtcode FUNCTION_ORDINARY 0\n"\r
-".emtcode FUNCTION_CONSTRUCTOR 1\n"\r
-".emtcode FUNCTION_OPERATOR 2\n"\r
-".emtcode OPERATOR_ASSIGN 1\n"\r
-".emtcode OPERATOR_ADDASSIGN 2\n"\r
-".emtcode OPERATOR_SUBASSIGN 3\n"\r
-".emtcode OPERATOR_MULASSIGN 4\n"\r
-".emtcode OPERATOR_DIVASSIGN 5\n"\r
-".emtcode OPERATOR_LOGICALXOR 12\n"\r
-".emtcode OPERATOR_EQUAL 16\n"\r
-".emtcode OPERATOR_NOTEQUAL 17\n"\r
-".emtcode OPERATOR_LESS 18\n"\r
-".emtcode OPERATOR_GREATER 19\n"\r
-".emtcode OPERATOR_LESSEQUAL 20\n"\r
-".emtcode OPERATOR_GREATEREQUAL 21\n"\r
-".emtcode OPERATOR_MULTIPLY 24\n"\r
-".emtcode OPERATOR_DIVIDE 25\n"\r
-".emtcode OPERATOR_INCREMENT 27\n"\r
-".emtcode OPERATOR_DECREMENT 28\n"\r
-".emtcode OPERATOR_PLUS 29\n"\r
-".emtcode OPERATOR_MINUS 30\n"\r
-".emtcode OPERATOR_NOT 32\n"\r
-".emtcode DECLARATOR_NONE 0\n"\r
-".emtcode DECLARATOR_NEXT 1\n"\r
-".emtcode VARIABLE_NONE 0\n"\r
-".emtcode VARIABLE_IDENTIFIER 1\n"\r
-".emtcode VARIABLE_INITIALIZER 2\n"\r
-".emtcode VARIABLE_ARRAY_EXPLICIT 3\n"\r
-".emtcode VARIABLE_ARRAY_UNKNOWN 4\n"\r
-".emtcode TYPE_QUALIFIER_NONE 0\n"\r
-".emtcode TYPE_QUALIFIER_CONST 1\n"\r
-".emtcode TYPE_QUALIFIER_ATTRIBUTE 2\n"\r
-".emtcode TYPE_QUALIFIER_VARYING 3\n"\r
-".emtcode TYPE_QUALIFIER_UNIFORM 4\n"\r
-".emtcode TYPE_SPECIFIER_VOID 0\n"\r
-".emtcode TYPE_SPECIFIER_BOOL 1\n"\r
-".emtcode TYPE_SPECIFIER_BVEC2 2\n"\r
-".emtcode TYPE_SPECIFIER_BVEC3 3\n"\r
-".emtcode TYPE_SPECIFIER_BVEC4 4\n"\r
-".emtcode TYPE_SPECIFIER_INT 5\n"\r
-".emtcode TYPE_SPECIFIER_IVEC2 6\n"\r
-".emtcode TYPE_SPECIFIER_IVEC3 7\n"\r
-".emtcode TYPE_SPECIFIER_IVEC4 8\n"\r
-".emtcode TYPE_SPECIFIER_FLOAT 9\n"\r
-".emtcode TYPE_SPECIFIER_VEC2 10\n"\r
-".emtcode TYPE_SPECIFIER_VEC3 11\n"\r
-".emtcode TYPE_SPECIFIER_VEC4 12\n"\r
-".emtcode TYPE_SPECIFIER_MAT2 13\n"\r
-".emtcode TYPE_SPECIFIER_MAT3 14\n"\r
-".emtcode TYPE_SPECIFIER_MAT4 15\n"\r
-".emtcode TYPE_SPECIFIER_SAMPLER1D 16\n"\r
-".emtcode TYPE_SPECIFIER_SAMPLER2D 17\n"\r
-".emtcode TYPE_SPECIFIER_SAMPLER3D 18\n"\r
-".emtcode TYPE_SPECIFIER_SAMPLERCUBE 19\n"\r
-".emtcode TYPE_SPECIFIER_SAMPLER1DSHADOW 20\n"\r
-".emtcode TYPE_SPECIFIER_SAMPLER2DSHADOW 21\n"\r
-".emtcode TYPE_SPECIFIER_STRUCT 22\n"\r
-".emtcode TYPE_SPECIFIER_TYPENAME 23\n"\r
-".emtcode FIELD_NONE 0\n"\r
-".emtcode FIELD_NEXT 1\n"\r
-".emtcode FIELD_ARRAY 2\n"\r
-".emtcode OP_END 0\n"\r
-".emtcode OP_BLOCK_BEGIN_NO_NEW_SCOPE 1\n"\r
-".emtcode OP_BLOCK_BEGIN_NEW_SCOPE 2\n"\r
-".emtcode OP_DECLARE 3\n"\r
-".emtcode OP_ASM 4\n"\r
-".emtcode OP_BREAK 5\n"\r
-".emtcode OP_CONTINUE 6\n"\r
-".emtcode OP_DISCARD 7\n"\r
-".emtcode OP_RETURN 8\n"\r
-".emtcode OP_EXPRESSION 9\n"\r
-".emtcode OP_IF 10\n"\r
-".emtcode OP_WHILE 11\n"\r
-".emtcode OP_DO 12\n"\r
-".emtcode OP_FOR 13\n"\r
-".emtcode OP_PUSH_VOID 14\n"\r
-".emtcode OP_PUSH_BOOL 15\n"\r
-".emtcode OP_PUSH_INT 16\n"\r
-".emtcode OP_PUSH_FLOAT 17\n"\r
-".emtcode OP_PUSH_IDENTIFIER 18\n"\r
-".emtcode OP_SEQUENCE 19\n"\r
-".emtcode OP_ASSIGN 20\n"\r
-".emtcode OP_ADDASSIGN 21\n"\r
-".emtcode OP_SUBASSIGN 22\n"\r
-".emtcode OP_MULASSIGN 23\n"\r
-".emtcode OP_DIVASSIGN 24\n"\r
-".emtcode OP_SELECT 31\n"\r
-".emtcode OP_LOGICALOR 32\n"\r
-".emtcode OP_LOGICALXOR 33\n"\r
-".emtcode OP_LOGICALAND 34\n"\r
-".emtcode OP_EQUAL 38\n"\r
-".emtcode OP_NOTEQUAL 39\n"\r
-".emtcode OP_LESS 40\n"\r
-".emtcode OP_GREATER 41\n"\r
-".emtcode OP_LESSEQUAL 42\n"\r
-".emtcode OP_GREATEREQUAL 43\n"\r
-".emtcode OP_ADD 46\n"\r
-".emtcode OP_SUBTRACT 47\n"\r
-".emtcode OP_MULTIPLY 48\n"\r
-".emtcode OP_DIVIDE 49\n"\r
-".emtcode OP_PREINCREMENT 51\n"\r
-".emtcode OP_PREDECREMENT 52\n"\r
-".emtcode OP_PLUS 53\n"\r
-".emtcode OP_MINUS 54\n"\r
-".emtcode OP_NOT 56\n"\r
-".emtcode OP_SUBSCRIPT 57\n"\r
-".emtcode OP_CALL 58\n"\r
-".emtcode OP_FIELD 59\n"\r
-".emtcode OP_POSTINCREMENT 60\n"\r
-".emtcode OP_POSTDECREMENT 61\n"\r
-".emtcode PARAM_QUALIFIER_IN 0\n"\r
-".emtcode PARAM_QUALIFIER_OUT 1\n"\r
-".emtcode PARAM_QUALIFIER_INOUT 2\n"\r
-".emtcode PARAMETER_NONE 0\n"\r
-".emtcode PARAMETER_NEXT 1\n"\r
-".emtcode PARAMETER_ARRAY_NOT_PRESENT 0\n"\r
-".emtcode PARAMETER_ARRAY_PRESENT 1\n"\r
-".errtext INVALID_EXTERNAL_DECLARATION \"error 2001: invalid external declaration\"\n"\r
-".errtext INVALID_OPERATOR_OVERRIDE \"error 2002: invalid operator override\"\n"\r
-".errtext LBRACE_EXPECTED \"error 2003: '{' expected but '$err_token$' found\"\n"\r
-".errtext LPAREN_EXPECTED \"error 2004: '(' expected but '$err_token$' found\"\n"\r
-".errtext RPAREN_EXPECTED \"error 2005: ')' expected but '$err_token$' found\"\n"\r
-".regbyte parsing_builtin 0\n"\r
-".regbyte shader_type 0\n"\r
-"variable_identifier\n"\r
-" identifier .emit OP_PUSH_IDENTIFIER;\n"\r
-"primary_expression\n"\r
-" floatconstant .or boolconstant .or intconstant .or variable_identifier .or primary_expression_1;\n"\r
-"primary_expression_1\n"\r
-" lparen .and expression .and rparen;\n"\r
-"postfix_expression\n"\r
-" postfix_expression_1 .and .loop postfix_expression_2;\n"\r
-"postfix_expression_1\n"\r
-" function_call .or primary_expression;\n"\r
-"postfix_expression_2\n"\r
-" postfix_expression_3 .or postfix_expression_4 .or\n"\r
-" plusplus .emit OP_POSTINCREMENT .or\n"\r
-" minusminus .emit OP_POSTDECREMENT;\n"\r
-"postfix_expression_3\n"\r
-" lbracket .and integer_expression .and rbracket .emit OP_SUBSCRIPT;\n"\r
-"postfix_expression_4\n"\r
-" dot .and field_selection .emit OP_FIELD;\n"\r
-"integer_expression\n"\r
-" expression;\n"\r
-"function_call\n"\r
-" function_call_generic .emit OP_CALL .and .true .emit OP_END;\n"\r
-"function_call_generic\n"\r
-" function_call_generic_1 .or function_call_generic_2;\n"\r
-"function_call_generic_1\n"\r
-" function_call_header_with_parameters .and rparen .error RPAREN_EXPECTED;\n"\r
-"function_call_generic_2\n"\r
-" function_call_header_no_parameters .and rparen .error RPAREN_EXPECTED;\n"\r
-"function_call_header_no_parameters\n"\r
-" function_call_header .and function_call_header_no_parameters_1;\n"\r
-"function_call_header_no_parameters_1\n"\r
-" \"void\" .or .true;\n"\r
-"function_call_header_with_parameters\n"\r
-" function_call_header .and assignment_expression .and .true .emit OP_END .and\n"\r
-" .loop function_call_header_with_parameters_1;\n"\r
-"function_call_header_with_parameters_1\n"\r
-" comma .and assignment_expression .and .true .emit OP_END;\n"\r
-"function_call_header\n"\r
-" function_identifier .and lparen;\n"\r
-"function_identifier\n"\r
-" identifier;\n"\r
-"unary_expression\n"\r
-" postfix_expression .or unary_expression_1 .or unary_expression_2 .or unary_expression_3 .or\n"\r
-" unary_expression_4 .or unary_expression_5;\n"\r
-"unary_expression_1\n"\r
-" plusplus .and unary_expression .and .true .emit OP_PREINCREMENT;\n"\r
-"unary_expression_2\n"\r
-" minusminus .and unary_expression .and .true .emit OP_PREDECREMENT;\n"\r
-"unary_expression_3\n"\r
-" plus .and unary_expression .and .true .emit OP_PLUS;\n"\r
-"unary_expression_4\n"\r
-" minus .and unary_expression .and .true .emit OP_MINUS;\n"\r
-"unary_expression_5\n"\r
-" bang .and unary_expression .and .true .emit OP_NOT;\n"\r
-"multiplicative_expression\n"\r
-" unary_expression .and .loop multiplicative_expression_1;\n"\r
-"multiplicative_expression_1\n"\r
-" multiplicative_expression_2 .or multiplicative_expression_3;\n"\r
-"multiplicative_expression_2\n"\r
-" star .and unary_expression .and .true .emit OP_MULTIPLY;\n"\r
-"multiplicative_expression_3\n"\r
-" slash .and unary_expression .and .true .emit OP_DIVIDE;\n"\r
-"additive_expression\n"\r
-" multiplicative_expression .and .loop additive_expression_1;\n"\r
-"additive_expression_1\n"\r
-" additive_expression_2 .or additive_expression_3;\n"\r
-"additive_expression_2\n"\r
-" plus .and multiplicative_expression .and .true .emit OP_ADD;\n"\r
-"additive_expression_3\n"\r
-" minus .and multiplicative_expression .and .true .emit OP_SUBTRACT;\n"\r
-"shift_expression\n"\r
-" additive_expression;\n"\r
-"relational_expression\n"\r
-" shift_expression .and .loop relational_expression_1;\n"\r
-"relational_expression_1\n"\r
-" relational_expression_2 .or relational_expression_3 .or relational_expression_4 .or\n"\r
-" relational_expression_5;\n"\r
-"relational_expression_2\n"\r
-" lessequals .and shift_expression .and .true .emit OP_LESSEQUAL;\n"\r
-"relational_expression_3\n"\r
-" greaterequals .and shift_expression .and .true .emit OP_GREATEREQUAL;\n"\r
-"relational_expression_4\n"\r
-" less .and shift_expression .and .true .emit OP_LESS;\n"\r
-"relational_expression_5\n"\r
-" greater .and shift_expression .and .true .emit OP_GREATER;\n"\r
-"equality_expression\n"\r
-" relational_expression .and .loop equality_expression_1;\n"\r
-"equality_expression_1\n"\r
-" equality_expression_2 .or equality_expression_3;\n"\r
-"equality_expression_2\n"\r
-" equalsequals .and relational_expression .and .true .emit OP_EQUAL;\n"\r
-"equality_expression_3\n"\r
-" bangequals .and relational_expression .and .true .emit OP_NOTEQUAL;\n"\r
-"and_expression\n"\r
-" equality_expression;\n"\r
-"exclusive_or_expression\n"\r
-" and_expression;\n"\r
-"inclusive_or_expression\n"\r
-" exclusive_or_expression;\n"\r
-"logical_and_expression\n"\r
-" inclusive_or_expression .and .loop logical_and_expression_1;\n"\r
-"logical_and_expression_1\n"\r
-" ampersandampersand .and inclusive_or_expression .and .true .emit OP_LOGICALAND;\n"\r
-"logical_xor_expression\n"\r
-" logical_and_expression .and .loop logical_xor_expression_1;\n"\r
-"logical_xor_expression_1\n"\r
-" caretcaret .and logical_and_expression .and .true .emit OP_LOGICALXOR;\n"\r
-"logical_or_expression\n"\r
-" logical_xor_expression .and .loop logical_or_expression_1;\n"\r
-"logical_or_expression_1\n"\r
-" barbar .and logical_xor_expression .and .true .emit OP_LOGICALOR;\n"\r
-"conditional_expression\n"\r
-" logical_or_expression .and .loop conditional_expression_1;\n"\r
-"conditional_expression_1\n"\r
-" question .and expression .and colon .and conditional_expression .and .true .emit OP_SELECT;\n"\r
-"assignment_expression\n"\r
-" assignment_expression_1 .or assignment_expression_2 .or assignment_expression_3 .or\n"\r
-" assignment_expression_4 .or assignment_expression_5 .or conditional_expression;\n"\r
-"assignment_expression_1\n"\r
-" unary_expression .and equals .and assignment_expression .and .true .emit OP_ASSIGN;\n"\r
-"assignment_expression_2\n"\r
-" unary_expression .and starequals .and assignment_expression .and .true .emit OP_MULASSIGN;\n"\r
-"assignment_expression_3\n"\r
-" unary_expression .and slashequals .and assignment_expression .and .true .emit OP_DIVASSIGN;\n"\r
-"assignment_expression_4\n"\r
-" unary_expression .and plusequals .and assignment_expression .and .true .emit OP_ADDASSIGN;\n"\r
-"assignment_expression_5\n"\r
-" unary_expression .and minusequals .and assignment_expression .and .true .emit OP_SUBASSIGN;\n"\r
-"expression\n"\r
-" assignment_expression .and .loop expression_1;\n"\r
-"expression_1\n"\r
-" comma .and assignment_expression .and .true .emit OP_SEQUENCE;\n"\r
-"constant_expression\n"\r
-" conditional_expression .and .true .emit OP_END;\n"\r
-"declaration\n"\r
-" declaration_1 .or declaration_2;\n"\r
-"declaration_1\n"\r
-" function_prototype .emit DECLARATION_FUNCTION_PROTOTYPE .and semicolon;\n"\r
-"declaration_2\n"\r
-" init_declarator_list .emit DECLARATION_INIT_DECLARATOR_LIST .and semicolon;\n"\r
-"function_prototype\n"\r
-" function_declarator .and rparen .error RPAREN_EXPECTED .emit PARAMETER_NONE;\n"\r
-"function_declarator\n"\r
-" function_header_with_parameters .or function_header;\n"\r
-"function_header_with_parameters\n"\r
-" function_header .and parameter_declaration .and .loop function_header_with_parameters_1;\n"\r
-"function_header_with_parameters_1\n"\r
-" comma .and parameter_declaration;\n"\r
-"function_header\n"\r
-" function_header_nospace .or function_header_space;\n"\r
-"function_header_space\n"\r
-" fully_specified_type_space .and space .and function_decl_identifier .and lparen;\n"\r
-"function_header_nospace\n"\r
-" fully_specified_type_nospace .and function_decl_identifier .and lparen;\n"\r
-"function_decl_identifier\n"\r
-" .if (parsing_builtin != 0) __operator .emit FUNCTION_OPERATOR .or\n"\r
-" .if (parsing_builtin != 0) \"__constructor\" .emit FUNCTION_CONSTRUCTOR .or\n"\r
-" identifier .emit FUNCTION_ORDINARY;\n"\r
-"__operator\n"\r
-" \"__operator\" .and overriden_operator .error INVALID_OPERATOR_OVERRIDE;\n"\r
-"overriden_operator\n"\r
-" plusplus .emit OPERATOR_INCREMENT .or\n"\r
-" plusequals .emit OPERATOR_ADDASSIGN .or\n"\r
-" plus .emit OPERATOR_PLUS .or\n"\r
-" minusminus .emit OPERATOR_DECREMENT .or\n"\r
-" minusequals .emit OPERATOR_SUBASSIGN .or\n"\r
-" minus .emit OPERATOR_MINUS .or\n"\r
-" bangequals .emit OPERATOR_NOTEQUAL .or\n"\r
-" bang .emit OPERATOR_NOT .or\n"\r
-" starequals .emit OPERATOR_MULASSIGN .or\n"\r
-" star .emit OPERATOR_MULTIPLY .or\n"\r
-" slashequals .emit OPERATOR_DIVASSIGN .or\n"\r
-" slash .emit OPERATOR_DIVIDE .or\n"\r
-" lessequals .emit OPERATOR_LESSEQUAL .or\n"\r
-" \n"\r
-" \n"\r
-" less .emit OPERATOR_LESS .or\n"\r
-" greaterequals .emit OPERATOR_GREATEREQUAL .or\n"\r
-" \n"\r
-" \n"\r
-" greater .emit OPERATOR_GREATER .or\n"\r
-" equalsequals .emit OPERATOR_EQUAL .or\n"\r
-" equals .emit OPERATOR_ASSIGN .or\n"\r
-" \n"\r
-" \n"\r
-" \n"\r
-" \n"\r
-" \n"\r
-" \n"\r
-" \n"\r
-" \n"\r
-" caretcaret .emit OPERATOR_LOGICALXOR ;\n"\r
-"parameter_declarator\n"\r
-" parameter_declarator_nospace .or parameter_declarator_space;\n"\r
-"parameter_declarator_nospace\n"\r
-" type_specifier_nospace .and identifier .and parameter_declarator_1;\n"\r
-"parameter_declarator_space\n"\r
-" type_specifier_space .and space .and identifier .and parameter_declarator_1;\n"\r
-"parameter_declarator_1\n"\r
-" parameter_declarator_2 .emit PARAMETER_ARRAY_PRESENT .or\n"\r
-" .true .emit PARAMETER_ARRAY_NOT_PRESENT;\n"\r
-"parameter_declarator_2\n"\r
-" lbracket .and constant_expression .and rbracket;\n"\r
-"parameter_declaration\n"\r
-" parameter_declaration_1 .emit PARAMETER_NEXT;\n"\r
-"parameter_declaration_1\n"\r
-" parameter_declaration_2 .or parameter_declaration_3;\n"\r
-"parameter_declaration_2\n"\r
-" type_qualifier .and space .and parameter_qualifier .and parameter_declaration_4;\n"\r
-"parameter_declaration_3\n"\r
-" parameter_qualifier .emit TYPE_QUALIFIER_NONE .and parameter_declaration_4;\n"\r
-"parameter_declaration_4\n"\r
-" parameter_declarator .or parameter_type_specifier;\n"\r
-"parameter_qualifier\n"\r
-" parameter_qualifier_1 .or .true .emit PARAM_QUALIFIER_IN;\n"\r
-"parameter_qualifier_1\n"\r
-" parameter_qualifier_2 .and space;\n"\r
-"parameter_qualifier_2\n"\r
-" \"in\" .emit PARAM_QUALIFIER_IN .or\n"\r
-" \"out\" .emit PARAM_QUALIFIER_OUT .or\n"\r
-" \"inout\" .emit PARAM_QUALIFIER_INOUT;\n"\r
-"parameter_type_specifier\n"\r
-" parameter_type_specifier_1 .and .true .emit '\\0' .and parameter_type_specifier_2;\n"\r
-"parameter_type_specifier_1\n"\r
-" type_specifier_nospace .or type_specifier_space;\n"\r
-"parameter_type_specifier_2\n"\r
-" parameter_type_specifier_3 .emit PARAMETER_ARRAY_PRESENT .or\n"\r
-" .true .emit PARAMETER_ARRAY_NOT_PRESENT;\n"\r
-"parameter_type_specifier_3\n"\r
-" lbracket .and constant_expression .and rbracket;\n"\r
-"init_declarator_list\n"\r
-" single_declaration .and .loop init_declarator_list_1 .emit DECLARATOR_NEXT .and\n"\r
-" .true .emit DECLARATOR_NONE;\n"\r
-"init_declarator_list_1\n"\r
-" comma .and identifier .emit VARIABLE_IDENTIFIER .and init_declarator_list_2;\n"\r
-"init_declarator_list_2\n"\r
-" init_declarator_list_3 .or init_declarator_list_4 .or .true .emit VARIABLE_NONE;\n"\r
-"init_declarator_list_3\n"\r
-" equals .and initializer .emit VARIABLE_INITIALIZER;\n"\r
-"init_declarator_list_4\n"\r
-" lbracket .and init_declarator_list_5 .and rbracket;\n"\r
-"init_declarator_list_5\n"\r
-" constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\n"\r
-"single_declaration\n"\r
-" single_declaration_nospace .or single_declaration_space;\n"\r
-"single_declaration_space\n"\r
-" fully_specified_type_space .and single_declaration_space_1;\n"\r
-"single_declaration_nospace\n"\r
-" fully_specified_type_nospace .and single_declaration_nospace_1;\n"\r
-"single_declaration_space_1\n"\r
-" single_declaration_space_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\n"\r
-"single_declaration_nospace_1\n"\r
-" single_declaration_nospace_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;\n"\r
-"single_declaration_space_2\n"\r
-" space .and identifier .and single_declaration_3;\n"\r
-"single_declaration_nospace_2\n"\r
-" identifier .and single_declaration_3;\n"\r
-"single_declaration_3\n"\r
-" single_declaration_4 .or single_declaration_5 .or .true .emit VARIABLE_NONE;\n"\r
-"single_declaration_4\n"\r
-" equals .and initializer .emit VARIABLE_INITIALIZER;\n"\r
-"single_declaration_5\n"\r
-" lbracket .and single_declaration_6 .and rbracket;\n"\r
-"single_declaration_6\n"\r
-" constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;\n"\r
-"fully_specified_type_space\n"\r
-" fully_specified_type_1 .and type_specifier_space;\n"\r
-"fully_specified_type_nospace\n"\r
-" fully_specified_type_1 .and type_specifier_nospace;\n"\r
-"fully_specified_type_1\n"\r
-" fully_specified_type_2 .or .true .emit TYPE_QUALIFIER_NONE;\n"\r
-"fully_specified_type_2\n"\r
-" type_qualifier .and space;\n"\r
-"type_qualifier\n"\r
-" \"const\" .emit TYPE_QUALIFIER_CONST .or\n"\r
-" .if (shader_type == 2) \"attribute\" .emit TYPE_QUALIFIER_ATTRIBUTE .or\n"\r
-" \"varying\" .emit TYPE_QUALIFIER_VARYING .or\n"\r
-" \"uniform\" .emit TYPE_QUALIFIER_UNIFORM;\n"\r
-"type_specifier_space\n"\r
-" \"void\" .emit TYPE_SPECIFIER_VOID .or\n"\r
-" \"float\" .emit TYPE_SPECIFIER_FLOAT .or\n"\r
-" \"int\" .emit TYPE_SPECIFIER_INT .or\n"\r
-" \"bool\" .emit TYPE_SPECIFIER_BOOL .or\n"\r
-" \"vec2\" .emit TYPE_SPECIFIER_VEC2 .or\n"\r
-" \"vec3\" .emit TYPE_SPECIFIER_VEC3 .or\n"\r
-" \"vec4\" .emit TYPE_SPECIFIER_VEC4 .or\n"\r
-" \"bvec2\" .emit TYPE_SPECIFIER_BVEC2 .or\n"\r
-" \"bvec3\" .emit TYPE_SPECIFIER_BVEC3 .or\n"\r
-" \"bvec4\" .emit TYPE_SPECIFIER_BVEC4 .or\n"\r
-" \"ivec2\" .emit TYPE_SPECIFIER_IVEC2 .or\n"\r
-" \"ivec3\" .emit TYPE_SPECIFIER_IVEC3 .or\n"\r
-" \"ivec4\" .emit TYPE_SPECIFIER_IVEC4 .or\n"\r
-" \"mat2\" .emit TYPE_SPECIFIER_MAT2 .or\n"\r
-" \"mat3\" .emit TYPE_SPECIFIER_MAT3 .or\n"\r
-" \"mat4\" .emit TYPE_SPECIFIER_MAT4 .or\n"\r
-" \"sampler1D\" .emit TYPE_SPECIFIER_SAMPLER1D .or\n"\r
-" \"sampler2D\" .emit TYPE_SPECIFIER_SAMPLER2D .or\n"\r
-" \"sampler3D\" .emit TYPE_SPECIFIER_SAMPLER3D .or\n"\r
-" \"samplerCube\" .emit TYPE_SPECIFIER_SAMPLERCUBE .or\n"\r
-" \"sampler1DShadow\" .emit TYPE_SPECIFIER_SAMPLER1DSHADOW .or\n"\r
-" \"sampler2DShadow\" .emit TYPE_SPECIFIER_SAMPLER2DSHADOW .or\n"\r
-" type_name .emit TYPE_SPECIFIER_TYPENAME;\n"\r
-"type_specifier_nospace\n"\r
-" struct_specifier .emit TYPE_SPECIFIER_STRUCT;\n"\r
-"struct_specifier\n"\r
-" \"struct\" .and struct_specifier_1 .and optional_space .and lbrace .error LBRACE_EXPECTED .and\n"\r
-" struct_declaration_list .and rbrace .emit FIELD_NONE;\n"\r
-"struct_specifier_1\n"\r
-" struct_specifier_2 .or .true .emit '\\0';\n"\r
-"struct_specifier_2\n"\r
-" space .and identifier;\n"\r
-"struct_declaration_list\n"\r
-" struct_declaration .and .loop struct_declaration .emit FIELD_NEXT;\n"\r
-"struct_declaration\n"\r
-" struct_declaration_nospace .or struct_declaration_space;\n"\r
-"struct_declaration_space\n"\r
-" type_specifier_space .and space .and struct_declarator_list .and semicolon .emit FIELD_NONE;\n"\r
-"struct_declaration_nospace\n"\r
-" type_specifier_nospace .and struct_declarator_list .and semicolon .emit FIELD_NONE;\n"\r
-"struct_declarator_list\n"\r
-" struct_declarator .and .loop struct_declarator_list_1 .emit FIELD_NEXT;\n"\r
-"struct_declarator_list_1\n"\r
-" comma .and struct_declarator;\n"\r
-"struct_declarator\n"\r
-" identifier .and struct_declarator_1;\n"\r
-"struct_declarator_1\n"\r
-" struct_declarator_2 .emit FIELD_ARRAY .or .true .emit FIELD_NONE;\n"\r
-"struct_declarator_2\n"\r
-" lbracket .and constant_expression .and rbracket;\n"\r
-"initializer\n"\r
-" assignment_expression .and .true .emit OP_END;\n"\r
-"declaration_statement\n"\r
-" declaration;\n"\r
-"statement\n"\r
-" compound_statement .or simple_statement;\n"\r
-"statement_space\n"\r
-" compound_statement .or statement_space_1;\n"\r
-"statement_space_1\n"\r
-" space .and simple_statement;\n"\r
-"simple_statement\n"\r
-" .if (parsing_builtin != 0) __asm_statement .emit OP_ASM .or\n"\r
-" selection_statement .or\n"\r
-" iteration_statement .or\n"\r
-" jump_statement .or\n"\r
-" expression_statement .emit OP_EXPRESSION .or\n"\r
-" declaration_statement .emit OP_DECLARE;\n"\r
-"compound_statement\n"\r
-" compound_statement_1 .emit OP_BLOCK_BEGIN_NEW_SCOPE .and .true .emit OP_END;\n"\r
-"compound_statement_1\n"\r
-" compound_statement_2 .or compound_statement_3;\n"\r
-"compound_statement_2\n"\r
-" lbrace .and rbrace;\n"\r
-"compound_statement_3\n"\r
-" lbrace .and statement_list .and rbrace;\n"\r
-"statement_no_new_scope\n"\r
-" compound_statement_no_new_scope .or simple_statement;\n"\r
-"compound_statement_no_new_scope\n"\r
-" compound_statement_no_new_scope_1 .emit OP_BLOCK_BEGIN_NO_NEW_SCOPE .and .true .emit OP_END;\n"\r
-"compound_statement_no_new_scope_1\n"\r
-" compound_statement_no_new_scope_2 .or compound_statement_no_new_scope_3;\n"\r
-"compound_statement_no_new_scope_2\n"\r
-" lbrace .and rbrace;\n"\r
-"compound_statement_no_new_scope_3\n"\r
-" lbrace .and statement_list .and rbrace;\n"\r
-"statement_list\n"\r
-" statement .and .loop statement;\n"\r
-"expression_statement\n"\r
-" expression_statement_1 .or expression_statement_2;\n"\r
-"expression_statement_1\n"\r
-" semicolon .emit OP_PUSH_VOID .emit OP_END;\n"\r
-"expression_statement_2\n"\r
-" expression .and semicolon .emit OP_END;\n"\r
-"selection_statement\n"\r
-" \"if\" .emit OP_IF .and lparen .error LPAREN_EXPECTED .and expression .and\n"\r
-" rparen .error RPAREN_EXPECTED .emit OP_END .and selection_rest_statement;\n"\r
-"selection_rest_statement\n"\r
-" statement .and selection_rest_statement_1;\n"\r
-"selection_rest_statement_1\n"\r
-" selection_rest_statement_2 .or .true .emit OP_EXPRESSION .emit OP_PUSH_VOID .emit OP_END;\n"\r
-"selection_rest_statement_2\n"\r
-" \"else\" .and optional_space .and statement;\n"\r
-"condition\n"\r
-" condition_1 .emit OP_DECLARE .emit DECLARATION_INIT_DECLARATOR_LIST .or\n"\r
-" condition_3 .emit OP_EXPRESSION;\n"\r
-"condition_1\n"\r
-" condition_1_nospace .or condition_1_space;\n"\r
-"condition_1_nospace\n"\r
-" fully_specified_type_nospace .and condition_2;\n"\r
-"condition_1_space\n"\r
-" fully_specified_type_space .and space .and condition_2;\n"\r
-"condition_2\n"\r
-" identifier .emit VARIABLE_IDENTIFIER .and equals .emit VARIABLE_INITIALIZER .and\n"\r
-" initializer .and .true .emit DECLARATOR_NONE;\n"\r
-"condition_3\n"\r
-" expression .and .true .emit OP_END;\n"\r
-"iteration_statement\n"\r
-" iteration_statement_1 .or iteration_statement_2 .or iteration_statement_3;\n"\r
-"iteration_statement_1\n"\r
-" \"while\" .emit OP_WHILE .and lparen .error LPAREN_EXPECTED .and condition .and\n"\r
-" rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\n"\r
-"iteration_statement_2\n"\r
-" \"do\" .emit OP_DO .and statement_space .and \"while\" .and lparen .error LPAREN_EXPECTED .and\n"\r
-" expression .and rparen .error RPAREN_EXPECTED .emit OP_END .and semicolon;\n"\r
-"iteration_statement_3\n"\r
-" \"for\" .emit OP_FOR .and lparen .error LPAREN_EXPECTED .and for_init_statement .and\n"\r
-" for_rest_statement .and rparen .error RPAREN_EXPECTED .and statement_no_new_scope;\n"\r
-"for_init_statement\n"\r
-" expression_statement .or declaration_statement;\n"\r
-"conditionopt\n"\r
-" condition .or\n"\r
-" .true .emit OP_EXPRESSION .emit OP_PUSH_BOOL .emit 2 .emit '1' .emit '\\0' .emit OP_END;\n"\r
-"for_rest_statement\n"\r
-" conditionopt .and semicolon .and for_rest_statement_1;\n"\r
-"for_rest_statement_1\n"\r
-" for_rest_statement_2 .or .true .emit OP_PUSH_VOID .emit OP_END;\n"\r
-"for_rest_statement_2\n"\r
-" expression .and .true .emit OP_END;\n"\r
-"jump_statement\n"\r
-" jump_statement_1 .or jump_statement_2 .or jump_statement_3 .or jump_statement_4 .or\n"\r
-" .if (shader_type == 1) jump_statement_5;\n"\r
-"jump_statement_1\n"\r
-" \"continue\" .and semicolon .emit OP_CONTINUE;\n"\r
-"jump_statement_2\n"\r
-" \"break\" .and semicolon .emit OP_BREAK;\n"\r
-"jump_statement_3\n"\r
-" \"return\" .emit OP_RETURN .and optional_space .and expression .and semicolon .emit OP_END;\n"\r
-"jump_statement_4\n"\r
-" \"return\" .emit OP_RETURN .and semicolon .emit OP_PUSH_VOID .emit OP_END;\n"\r
-"jump_statement_5\n"\r
-" \"discard\" .and semicolon .emit OP_DISCARD;\n"\r
-"__asm_statement\n"\r
-" \"__asm\" .and space .and identifier .and space .and asm_arguments .and semicolon .emit OP_END;\n"\r
-"asm_arguments\n"\r
-" variable_identifier .and .true .emit OP_END .and .loop asm_arguments_1;\n"\r
-"asm_arguments_1\n"\r
-" comma .and variable_identifier .and .true .emit OP_END;\n"\r
-"translation_unit\n"\r
-" optional_space .emit REVISION .and external_declaration .error INVALID_EXTERNAL_DECLARATION .and\n"\r
-" .loop external_declaration .and optional_space .and\n"\r
-" '\\0' .error INVALID_EXTERNAL_DECLARATION .emit EXTERNAL_NULL;\n"\r
-"external_declaration\n"\r
-" function_definition .emit EXTERNAL_FUNCTION_DEFINITION .or\n"\r
-" declaration .emit EXTERNAL_DECLARATION;\n"\r
-"function_definition\n"\r
-" function_prototype .and compound_statement_no_new_scope;\n"\r
-"digit_oct\n"\r
-" '0'-'7';\n"\r
-"digit_dec\n"\r
-" '0'-'9';\n"\r
-"digit_hex\n"\r
-" '0'-'9' .or 'A'-'F' .or 'a'-'f';\n"\r
-"id_character_first\n"\r
-" 'a'-'z' .or 'A'-'Z' .or '_';\n"\r
-"id_character_next\n"\r
-" id_character_first .or digit_dec;\n"\r
-"identifier\n"\r
-" id_character_first .emit * .and .loop id_character_next .emit * .and .true .emit '\\0';\n"\r
-"float\n"\r
-" float_1 .or float_2;\n"\r
-"float_1\n"\r
-" float_fractional_constant .and float_optional_exponent_part;\n"\r
-"float_2\n"\r
-" float_digit_sequence .and .true .emit '\\0' .and float_exponent_part;\n"\r
-"float_fractional_constant\n"\r
-" float_fractional_constant_1 .or float_fractional_constant_2 .or float_fractional_constant_3;\n"\r
-"float_fractional_constant_1\n"\r
-" float_digit_sequence .and '.' .and float_digit_sequence;\n"\r
-"float_fractional_constant_2\n"\r
-" float_digit_sequence .and '.' .and .true .emit '\\0';\n"\r
-"float_fractional_constant_3\n"\r
-" '.' .emit '\\0' .and float_digit_sequence;\n"\r
-"float_optional_exponent_part\n"\r
-" float_exponent_part .or .true .emit '\\0';\n"\r
-"float_digit_sequence\n"\r
-" digit_dec .emit * .and .loop digit_dec .emit * .and .true .emit '\\0';\n"\r
-"float_exponent_part\n"\r
-" float_exponent_part_1 .or float_exponent_part_2;\n"\r
-"float_exponent_part_1\n"\r
-" 'e' .and float_optional_sign .and float_digit_sequence;\n"\r
-"float_exponent_part_2\n"\r
-" 'E' .and float_optional_sign .and float_digit_sequence;\n"\r
-"float_optional_sign\n"\r
-" float_sign .or .true;\n"\r
-"float_sign\n"\r
-" '+' .or '-' .emit '-';\n"\r
-"integer\n"\r
-" integer_hex .or integer_oct .or integer_dec;\n"\r
-"integer_hex\n"\r
-" '0' .and integer_hex_1 .emit 0x10 .and digit_hex .emit * .and .loop digit_hex .emit * .and\n"\r
-" .true .emit '\\0';\n"\r
-"integer_hex_1\n"\r
-" 'x' .or 'X';\n"\r
-"integer_oct\n"\r
-" '0' .emit 8 .emit * .and .loop digit_oct .emit * .and .true .emit '\\0';\n"\r
-"integer_dec\n"\r
-" digit_dec .emit 10 .emit * .and .loop digit_dec .emit * .and .true .emit '\\0';\n"\r
-"boolean\n"\r
-" \"true\" .emit 2 .emit '1' .emit '\\0' .or\n"\r
-" \"false\" .emit 2 .emit '0' .emit '\\0';\n"\r
-"type_name\n"\r
-" identifier;\n"\r
-"field_selection\n"\r
-" identifier;\n"\r
-"floatconstant\n"\r
-" float .emit OP_PUSH_FLOAT;\n"\r
-"intconstant\n"\r
-" integer .emit OP_PUSH_INT;\n"\r
-"boolconstant\n"\r
-" boolean .emit OP_PUSH_BOOL;\n"\r
-"optional_space\n"\r
-" .loop single_space;\n"\r
-"space\n"\r
-" single_space .and .loop single_space;\n"\r
-"single_space\n"\r
-" white_char .or c_style_comment_block .or cpp_style_comment_block;\n"\r
-"white_char\n"\r
-" ' ' .or '\\t' .or new_line .or '\\v' .or '\\f';\n"\r
-"new_line\n"\r
-" cr_lf .or lf_cr .or '\\n' .or '\\r';\n"\r
-"cr_lf\n"\r
-" '\\r' .and '\\n';\n"\r
-"lf_cr\n"\r
-" '\\n' .and '\\r';\n"\r
-"c_style_comment_block\n"\r
-" '/' .and '*' .and c_style_comment_rest;\n"\r
-"c_style_comment_rest\n"\r
-" .loop c_style_comment_char_no_star .and c_style_comment_rest_1;\n"\r
-"c_style_comment_rest_1\n"\r
-" c_style_comment_end .or c_style_comment_rest_2;\n"\r
-"c_style_comment_rest_2\n"\r
-" '*' .and c_style_comment_rest;\n"\r
-"c_style_comment_char_no_star\n"\r
-" '\\x2B'-'\\xFF' .or '\\x01'-'\\x29';\n"\r
-"c_style_comment_end\n"\r
-" '*' .and '/';\n"\r
-"cpp_style_comment_block\n"\r
-" '/' .and '/' .and cpp_style_comment_block_1;\n"\r
-"cpp_style_comment_block_1\n"\r
-" cpp_style_comment_block_2 .or cpp_style_comment_block_3;\n"\r
-"cpp_style_comment_block_2\n"\r
-" .loop cpp_style_comment_char .and new_line;\n"\r
-"cpp_style_comment_block_3\n"\r
-" .loop cpp_style_comment_char;\n"\r
-"cpp_style_comment_char\n"\r
-" '\\x0E'-'\\xFF' .or '\\x01'-'\\x09' .or '\\x0B'-'\\x0C';\n"\r
-"ampersandampersand\n"\r
-" optional_space .and '&' .and '&' .and optional_space;\n"\r
-"barbar\n"\r
-" optional_space .and '|' .and '|' .and optional_space;\n"\r
-"bang\n"\r
-" optional_space .and '!' .and optional_space;\n"\r
-"bangequals\n"\r
-" optional_space .and '!' .and '=' .and optional_space;\n"\r
-"caretcaret\n"\r
-" optional_space .and '^' .and '^' .and optional_space;\n"\r
-"colon\n"\r
-" optional_space .and ':' .and optional_space;\n"\r
-"comma\n"\r
-" optional_space .and ',' .and optional_space;\n"\r
-"dot\n"\r
-" optional_space .and '.' .and optional_space;\n"\r
-"equals\n"\r
-" optional_space .and '=' .and optional_space;\n"\r
-"equalsequals\n"\r
-" optional_space .and '=' .and '=' .and optional_space;\n"\r
-"greater\n"\r
-" optional_space .and '>' .and optional_space;\n"\r
-"greaterequals\n"\r
-" optional_space .and '>' .and '=' .and optional_space;\n"\r
-"lbrace\n"\r
-" optional_space .and '{' .and optional_space;\n"\r
-"lbracket\n"\r
-" optional_space .and '[' .and optional_space;\n"\r
-"less\n"\r
-" optional_space .and '<' .and optional_space;\n"\r
-"lessequals\n"\r
-" optional_space .and '<' .and '=' .and optional_space;\n"\r
-"lparen\n"\r
-" optional_space .and '(' .and optional_space;\n"\r
-"minus\n"\r
-" optional_space .and '-' .and optional_space;\n"\r
-"minusequals\n"\r
-" optional_space .and '-' .and '=' .and optional_space;\n"\r
-"minusminus\n"\r
-" optional_space .and '-' .and '-' .and optional_space;\n"\r
-"plus\n"\r
-" optional_space .and '+' .and optional_space;\n"\r
-"plusequals\n"\r
-" optional_space .and '+' .and '=' .and optional_space;\n"\r
-"plusplus\n"\r
-" optional_space .and '+' .and '+' .and optional_space;\n"\r
-"question\n"\r
-" optional_space .and '?' .and optional_space;\n"\r
-"rbrace\n"\r
-" optional_space .and '}' .and optional_space;\n"\r
-"rbracket\n"\r
-" optional_space .and ']' .and optional_space;\n"\r
-"rparen\n"\r
-" optional_space .and ')' .and optional_space;\n"\r
-"semicolon\n"\r
-" optional_space .and ';' .and optional_space;\n"\r
-"slash\n"\r
-" optional_space .and '/' .and optional_space;\n"\r
-"slashequals\n"\r
-" optional_space .and '/' .and '=' .and optional_space;\n"\r
-"star\n"\r
-" optional_space .and '*' .and optional_space;\n"\r
-"starequals\n"\r
-" optional_space .and '*' .and '=' .and optional_space;\n"\r
-".string string_lexer;\n"\r
-"string_lexer\n"\r
-" lex_first_identifier_character .and .loop lex_next_identifier_character;\n"\r
-"lex_first_identifier_character\n"\r
-" 'a'-'z' .or 'A'-'Z' .or '_';\n"\r
-"lex_next_identifier_character\n"\r
-" 'a'-'z' .or 'A'-'Z' .or '0'-'9' .or '_';\n"\r
-"err_token\n"\r
-" '~' .or '`' .or '!' .or '@' .or '#' .or '$' .or '%' .or '^' .or '&' .or '*' .or '(' .or ')' .or\n"\r
-" '-' .or '+' .or '=' .or '|' .or '\\\\' .or '[' .or ']' .or '{' .or '}' .or ':' .or ';' .or '\"' .or\n"\r
-" '\\'' .or '<' .or ',' .or '>' .or '.' .or '/' .or '?' .or err_identifier;\n"\r
-"err_identifier\n"\r
-" id_character_first .and .loop id_character_next;\n"\r
-""
\ No newline at end of file
+++ /dev/null
-
-//
-// 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.10, rev. 59
-//
-// 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\92t 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_MaxTextureCoords
-varying float gl_FogFragCoord;
-
-//
-// For gl_FogFragCoord, the value written will be used as the \93c\94 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 \93c\94, 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 an integral constant
-// expressions, or this array must be re-declared by the shader with a size. The size can be
-// at most gl_MaxTextureCoords. 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:
-//
-// \95 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.
-//
-// \95 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.
-//
-// \95 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\92s
-// 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;
-}
-
-//
-// 8.7 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 that represents a depth texture with depth
-// comparisons turned on, then results are undefined. If a shadow texture call is made to a sampler
-// that represents a depth texture with depth comparisions turned off, the results are undefined.
-// If a shadow texture call is made to a sampler that does not represent a depth texture, then
-// results are 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 \93Lod\94 are allowed only in a vertex shader. For the \93Lod\94 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 (\93Proj\94) 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 \931D\94 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);
-}
-
projects / mesa.git / commitdiff