diff options
Diffstat (limited to 'nx-X11/extras/Mesa/src/mesa/shader/slang/library')
8 files changed, 0 insertions, 5363 deletions
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/gc_to_bin.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/gc_to_bin.c deleted file mode 100755 index 4bd211442..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/gc_to_bin.c +++ /dev/null @@ -1,79 +0,0 @@ -#include "../../grammar/grammar_crt.h"
-#include "../../grammar/grammar_crt.c"
-#include <stdio.h>
-
-static const char *slang_shader_syn =
-#include "slang_shader_syn.h"
-;
-
-static void gc_to_bin (grammar id, const char *in, const char *out)
-{
- FILE *f;
- byte *source, *prod;
- unsigned int size, i, line = 0;
-
- f = fopen (in, "r");
- if (f == NULL)
- return;
- fseek (f, 0, SEEK_END);
- size = ftell (f);
- fseek (f, 0, SEEK_SET);
- source = (byte *) grammar_alloc_malloc (size + 1);
- source[fread (source, 1, size, f)] = '\0';
- fclose (f);
-
- if (!grammar_fast_check (id, source, &prod, &size, 65536))
- {
- grammar_alloc_free (source);
- return;
- }
-
- f = fopen (out, "w");
- for (i = 0; i < size; i++)
- {
- unsigned int a;
- if (prod[i] < 10)
- a = 1;
- else if (prod[i] < 100)
- a = 2;
- else
- a = 3;
- if (i < size - 1)
- a++;
- if (line + a > 100)
- {
- fprintf (f, "\n");
- line = 0;
- }
- line += a;
- fprintf (f, "%d", prod[i]);
- if (i < size - 1)
- fprintf (f, ",");
- }
- fclose (f);
- grammar_alloc_free (prod);
-}
-
-int main ()
-{
- grammar id;
-
- id = grammar_load_from_text ((const byte *) slang_shader_syn);
- if (id == 0)
- return 1;
-
- grammar_set_reg8 (id, (const byte *) "parsing_builtin", 1);
-
- grammar_set_reg8 (id, (const byte *) "shader_type", 1);
- gc_to_bin (id, "slang_core.gc", "slang_core_gc_bin.h");
- gc_to_bin (id, "slang_common_builtin.gc", "slang_common_builtin_gc_bin.h");
- gc_to_bin (id, "slang_fragment_builtin.gc", "slang_fragment_builtin_gc_bin.h");
-
- grammar_set_reg8 (id, (const byte *) "shader_type", 2);
- gc_to_bin (id, "slang_vertex_builtin.gc", "slang_vertex_builtin_gc_bin.h");
-
- grammar_destroy (id);
-
- return 0;
-}
-
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/gc_to_string.py b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/gc_to_string.py deleted file mode 100644 index a9d399fc1..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/gc_to_string.py +++ /dev/null @@ -1,55 +0,0 @@ -#!/usr/bin/env python
-
-# Mesa 3-D graphics library
-# Version: 6.3
-#
-# Copyright (C) 2005 Brian Paul All Rights Reserved.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-# author: Michal Krol
-
-# converts slang source file into a C header containing one big string
-# comments and trailing whitespaces are stripped
-# C style comments are not supported, only C++ style ones are
-# empty lines are kept to maintain line numbers correlation
-# escape characters are not handled except for newlines
-
-# example:
-# -- source file
-# // some comment
-#
-# attribute vec4 myPosition; // my vertex data
-# -- output file
-# "\n"
-# "\n"
-# "attribute vec4 myPosition;\n"
-
-# usage: gc_to_string.py filename.gc > filename_gc.h
-
-import sys
-
-f = open (sys.argv[1], 'r')
-s = f.readline ()
-while s != '':
- s = s[0:s.find ('//')].rstrip ()
- # output empty lines, too, so line numbers can be tracked
- print '\"' + s + '\\n\"'
- s = f.readline ()
-f.close ()
-
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_common_builtin.gc b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_common_builtin.gc deleted file mode 100755 index 0b3ed0e88..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_common_builtin.gc +++ /dev/null @@ -1,1410 +0,0 @@ - -// -// 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: -// -// * They expose some necessary hardware functionality in a convenient way such as accessing -// a texture map. There is no way in the language for these functions to be emulated by a shader. -// -// * They represent a trivial operation (clamp, mix, etc.) that is very simple for the user -// to write, but they are very common and may have direct hardware support. It is a very hard -// problem for the compiler to map expressions to complex assembler instructions. -// -// * They represent an operation graphics hardware is likely to accelerate at some point. The -// trigonometry functions fall into this category. -// -// Many of the functions are similar to the same named ones in common C libraries, but they support -// vector input as well as the more traditional scalar input. -// -// Applications should be encouraged to use the built-in functions rather than do the equivalent -// computations in their own shader code since the built-in functions are assumed to be optimal -// (e.g., perhaps supported directly in hardware). -// -// User code can replace built-in functions with their own if they choose, by simply re-declaring -// and defining the same name and argument list. -// - -// -// 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 -// [–PI/2, PI/2]. Results are undefined if |x| > 1. -// -// XXX -float asin (float x) { - return 0.0; -} -vec2 asin (vec2 x) { - return vec2 (asin (x.x), asin (x.y)); -} -vec3 asin (vec3 x) { - return vec3 (asin (x.x), asin (x.y), asin (x.z)); -} -vec4 asin (vec4 x) { - return vec4 (asin (x.x), asin (x.y), asin (x.z), asin (x.w)); -} - -// -// Arc cosine. Returns an angle whose cosine is x. The range of values returned by this function is -// [0, PI]. Results are undefined if |x| > 1. -// -// XXX -float acos (float x) { - return 0.0; -} -vec2 acos (vec2 x) { - return vec2 (acos (x.x), acos (x.y)); -} -vec3 acos (vec3 x) { - return vec3 (acos (x.x), acos (x.y), acos (x.z)); -} -vec4 acos (vec4 x) { - return vec4 (acos (x.x), acos (x.y), acos (x.z), acos (x.w)); -} - -// -// Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine -// what quadrant the angle is in. The range of values returned by this function is [–PI, PI]. -// Results are undefined if x and y are both 0. -// -// XXX -float atan (float x, float y) { - return 0.0; -} -vec2 atan (vec2 x, vec2 y) { - return vec2 (atan (x.x, y.x), atan (x.y, y.y)); -} -vec3 atan (vec3 x, vec3 y) { - return vec3 (atan (x.x, y.x), atan (x.y, y.y), atan (x.z, y.z)); -} -vec4 atan (vec4 x, vec4 y) { - return vec4 (atan (x.x, y.x), atan (x.y, y.y), atan (x.z, y.z), atan (x.w, y.w)); -} - -// -// Arc tangent. Returns an angle whose tangent is y_over_x. The range of values returned by this -// function is [–PI/2, PI/2]. -// -// XXX -float atan (float y_over_x) { - return 0.0; -} -vec2 atan (vec2 y_over_x) { - return vec2 (atan (y_over_x.x), atan (y_over_x.y)); -} -vec3 atan (vec3 y_over_x) { - return vec3 (atan (y_over_x.x), atan (y_over_x.y), atan (y_over_x.z)); -} -vec4 atan (vec4 y_over_x) { - return vec4 (atan (y_over_x.x), atan (y_over_x.y), atan (y_over_x.z), atan (y_over_x.w)); -} - -// -// 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 –x -// - -float abs (float x) { - return x >= 0.0 ? x : -x; -} -vec2 abs (vec2 x) { - return vec2 (abs (x.x), abs (x.y)); -} -vec3 abs (vec3 x) { - return vec3 (abs (x.x), abs (x.y), abs (x.z)); -} -vec4 abs (vec4 x) { - return vec4 (abs (x.x), abs (x.y), abs (x.z), abs (x.w)); -} - -// -// Returns 1.0 if x > 0, 0.0 if x = 0, or –1.0 if x < 0 -// - -float sign (float x) { - return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : 0.0; -} -vec2 sign (vec2 x) { - return vec2 (sign (x.x), sign (x.y)); -} -vec3 sign (vec3 x) { - return vec3 (sign (x.x), sign (x.y), sign (x.z)); -} -vec4 sign (vec4 x) { - return vec4 (sign (x.x), sign (x.y), sign (x.z), sign (x.w)); -} - -// -// Returns a value equal to the nearest integer that is less than or equal to x -// -// XXX -float floor (float x) { - return 0.0; -} -vec2 floor (vec2 x) { - return vec2 (floor (x.x), floor (x.y)); -} -vec3 floor (vec3 x) { - return vec3 (floor (x.x), floor (x.y), floor (x.z)); -} -vec4 floor (vec4 x) { - return vec4 (floor (x.x), floor (x.y), floor (x.z), floor (x.w)); -} - -// -// Returns a value equal to the nearest integer that is greater than or equal to x -// -// XXX -float ceil (float x) { - return 0.0; -} -vec2 ceil (vec2 x) { - return vec2 (ceil (x.x), ceil (x.y)); -} -vec3 ceil (vec3 x) { - return vec3 (ceil (x.x), ceil (x.y), ceil (x.z)); -} -vec4 ceil (vec4 x) { - return vec4 (ceil (x.x), ceil (x.y), ceil (x.z), ceil (x.w)); -} - -// -// Returns x – floor (x) -// - -float fract (float x) { - return x - floor (x); -} -vec2 fract (vec2 x) { - return vec2 (fract (x.x), fract (x.y)); -} -vec3 fract (vec3 x) { - return vec3 (fract (x.x), fract (x.y), fract (x.z)); -} -vec4 fract (vec4 x) { - return vec4 (fract (x.x), fract (x.y), fract (x.z), fract (x.w)); -} - -// -// Modulus. Returns x – y * floor (x/y) -// - -float mod (float x, float y) { - return x - y * floor (x / y); -} -vec2 mod (vec2 x, float y) { - return vec2 (mod (x.x, y), mod (x.y, y)); -} -vec3 mod (vec3 x, float y) { - return vec3 (mod (x.x, y), mod (x.y, y), mod (x.z, y)); -} -vec4 mod (vec4 x, float y) { - return vec4 (mod (x.x, y), mod (x.y, y), mod (x.z, y), mod (x.w, y)); -} -vec2 mod (vec2 x, vec2 y) { - return vec2 (mod (x.x, y.x), mod (x.y, y.y)); -} -vec3 mod (vec3 x, vec3 y) { - return vec3 (mod (x.x, y.x), mod (x.y, y.y), mod (x.z, y.z)); -} -vec4 mod (vec4 x, vec4 y) { - return vec4 (mod (x.x, y.x), mod (x.y, y.y), mod (x.z, y.z), mod (x.w, y.w)); -} - -// -// Returns y if y < x, otherwise it returns x -// - -float min (float x, float y) { - return y < x ? y : x; -} -vec2 min (vec2 x, float y) { - return vec2 (min (x.x, y), min (x.y, y)); -} -vec3 min (vec3 x, float y) { - return vec3 (min (x.x, y), min (x.y, y), min (x.z, y)); -} -vec4 min (vec4 x, float y) { - return vec4 (min (x.x, y), min (x.y, y), min (x.z, y), min (x.w, y)); -} -vec2 min (vec2 x, vec2 y) { - return vec2 (min (x.x, y.x), min (x.y, y.y)); -} -vec3 min (vec3 x, vec3 y) { - return vec3 (min (x.x, y.x), min (x.y, y.y), min (x.z, y.z)); -} -vec4 min (vec4 x, vec4 y) { - return vec4 (min (x.x, y.x), min (x.y, y.y), min (x.z, y.z), min (x.w, y.w)); -} - -// -// Returns y if x < y, otherwise it returns x -// - -float max (float x, float y) { - return min (y, x); -} -vec2 max (vec2 x, float y) { - return vec2 (max (x.x, y), max (x.y, y)); -} -vec3 max (vec3 x, float y) { - return vec3 (max (x.x, y), max (x.y, y), max (x.z, y)); -} -vec4 max (vec4 x, float y) { - return vec4 (max (x.x, y), max (x.y, y), max (x.z, y), max (x.w, y)); -} -vec2 max (vec2 x, vec2 y) { - return vec2 (max (x.x, y.x), max (x.y, y.y)); -} -vec3 max (vec3 x, vec3 y) { - return vec3 (max (x.x, y.x), max (x.y, y.y), max (x.z, y.z)); -} -vec4 max (vec4 x, vec4 y) { - return vec4 (max (x.x, y.x), max (x.y, y.y), max (x.z, y.z), max (x.w, y.w)); -} - -// -// Returns min (max (x, minVal), maxVal) -// -// Note that colors and depths written by fragment shaders will be clamped by the implementation -// after the fragment shader runs. -// - -float clamp (float x, float minVal, float maxVal) { - return min (max (x, minVal), maxVal); -} -vec2 clamp (vec2 x, float minVal, float maxVal) { - return vec2 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal)); -} -vec3 clamp (vec3 x, float minVal, float maxVal) { - return vec3 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal), - clamp (x.z, minVal, maxVal)); -} -vec4 clamp (vec4 x, float minVal, float maxVal) { - return vec4 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal), - clamp (x.z, minVal, maxVal), clamp (x.w, minVal, maxVal)); -} -vec2 clamp (vec2 x, vec2 minVal, vec2 maxVal) { - return vec2 (clamp (x.x, minVal.x, maxVal.x), clamp (x.y, minVal.y, maxVal.y)); -} -vec3 clamp (vec3 x, vec3 minVal, vec3 maxVal) { - return vec3 (clamp (x.x, minVal.x, maxVal.x), clamp (x.y, minVal.y, maxVal.y), - clamp (x.z, minVal.z, maxVal.z)); -} -vec4 clamp (vec4 x, vec4 minVal, vec4 maxVal) { - return vec4 (clamp (x.x, minVal.x, maxVal.y), clamp (x.y, minVal.y, maxVal.y), - clamp (x.z, minVal.z, maxVal.z), clamp (x.w, minVal.w, maxVal.w)); -} - -// -// Returns x * (1 – a) + y * a, i.e., the linear blend of x and y -// - -float mix (float x, float y, float a) { - return x * (1.0 - a) + y * a; -} -vec2 mix (vec2 x, vec2 y, float a) { - return vec2 (mix (x.x, y.x, a), mix (x.y, y.y, a)); -} -vec3 mix (vec3 x, vec3 y, float a) { - return vec3 (mix (x.x, y.x, a), mix (x.y, y.y, a), mix (x.z, y.z, a)); -} -vec4 mix (vec4 x, vec4 y, float a) { - return vec4 (mix (x.x, y.x, a), mix (x.y, y.y, a), mix (x.z, y.z, a), mix (x.w, y.w, a)); -} -vec2 mix (vec2 x, vec2 y, vec2 a) { - return vec2 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y)); -} -vec3 mix (vec3 x, vec3 y, vec3 a) { - return vec3 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y), mix (x.z, y.z, a.z)); -} -vec4 mix (vec4 x, vec4 y, vec4 a) { - return vec4 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y), mix (x.z, y.z, a.z), - mix (x.w, y.w, a.w)); -} - -// -// Returns 0.0 if x < edge, otherwise it returns 1.0 -// - -float step (float edge, float x) { - return x < edge ? 0.0 : 1.0; -} -vec2 step (float edge, vec2 x) { - return vec2 (step (edge, x.x), step (edge, x.y)); -} -vec3 step (float edge, vec3 x) { - return vec3 (step (edge, x.x), step (edge, x.y), step (edge, x.z)); -} -vec4 step (float edge, vec4 x) { - return vec4 (step (edge, x.x), step (edge, x.y), step (edge, x.z), step (edge, x.w)); -} -vec2 step (vec2 edge, vec2 x) { - return vec2 (step (edge.x, x.x), step (edge.y, x.y)); -} -vec3 step (vec3 edge, vec3 x) { - return vec3 (step (edge.x, x.x), step (edge.y, x.y), step (edge.z, x.z)); -} -vec4 step (vec4 edge, vec4 x) { - return vec4 (step (edge.x, x.x), step (edge.y, x.y), step (edge.z, x.z), step (edge.w, x.w)); -} - -// -// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation -// between 0 and 1 when edge0 < x < edge1. This is useful in cases where you would want a threshold -// function with a smooth transition. This is equivalent to: -// <type> t; -// t = clamp ((x – edge0) / (edge1 – edge0), 0, 1); -// return t * t * (3 – 2 * t); -// - -float smoothstep (float edge0, float edge1, float x) { - const float t = clamp ((x - edge0) / (edge1 - edge0), 0.0, 1.0); - return t * t * (3.0 - 2.0 * t); -} -vec2 smoothstep (float edge0, float edge1, vec2 x) { - return vec2 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y)); -} -vec3 smoothstep (float edge0, float edge1, vec3 x) { - return vec3 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y), - smoothstep (edge0, edge1, x.z)); -} -vec4 smoothstep (float edge0, float edge1, vec4 x) { - return vec4 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y), - smoothstep (edge0, edge1, x.z), smoothstep (edge0, edge1, x.w)); -} -vec2 smoothstep (vec2 edge0, vec2 edge1, vec2 x) { - return vec2 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y)); -} -vec3 smoothstep (vec3 edge0, vec3 edge1, vec3 x) { - return vec3 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y), - smoothstep (edge0.z, edge1.z, x.z)); -} -vec4 smoothstep (vec4 edge0, vec4 edge1, vec4 x) { - return vec4 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y), - smoothstep (edge0.z, edge1.z, x.z), smoothstep (edge0.w, edge1.w, x.w)); -} - -// -// 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 – p1) -// - -float distance (float x, float y) { - return length (x - y); -} -float distance (vec2 x, vec2 y) { - return length (x - y); -} -float distance (vec3 x, vec3 y) { - return length (x - y); -} -float distance (vec4 x, vec4 y) { - return length (x - y); -} - -// -// Returns the cross product of x and y, i.e. -// result.0 = x[1] * y[2] - y[1] * x[2] -// result.1 = x[2] * y[0] - y[2] * x[0] -// result.2 = x[0] * y[1] - y[0] * x[1] -// - -vec3 cross (vec3 x, vec3 y) { - return vec3 (x.y * y.z - y.y * x.z, x.z * y.x - y.z * x.x, x.x * y.y - y.x * x.y); -} - -// -// Returns a vector in the same direction as x but with a length of 1. -// - -float normalize (float x) { - return 1.0; -} -vec2 normalize (vec2 x) { - return x / length (x); -} -vec3 normalize (vec3 x) { - return x / length (x); -} -vec4 normalize (vec4 x) { - return x / length (x); -} - -// -// If dot (Nref, I) < 0 return N otherwise return –N -// - -float faceforward (float N, float I, float Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} -vec2 faceforward (vec2 N, vec2 I, vec2 Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} -vec3 faceforward (vec3 N, vec3 I, vec3 Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} -vec4 faceforward (vec4 N, vec4 I, vec4 Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} - -// -// For the incident vector I and surface orientation N, returns the reflection direction: -// result = I - 2 * dot (N, I) * N -// N 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 "Lod" are allowed only in a vertex shader. For the "Lod" functions, -// lod is directly used as the level of detail. -// - -// -// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate coord.s is divided by -// the last component of coord. -// -// XXX -vec4 texture1D (sampler1D sampler, float coord) { - return vec4 (0.0); -} -vec4 texture1DProj (sampler1D sampler, vec2 coord) { - return texture1D (sampler, coord.s / coord.t); -} -vec4 texture1DProj (sampler1D sampler, vec4 coord) { - return texture1D (sampler, coord.s / coord.q); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate (coord.s, coord.t) is -// divided by the last component of coord. The third component of coord is ignored for the vec4 -// coord variant. -// -// XXX -vec4 texture2D (sampler2D sampler, vec2 coord) { - return vec4 (0.0); -} -vec4 texture2DProj (sampler2D sampler, vec3 coord) { - return texture2D (sampler, vec2 (coord.s / coord.p, coord.t / coord.p)); -} -vec4 texture2DProj (sampler2D sampler, vec4 coord) { - return texture2D (sampler, vec2 (coord.s / coord.q, coord.t / coord.q)); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate is divided by coord.q. -// -// XXX -vec4 texture3D (sampler3D sampler, vec3 coord) { - return vec4 (0.0); -} -vec4 texture3DProj (sampler3D sampler, vec4 coord) { - return texture3D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q)); -} - -// -// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound -// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture -// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification. -// -// XXX -vec4 textureCube (samplerCube sampler, vec3 coord) { - return vec4 (0.0); -} - -// -// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound -// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd -// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a -// depth texture, or results are undefined. For the projective ("Proj") version of each built-in, -// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The -// second component of coord is ignored for the "1D" variants. -// -// XXX -vec4 shadow1D (sampler1DShadow sampler, vec3 coord) { - return vec4 (0.0); -} -// XXX -vec4 shadow2D (sampler2DShadow sampler, vec3 coord) { - return vec4 (0.0); -} -vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord) { - return shadow1D (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q)); -} -vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord) { - return shadow2D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q)); -} - -// -// 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. -// * The return value(s) have an overall average of 0.0 -// * They are repeatable, in that a particular input value will always produce the same return value -// * They are statistically invariant under rotation (i.e., no matter how the domain is rotated, it -// has the same statistical character) -// * They have a statistical invariance under translation (i.e., no matter how the domain is -// translated, it has the same statistical character) -// * They typically give different results under translation. -// - 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); -} - diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_core.gc b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_core.gc deleted file mode 100755 index d1d2cb10f..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_core.gc +++ /dev/null @@ -1,1565 +0,0 @@ -
-//
-// 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 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.
-//
-
-int __constructor (const float _f) {
- int _i;
- __asm float_to_int _i, _f;
- return _i;
-}
-
-bool __constructor (const int _i) {
- return _i != 0;
-}
-
-bool __constructor (const float _f) {
- return _f != 0.0;
-}
-
-int __constructor (const bool _b) {
- return _b ? 1 : 0;
-}
-
-float __constructor (const bool _b) {
- return _b ? 1.0 : 0.0;
-}
-
-float __constructor (const int _i) {
- float _f;
- __asm int_to_float _f, _i;
- return _f;
-}
-
-bool __constructor (const bool _b) {
- return _b;
-}
-
-int __constructor (const int _i) {
- return _i;
-}
-
-float __constructor (const float _f) {
- return _f;
-}
-
-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);
-}
-
-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
- );
-}
-
-//void __operator = (out float a, const float b) {
-// __asm float_copy a, b;
-//}
-//
-//void __operator = (out int a, const int b) {
-// __asm int_copy a, b;
-//}
-//
-//void __operator = (out bool a, const bool b) {
-// __asm bool_copy a, b;
-//}
-//
-//void __operator = (out vec2 v, const vec2 u) {
-// v.x = u.x, v.y = u.y;
-//}
-//
-//void __operator = (out vec3 v, const vec3 u) {
-// v.x = u.x, v.y = u.y, v.z = u.z;
-//}
-//
-//void __operator = (out vec4 v, const vec4 u) {
-// v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
-//}
-//
-//void __operator = (out ivec2 v, const ivec2 u) {
-// v.x = u.x, v.y = u.y;
-//}
-//
-//void __operator = (out ivec3 v, const ivec3 u) {
-// v.x = u.x, v.y = u.y, v.z = u.z;
-//}
-//
-//void __operator = (out ivec4 v, const ivec4 u) {
-// v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
-//}
-//
-//void __operator = (out bvec2 v, const bvec2 u) {
-// v.x = u.x, v.y = u.y;
-//}
-//
-//void __operator = (out bvec3 v, const bvec3 u) {
-// v.x = u.x, v.y = u.y, v.z = u.z;
-//}
-//
-//void __operator = (out bvec4 v, const bvec4 u) {
-// v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;
-//}
-//
-//void __operator = (out mat2 m, const mat2 n) {
-// m[0] = n[0], m[1] = n[1];
-//}
-//
-//void __operator = (out mat3 m, const mat3 n) {
-// m[0] = n[0], m[1] = n[1], m[2] = n[2];
-//}
-//
-//void __operator = (out mat4 m, const mat4 n) {
-// m[0] = n[0], m[1] = n[1], m[2] = n[2], m[3] = n[3];
-//}
-
-void __operator += (inout float a, const float b) {
- __asm float_add a, a, b;
-}
-
-float __operator - (const float a) {
- float c;
- __asm float_negate c, a;
- return c;
-}
-
-void __operator -= (inout float a, const float b) {
- a += -b;
-}
-
-void __operator *= (inout float a, const float b) {
- __asm float_multiply a, a, b;
-}
-
-void __operator /= (inout float a, const float b) {
- __asm float_divide a, a, b;
-}
-
-float __operator + (const float a, const float b) {
- float c;
- c = a;
- return c += b;
-}
-
-void __operator += (inout int a, const int b) {
- a = int (float (a) + float (b));
-}
-
-int __operator - (const int a) {
- return int (-float (a));
-}
-
-void __operator -= (inout int a, const int b) {
- a += -b;
-}
-
-float __operator * (const float a, const float b) {
- float c;
- c = a;
- return c *= b;
-}
-
-void __operator *= (inout int a, const int b) {
- a = int (float (a) * float (b));
-}
-
-float __operator / (const float a, const float b) {
- float c;
- c = a;
- return c /= b;
-}
-
-void __operator /= (inout int a, const int b) {
- a = int (float (a) / float (b));
-}
-
-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 m, const mat2 n) {
- m[0] -= n[0], m[1] -= n[1];
-}
-
-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
- );
-}
-
-mat2 __operator * (const mat2 m, const mat2 n) {
- return mat2 (m * n[0], m * 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];
-}
-
-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
- );
-}
-
-mat3 __operator * (const mat3 m, const mat3 n) {
- return mat3 (m * n[0], m * n[1], m * 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];
-}
-
-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
- );
-}
-
-mat4 __operator * (const mat4 m, const mat4 n) {
- return mat4 (m * n[0], m * n[1], m * n[2], m * 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];
-}
-
-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;
-}
-
-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
- );
-}
-
-void __operator *= (inout vec2 v, const mat2 m) {
- v = v * m;
-}
-
-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
- );
-}
-
-void __operator *= (inout vec3 v, const mat3 m) {
- v = v * m;
-}
-
-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
- );
-}
-
-void __operator *= (inout vec4 v, const mat4 m) {
- v = v * m;
-}
-
-float __operator - (const float a, const float b) {
- return a + -b;
-}
-
-int __operator + (const int a, const int b) {
- int c;
- c = a;
- return c += b;
-}
-
-int __operator - (const int a, const int b) {
- return a + -b;
-}
-
-int __operator * (const int a, const int b) {
- int c;
- return (c = a) *= b;
-}
-
-int __operator / (const int a, const int b) {
- int c;
- return (c = a) /= b;
-}
-
-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]);
-}
-
-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);
-}
-
-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);
-}
-
-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);
-}
-
-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]);
-}
-
-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]);
-}
-
-//
-// NOTE: postfix increment and decrement operators take additional dummy int parameter to
-// distinguish their prototypes from prefix ones.
-//
-
-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) {
- float c;
- c = a;
- --a;
- return c;
-}
-
-int __operator -- (inout int a, const int) {
- int c;
- 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) {
- float c;
- c = a;
- ++a;
- return c;
-}
-
-int __operator ++ (inout int a, const int) {
- int c;
- 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]++);
-}
-
-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) {
- return float (a) < float (b);
-}
-
-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;
-}
-
-//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) {
-// return float (a) == float (b);
-//}
-//
-//bool __operator == (const bool a, const bool b) {
-// return float (a) == float (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];
-//}
-//
-//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];
-//}
-
-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;
-// }
-//
-
-bool __operator ! (const bool a) {
- return a == false;
-}
-
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_fragment_builtin.gc b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_fragment_builtin.gc deleted file mode 100755 index b4c5aa3ec..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_fragment_builtin.gc +++ /dev/null @@ -1,366 +0,0 @@ - -// -// 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's depth value. If a shader statically assigns -// a value to gl_FragDepth, and there is an execution path through the shader that does not set -// gl_FragDepth, then the value of the fragment's depth may be undefined for 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's depth if a shader contained no writes to gl_FragDepth. This is useful for -// invariance if a shader conditionally computes gl_FragDepth but otherwise wants the fixed -// functionality fragment depth. -// -// The fragment shader has access to the read-only built-in variable gl_FrontFacing whose value -// is true if the fragment belongs to a front-facing primitive. One use of this is to emulate -// two-sided lighting by selecting one of two colors calculated by the vertex shader. -// -// The built-in variables that are accessible from a fragment shader are intrinsically given types -// as follows: -// - -__fixed_input vec4 gl_FragCoord; -__fixed_input bool gl_FrontFacing; -__fixed_output vec4 gl_FragColor; -__fixed_output vec4 gl_FragData[gl_MaxDrawBuffers]; -__fixed_output float gl_FragDepth; - -// -// However, they do not behave like variables with no qualifier; their behavior is as described -// above. These built-in variables have global scope. -// - -// -// Unlike user-defined varying variables, the built-in varying variables don't have a strict -// one-to-one correspondence between the vertex language and the fragment language. Two sets are -// provided, one for each language. Their relationship is described below. -// -// The following varying variables are available to read from in a fragment shader. The gl_Color -// and gl_SecondaryColor names are the same names as attributes passed to the vertex shader. -// However, there is no name conflict, because attributes are visible only in vertex shaders -// and the following are only visible in a fragment shader. -// - -varying vec4 gl_Color; -varying vec4 gl_SecondaryColor; -varying vec4 gl_TexCoord[]; // at most will be gl_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: -// -// * They expose some necessary hardware functionality in a convenient way such as accessing -// a texture map. There is no way in the language for these functions to be emulated by a shader. -// -// * They represent a trivial operation (clamp, mix, etc.) that is very simple for the user -// to write, but they are very common and may have direct hardware support. It is a very hard -// problem for the compiler to map expressions to complex assembler instructions. -// -// * They represent an operation graphics hardware is likely to accelerate at some point. The -// trigonometry functions fall into this category. -// -// Many of the functions are similar to the same named ones in common C libraries, but they support -// vector input as well as the more traditional scalar input. -// -// Applications should be encouraged to use the built-in functions rather than do the equivalent -// computations in their own shader code since the built-in functions are assumed to be optimal -// (e.g., perhaps supported directly in hardware). -// -// User code can replace built-in functions with their own if they choose, by simply re-declaring -// and defining the same name and argument list. -// - -// -// 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 "Lod" are allowed only in a vertex shader. For the "Lod" functions, -// lod is directly used as the level of detail. -// - -// -// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate coord.s is divided by -// the last component of coord. -// -// XXX -vec4 texture1D (sampler1D sampler, float coord, float bias) { - return vec4 (0.0); -} -vec4 texture1DProj (sampler1D sampler, vec2 coord, float bias) { - return texture1D (sampler, coord.s / coord.t, bias); -} -vec4 texture1DProj (sampler1D sampler, vec4 coord, float bias) { - return texture1D (sampler, coord.s / coord.q, bias); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate (coord.s, coord.t) is -// divided by the last component of coord. The third component of coord is ignored for the vec4 -// coord variant. -// -// XXX -vec4 texture2D (sampler2D sampler, vec2 coord, float bias) { - return vec4 (0.0); -} -vec4 texture2DProj (sampler2D sampler, vec3 coord, float bias) { - return texture2D (sampler, vec2 (coord.s / coord.p, coord.t / coord.p), bias); -} -vec4 texture2DProj (sampler2D sampler, vec4 coord, float bias) { - return texture2D (sampler, vec2 (coord.s / coord.q, coord.s / coord.q), bias); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate is divided by coord.q. -// -// XXX -vec4 texture3D (sampler3D sampler, vec3 coord, float bias) { - return vec4 (0.0); -} -vec4 texture3DProj (sampler3D sampler, vec4 coord, float bias) { - return texture3DProj (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q), - bias); -} - -// -// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound -// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture -// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification. -// -// XXX -vec4 textureCube (samplerCube sampler, vec3 coord, float bias) { - return vec4 (0.0); -} - -// -// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound -// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd -// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a -// depth texture, or results are undefined. For the projective ("Proj") version of each built-in, -// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The -// second component of coord is ignored for the "1D" variants. -// -// XXX -vec4 shadow1D (sampler1DShadow sampler, vec3 coord, float bias) { - return vec4 (0.0); -} -// XXX -vec4 shadow2D (sampler2DShadow sampler, vec3 coord, float bias) { - return vec4 (0.0); -} -vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord, float bias) { - return shadow1D (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q), bias); -} -vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord, float bias) { - return shadow2D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q), bias); -} - -// -// 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)); -} - diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_shader.syn b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_shader.syn deleted file mode 100644 index 65d7fe353..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_shader.syn +++ /dev/null @@ -1,1508 +0,0 @@ -/*
- * Mesa 3-D graphics library
- * Version: 6.2
- *
- * Copyright (C) 2004-2005 Brian Paul All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/*
- * \file slang_shader.syn
- * slang vertex/fragment shader syntax
- * \author Michal Krol
- */
-
-/*
- * usage:
- * syn2c slang_shader.syn > slang_shader_syn.h
- *
- * when modifying or extending this file, several things must be taken into consideration:
- * - when adding new operators that were marked as reserved in the initial specification,
- * one must only uncomment particular lines of code that refer to operators being added;
- * - when adding new shader target, one must reserve new value for shader_type register and
- * use it in .if constructs for symbols that are exclusive for that shader;
- * - some symbols mimic output of other symbols - the best example is the "for" construct:
- * expression "for (foo(); ; bar())" is seen as "for (foo(); true; bar())" by the output
- * processor - hence, special care must be taken when rearranging output of essential symbols;
- * - order of single-quoted tokens does matter in alternatives - so do not parse "<" operator
- * before "<<" and "<<" before "<<=";
- * - all double-quoted tokens are internally preprocessed to eliminate problems with parsing
- * strings that are prefixes of other strings, like "sampler1D" and "sampler1DShadow";
- */
-
-.syntax translation_unit;
-
-/* revision number - increment after each change affecting emitted output */
-.emtcode REVISION 2
-
-/* external declaration */
-.emtcode EXTERNAL_NULL 0
-.emtcode EXTERNAL_FUNCTION_DEFINITION 1
-.emtcode EXTERNAL_DECLARATION 2
-
-/* declaration */
-.emtcode DECLARATION_FUNCTION_PROTOTYPE 1
-.emtcode DECLARATION_INIT_DECLARATOR_LIST 2
-
-/* function type */
-.emtcode FUNCTION_ORDINARY 0
-.emtcode FUNCTION_CONSTRUCTOR 1
-.emtcode FUNCTION_OPERATOR 2
-
-/* operator type */
-.emtcode OPERATOR_ASSIGN 1
-.emtcode OPERATOR_ADDASSIGN 2
-.emtcode OPERATOR_SUBASSIGN 3
-.emtcode OPERATOR_MULASSIGN 4
-.emtcode OPERATOR_DIVASSIGN 5
-/*.emtcode OPERATOR_MODASSIGN 6*/
-/*.emtcode OPERATOR_LSHASSIGN 7*/
-/*.emtcode OPERATOR_RSHASSIGN 8*/
-/*.emtcode OPERATOR_ORASSIGN 9*/
-/*.emtcode OPERATOR_XORASSIGN 10*/
-/*.emtcode OPERATOR_ANDASSIGN 11*/
-.emtcode OPERATOR_LOGICALXOR 12
-/*.emtcode OPERATOR_BITOR 13*/
-/*.emtcode OPERATOR_BITXOR 14*/
-/*.emtcode OPERATOR_BITAND 15*/
-.emtcode OPERATOR_EQUAL 16
-.emtcode OPERATOR_NOTEQUAL 17
-.emtcode OPERATOR_LESS 18
-.emtcode OPERATOR_GREATER 19
-.emtcode OPERATOR_LESSEQUAL 20
-.emtcode OPERATOR_GREATEREQUAL 21
-/*.emtcode OPERATOR_LSHIFT 22*/
-/*.emtcode OPERATOR_RSHIFT 23*/
-.emtcode OPERATOR_MULTIPLY 24
-.emtcode OPERATOR_DIVIDE 25
-/*.emtcode OPERATOR_MODULUS 26*/
-.emtcode OPERATOR_INCREMENT 27
-.emtcode OPERATOR_DECREMENT 28
-.emtcode OPERATOR_PLUS 29
-.emtcode OPERATOR_MINUS 30
-/*.emtcode OPERATOR_COMPLEMENT 31*/
-.emtcode OPERATOR_NOT 32
-
-/* init declarator list */
-.emtcode DECLARATOR_NONE 0
-.emtcode DECLARATOR_NEXT 1
-
-/* variable declaration */
-.emtcode VARIABLE_NONE 0
-.emtcode VARIABLE_IDENTIFIER 1
-.emtcode VARIABLE_INITIALIZER 2
-.emtcode VARIABLE_ARRAY_EXPLICIT 3
-.emtcode VARIABLE_ARRAY_UNKNOWN 4
-
-/* type qualifier */
-.emtcode TYPE_QUALIFIER_NONE 0
-.emtcode TYPE_QUALIFIER_CONST 1
-.emtcode TYPE_QUALIFIER_ATTRIBUTE 2
-.emtcode TYPE_QUALIFIER_VARYING 3
-.emtcode TYPE_QUALIFIER_UNIFORM 4
-.emtcode TYPE_QUALIFIER_FIXEDOUTPUT 5
-.emtcode TYPE_QUALIFIER_FIXEDINPUT 6
-
-/* type specifier */
-.emtcode TYPE_SPECIFIER_VOID 0
-.emtcode TYPE_SPECIFIER_BOOL 1
-.emtcode TYPE_SPECIFIER_BVEC2 2
-.emtcode TYPE_SPECIFIER_BVEC3 3
-.emtcode TYPE_SPECIFIER_BVEC4 4
-.emtcode TYPE_SPECIFIER_INT 5
-.emtcode TYPE_SPECIFIER_IVEC2 6
-.emtcode TYPE_SPECIFIER_IVEC3 7
-.emtcode TYPE_SPECIFIER_IVEC4 8
-.emtcode TYPE_SPECIFIER_FLOAT 9
-.emtcode TYPE_SPECIFIER_VEC2 10
-.emtcode TYPE_SPECIFIER_VEC3 11
-.emtcode TYPE_SPECIFIER_VEC4 12
-.emtcode TYPE_SPECIFIER_MAT2 13
-.emtcode TYPE_SPECIFIER_MAT3 14
-.emtcode TYPE_SPECIFIER_MAT4 15
-.emtcode TYPE_SPECIFIER_SAMPLER1D 16
-.emtcode TYPE_SPECIFIER_SAMPLER2D 17
-.emtcode TYPE_SPECIFIER_SAMPLER3D 18
-.emtcode TYPE_SPECIFIER_SAMPLERCUBE 19
-.emtcode TYPE_SPECIFIER_SAMPLER1DSHADOW 20
-.emtcode TYPE_SPECIFIER_SAMPLER2DSHADOW 21
-.emtcode TYPE_SPECIFIER_STRUCT 22
-.emtcode TYPE_SPECIFIER_TYPENAME 23
-
-/* structure field */
-.emtcode FIELD_NONE 0
-.emtcode FIELD_NEXT 1
-.emtcode FIELD_ARRAY 2
-
-/* operation */
-.emtcode OP_END 0
-.emtcode OP_BLOCK_BEGIN_NO_NEW_SCOPE 1
-.emtcode OP_BLOCK_BEGIN_NEW_SCOPE 2
-.emtcode OP_DECLARE 3
-.emtcode OP_ASM 4
-.emtcode OP_BREAK 5
-.emtcode OP_CONTINUE 6
-.emtcode OP_DISCARD 7
-.emtcode OP_RETURN 8
-.emtcode OP_EXPRESSION 9
-.emtcode OP_IF 10
-.emtcode OP_WHILE 11
-.emtcode OP_DO 12
-.emtcode OP_FOR 13
-.emtcode OP_PUSH_VOID 14
-.emtcode OP_PUSH_BOOL 15
-.emtcode OP_PUSH_INT 16
-.emtcode OP_PUSH_FLOAT 17
-.emtcode OP_PUSH_IDENTIFIER 18
-.emtcode OP_SEQUENCE 19
-.emtcode OP_ASSIGN 20
-.emtcode OP_ADDASSIGN 21
-.emtcode OP_SUBASSIGN 22
-.emtcode OP_MULASSIGN 23
-.emtcode OP_DIVASSIGN 24
-/*.emtcode OP_MODASSIGN 25*/
-/*.emtcode OP_LSHASSIGN 26*/
-/*.emtcode OP_RSHASSIGN 27*/
-/*.emtcode OP_ORASSIGN 28*/
-/*.emtcode OP_XORASSIGN 29*/
-/*.emtcode OP_ANDASSIGN 30*/
-.emtcode OP_SELECT 31
-.emtcode OP_LOGICALOR 32
-.emtcode OP_LOGICALXOR 33
-.emtcode OP_LOGICALAND 34
-/*.emtcode OP_BITOR 35*/
-/*.emtcode OP_BITXOR 36*/
-/*.emtcode OP_BITAND 37*/
-.emtcode OP_EQUAL 38
-.emtcode OP_NOTEQUAL 39
-.emtcode OP_LESS 40
-.emtcode OP_GREATER 41
-.emtcode OP_LESSEQUAL 42
-.emtcode OP_GREATEREQUAL 43
-/*.emtcode OP_LSHIFT 44*/
-/*.emtcode OP_RSHIFT 45*/
-.emtcode OP_ADD 46
-.emtcode OP_SUBTRACT 47
-.emtcode OP_MULTIPLY 48
-.emtcode OP_DIVIDE 49
-/*.emtcode OP_MODULUS 50*/
-.emtcode OP_PREINCREMENT 51
-.emtcode OP_PREDECREMENT 52
-.emtcode OP_PLUS 53
-.emtcode OP_MINUS 54
-/*.emtcode OP_COMPLEMENT 55*/
-.emtcode OP_NOT 56
-.emtcode OP_SUBSCRIPT 57
-.emtcode OP_CALL 58
-.emtcode OP_FIELD 59
-.emtcode OP_POSTINCREMENT 60
-.emtcode OP_POSTDECREMENT 61
-
-/* parameter qualifier */
-.emtcode PARAM_QUALIFIER_IN 0
-.emtcode PARAM_QUALIFIER_OUT 1
-.emtcode PARAM_QUALIFIER_INOUT 2
-
-/* function parameter */
-.emtcode PARAMETER_NONE 0
-.emtcode PARAMETER_NEXT 1
-
-/* function parameter array presence */
-.emtcode PARAMETER_ARRAY_NOT_PRESENT 0
-.emtcode PARAMETER_ARRAY_PRESENT 1
-
-.errtext INVALID_EXTERNAL_DECLARATION "error 2001: invalid external declaration"
-.errtext INVALID_OPERATOR_OVERRIDE "error 2002: invalid operator override"
-.errtext LBRACE_EXPECTED "error 2003: '{' expected but '$err_token$' found"
-.errtext LPAREN_EXPECTED "error 2004: '(' expected but '$err_token$' found"
-.errtext RPAREN_EXPECTED "error 2005: ')' expected but '$err_token$' found"
-
-/* tells whether the shader that is being parsed is a built-in shader or not */
-/* 0 - normal behaviour */
-/* 1 - accepts constructor and operator definitions and __asm statements */
-/* the implementation will set it to 1 when compiling internal built-in shaders */
-.regbyte parsing_builtin 0
-
-/* holds the type of the shader being parsed; possible values are listed below */
-/* FRAGMENT_SHADER 1 */
-/* VERTEX_SHADER 2 */
-/* shader type is set by the caller before parsing */
-.regbyte shader_type 0
-
-/*
- <variable_identifier> ::= <identifier>
-*/
-variable_identifier
- identifier .emit OP_PUSH_IDENTIFIER;
-
-/*
- <primary_expression> ::= <variable_identifier>
- | <intconstant>
- | <floatconstant>
- | <boolconstant>
- | "(" <expression> ")"
-*/
-primary_expression
- floatconstant .or boolconstant .or intconstant .or variable_identifier .or primary_expression_1;
-primary_expression_1
- lparen .and expression .and rparen;
-
-/*
- <postfix_expression> ::= <primary_expression>
- | <postfix_expression> "[" <integer_expression> "]"
- | <function_call>
- | <postfix_expression> "." <field_selection>
- | <postfix_expression> "++"
- | <postfix_expression> "--"
-*/
-postfix_expression
- postfix_expression_1 .and .loop postfix_expression_2;
-postfix_expression_1
- function_call .or primary_expression;
-postfix_expression_2
- postfix_expression_3 .or postfix_expression_4 .or
- plusplus .emit OP_POSTINCREMENT .or
- minusminus .emit OP_POSTDECREMENT;
-postfix_expression_3
- lbracket .and integer_expression .and rbracket .emit OP_SUBSCRIPT;
-postfix_expression_4
- dot .and field_selection .emit OP_FIELD;
-
-/*
- <integer_expression> ::= <expression>
-*/
-integer_expression
- expression;
-
-/*
- <function_call> ::= <function_call_generic>
-*/
-function_call
- function_call_generic .emit OP_CALL .and .true .emit OP_END;
-
-/*
- <function_call_generic> ::= <function_call_header_with_parameters> ")"
- | <function_call_header_no_parameters> ")"
-*/
-function_call_generic
- function_call_generic_1 .or function_call_generic_2;
-function_call_generic_1
- function_call_header_with_parameters .and rparen .error RPAREN_EXPECTED;
-function_call_generic_2
- function_call_header_no_parameters .and rparen .error RPAREN_EXPECTED;
-
-/*
- <function_call_header_no_parameters>::= <function_call_header> "void"
- | <function_call_header>
-*/
-function_call_header_no_parameters
- function_call_header .and function_call_header_no_parameters_1;
-function_call_header_no_parameters_1
- "void" .or .true;
-
-/*
- <function_call_header_with_parameters>::= <function_call_header> <assignment_expression>
- | <function_call_header_with_parameters> ","
- <assignment_expression>
-*/
-function_call_header_with_parameters
- function_call_header .and assignment_expression .and .true .emit OP_END .and
- .loop function_call_header_with_parameters_1;
-function_call_header_with_parameters_1
- comma .and assignment_expression .and .true .emit OP_END;
-
-/*
- <function_call_header> ::= <function_identifier> "("
-*/
-function_call_header
- function_identifier .and lparen;
-
-/*
- <function_identifier> ::= <constructor_identifier>
- | <identifier>
-
-note: <constructor_identifier> has been deleted
-*/
-function_identifier
- identifier;
-
-/*
- <unary_expression> ::= <postfix_expression>
- | "++" <unary_expression>
- | "--" <unary_expression>
- | <unary_operator> <unary_expression>
-
- <unary_operator> ::= "+"
- | "-"
- | "!"
- | "~" // reserved
-*/
-unary_expression
- postfix_expression .or unary_expression_1 .or unary_expression_2 .or unary_expression_3 .or
- unary_expression_4 .or unary_expression_5/* .or unary_expression_6*/;
-unary_expression_1
- plusplus .and unary_expression .and .true .emit OP_PREINCREMENT;
-unary_expression_2
- minusminus .and unary_expression .and .true .emit OP_PREDECREMENT;
-unary_expression_3
- plus .and unary_expression .and .true .emit OP_PLUS;
-unary_expression_4
- minus .and unary_expression .and .true .emit OP_MINUS;
-unary_expression_5
- bang .and unary_expression .and .true .emit OP_NOT;
-/*unary_expression_6
- tilde .and unary_expression .and .true .emit OP_COMPLEMENT;*/
-
-/*
- <multiplicative_expression> ::= <unary_expression>
- | <multiplicative_expression> "*" <unary_expression>
- | <multiplicative_expression> "/" <unary_expression>
- | <multiplicative_expression> "%" <unary_expression> // reserved
-*/
-multiplicative_expression
- unary_expression .and .loop multiplicative_expression_1;
-multiplicative_expression_1
- multiplicative_expression_2 .or multiplicative_expression_3/* .or multiplicative_expression_4*/;
-multiplicative_expression_2
- star .and unary_expression .and .true .emit OP_MULTIPLY;
-multiplicative_expression_3
- slash .and unary_expression .and .true .emit OP_DIVIDE;
-/*multiplicative_expression_4
- percent .and unary_expression .and .true .emit OP_MODULUS;*/
-
-/*
- <additive_expression> ::= <multiplicative_expression>
- | <additive_expression> "+" <multiplicative_expression>
- | <additive_expression> "-" <multiplicative_expression>
-*/
-additive_expression
- multiplicative_expression .and .loop additive_expression_1;
-additive_expression_1
- additive_expression_2 .or additive_expression_3;
-additive_expression_2
- plus .and multiplicative_expression .and .true .emit OP_ADD;
-additive_expression_3
- minus .and multiplicative_expression .and .true .emit OP_SUBTRACT;
-
-/*
- <shift_expression> ::= <additive_expression>
- | <shift_expression> "<<" <additive_expression> // reserved
- | <shift_expression> ">>" <additive_expression> // reserved
-*/
-shift_expression
- additive_expression/* .and .loop shift_expression_1*/;
-/*shift_expression_1
- shift_expression_2 .or shift_expression_3;*/
-/*shift_expression_2
- lessless .and additive_expression .and .true .emit OP_LSHIFT;*/
-/*shift_expression_3
- greatergreater .and additive_expression .and .true .emit OP_RSHIFT;*/
-
-/*
- <relational_expression> ::= <shift_expression>
- | <relational_expression> "<" <shift_expression>
- | <relational_expression> ">" <shift_expression>
- | <relational_expression> "<=" <shift_expression>
- | <relational_expression> ">=" <shift_expression>
-*/
-relational_expression
- shift_expression .and .loop relational_expression_1;
-relational_expression_1
- relational_expression_2 .or relational_expression_3 .or relational_expression_4 .or
- relational_expression_5;
-relational_expression_2
- lessequals .and shift_expression .and .true .emit OP_LESSEQUAL;
-relational_expression_3
- greaterequals .and shift_expression .and .true .emit OP_GREATEREQUAL;
-relational_expression_4
- less .and shift_expression .and .true .emit OP_LESS;
-relational_expression_5
- greater .and shift_expression .and .true .emit OP_GREATER;
-
-/*
- <equality_expression> ::= <relational_expression>
- | <equality_expression> "==" <relational_expression>
- | <equality_expression> "!=" <relational_expression>
-*/
-equality_expression
- relational_expression .and .loop equality_expression_1;
-equality_expression_1
- equality_expression_2 .or equality_expression_3;
-equality_expression_2
- equalsequals .and relational_expression .and .true .emit OP_EQUAL;
-equality_expression_3
- bangequals .and relational_expression .and .true .emit OP_NOTEQUAL;
-
-/*
- <and_expression> ::= <equality_expression>
- | <and_expression> "&" <equality_expression> // reserved
-*/
-and_expression
- equality_expression/* .and .loop and_expression_1*/;
-/*and_expression_1
- ampersand .and equality_expression .and .true .emit OP_BITAND;*/
-
-/*
- <exclusive_or_expression> ::= <and_expression>
- | <exclusive_or_expression> "^" <and_expression> // reserved
-*/
-exclusive_or_expression
- and_expression/* .and .loop exclusive_or_expression_1*/;
-/*exclusive_or_expression_1
- caret .and and_expression .and .true .emit OP_BITXOR;*/
-
-/*
- <inclusive_or_expression> ::= <exclusive_or_expression>
- | <inclusive_or_expression> "|" <exclusive_or_expression> // reserved
-*/
-inclusive_or_expression
- exclusive_or_expression/* .and .loop inclusive_or_expression_1*/;
-/*inclusive_or_expression_1
- bar .and exclusive_or_expression .and .true .emit OP_BITOR;*/
-
-/*
- <logical_and_expression> ::= <inclusive_or_expression>
- | <logical_and_expression> "&&" <inclusive_or_expression>
-*/
-logical_and_expression
- inclusive_or_expression .and .loop logical_and_expression_1;
-logical_and_expression_1
- ampersandampersand .and inclusive_or_expression .and .true .emit OP_LOGICALAND;
-
-/*
- <logical_xor_expression> ::= <logical_and_expression>
- | <logical_xor_expression> "^^" <logical_and_expression>
-*/
-logical_xor_expression
- logical_and_expression .and .loop logical_xor_expression_1;
-logical_xor_expression_1
- caretcaret .and logical_and_expression .and .true .emit OP_LOGICALXOR;
-
-/*
- <logical_or_expression> ::= <logical_xor_expression>
- | <logical_or_expression> "||" <logical_xor_expression>
-*/
-logical_or_expression
- logical_xor_expression .and .loop logical_or_expression_1;
-logical_or_expression_1
- barbar .and logical_xor_expression .and .true .emit OP_LOGICALOR;
-
-/*
- <conditional_expression> ::= <logical_or_expression>
- | <logical_or_expression> "?" <expression> ":"
- <conditional_expression>
-*/
-conditional_expression
- logical_or_expression .and .loop conditional_expression_1;
-conditional_expression_1
- question .and expression .and colon .and conditional_expression .and .true .emit OP_SELECT;
-
-/*
- <assignment_expression> ::= <conditional_expression>
- | <unary_expression> <assignment_operator>
- <assignment_expression>
-
- <assignment_operator> ::= "="
- | "*="
- | "/="
- | "+="
- | "-="
- | "%=" // reserved
- | "<<=" // reserved
- | ">>=" // reserved
- | "&=" // reserved
- | "^=" // reserved
- | "|=" // reserved
-*/
-assignment_expression
- assignment_expression_1 .or assignment_expression_2 .or assignment_expression_3 .or
- assignment_expression_4 .or assignment_expression_5/* .or assignment_expression_6 .or
- assignment_expression_7 .or assignment_expression_8 .or assignment_expression_9 .or
- assignment_expression_10 .or assignment_expression_11*/ .or conditional_expression;
-assignment_expression_1
- unary_expression .and equals .and assignment_expression .and .true .emit OP_ASSIGN;
-assignment_expression_2
- unary_expression .and starequals .and assignment_expression .and .true .emit OP_MULASSIGN;
-assignment_expression_3
- unary_expression .and slashequals .and assignment_expression .and .true .emit OP_DIVASSIGN;
-assignment_expression_4
- unary_expression .and plusequals .and assignment_expression .and .true .emit OP_ADDASSIGN;
-assignment_expression_5
- unary_expression .and minusequals .and assignment_expression .and .true .emit OP_SUBASSIGN;
-/*assignment_expression_6
- unary_expression .and percentequals .and assignment_expression .and .true .emit OP_MODASSIGN;*/
-/*assignment_expression_7
- unary_expression .and lesslessequals .and assignment_expression .and .true .emit OP_LSHASSIGN;*/
-/*assignment_expression_8
- unary_expression .and greatergreaterequals .and assignment_expression .and
- .true .emit OP_RSHASSIGN;*/
-/*assignment_expression_9
- unary_expression .and ampersandequals .and assignment_expression .and .true .emit OP_ANDASSIGN;*/
-/*assignment_expression_10
- unary_expression .and caretequals .and assignment_expression .and .true .emit OP_XORASSIGN;*/
-/*assignment_expression_11
- unary_expression .and barequals .and assignment_expression .and .true .emit OP_ORASSIGN;*/
-
-/*
- <expression> ::= <assignment_expression>
- | <expression> "," <assignment_expression>
-*/
-expression
- assignment_expression .and .loop expression_1;
-expression_1
- comma .and assignment_expression .and .true .emit OP_SEQUENCE;
-
-/*
- <constant_expression> ::= <conditional_expression>
-*/
-constant_expression
- conditional_expression .and .true .emit OP_END;
-
-/*
- <declaration> ::= <function_prototype> ";"
- | <init_declarator_list> ";"
-*/
-declaration
- declaration_1 .or declaration_2;
-declaration_1
- function_prototype .emit DECLARATION_FUNCTION_PROTOTYPE .and semicolon;
-declaration_2
- init_declarator_list .emit DECLARATION_INIT_DECLARATOR_LIST .and semicolon;
-
-/*
- <function_prototype> ::= <function_declarator> ")"
-*/
-function_prototype
- function_declarator .and rparen .error RPAREN_EXPECTED .emit PARAMETER_NONE;
-
-/*
- <function_declarator> ::= <function_header>
- | <function_header_with_parameters>
-*/
-function_declarator
- function_header_with_parameters .or function_header;
-
-/*
- <function_header_with_parameters> ::= <function_header> <parameter_declaration>
- | <function_header_with_parameters> ","
- <parameter_declaration>
-*/
-function_header_with_parameters
- function_header .and parameter_declaration .and .loop function_header_with_parameters_1;
-function_header_with_parameters_1
- comma .and parameter_declaration;
-
-/*
- <function_header> ::= <fully_specified_type> <identifier> "("
-*/
-function_header
- function_header_nospace .or function_header_space;
-function_header_space
- fully_specified_type_space .and space .and function_decl_identifier .and lparen;
-function_header_nospace
- fully_specified_type_nospace .and function_decl_identifier .and lparen;
-
-/*
- <function_decl_identifier> ::= "__constructor"
- | <__operator>
- | <identifier>
-
-note: this is an extension to the standard language specification - normally slang disallows
- operator and constructor prototypes and definitions
-*/
-function_decl_identifier
- .if (parsing_builtin != 0) __operator .emit FUNCTION_OPERATOR .or
- .if (parsing_builtin != 0) "__constructor" .emit FUNCTION_CONSTRUCTOR .or
- identifier .emit FUNCTION_ORDINARY;
-
-/*
- <__operator> ::= "__operator" <overriden_op>
-
-note: this is an extension to the standard language specification - normally slang disallows
- operator prototypes and definitions
-*/
-__operator
- "__operator" .and overriden_operator .error INVALID_OPERATOR_OVERRIDE;
-
-/*
- <overriden_op> ::= "="
- | "+="
- | "-="
- | "*="
- | "/="
- | "%=" // reserved
- | "<<=" // reserved
- | ">>=" // reserved
- | "&=" // reserved
- | "^=" // reserved
- | "|=" // reserved
- | "^^"
- | "|" // reserved
- | "^" // reserved
- | "&" // reserved
- | "=="
- | "!="
- | "<"
- | ">"
- | "<="
- | ">="
- | "<<" // reserved
- | ">>" // reserved
- | "*"
- | "/"
- | "%" // reserved
- | "++"
- | "--"
- | "+"
- | "-"
- | "~" // reserved
- | "!"
-
-note: this is an extension to the standard language specification - normally slang disallows
- operator prototypes and definitions
-*/
-overriden_operator
- plusplus .emit OPERATOR_INCREMENT .or
- plusequals .emit OPERATOR_ADDASSIGN .or
- plus .emit OPERATOR_PLUS .or
- minusminus .emit OPERATOR_DECREMENT .or
- minusequals .emit OPERATOR_SUBASSIGN .or
- minus .emit OPERATOR_MINUS .or
- bangequals .emit OPERATOR_NOTEQUAL .or
- bang .emit OPERATOR_NOT .or
- starequals .emit OPERATOR_MULASSIGN .or
- star .emit OPERATOR_MULTIPLY .or
- slashequals .emit OPERATOR_DIVASSIGN .or
- slash .emit OPERATOR_DIVIDE .or
- lessequals .emit OPERATOR_LESSEQUAL .or
- /*lesslessequals .emit OPERATOR_LSHASSIGN .or*/
- /*lessless .emit OPERATOR_LSHIFT .or*/
- less .emit OPERATOR_LESS .or
- greaterequals .emit OPERATOR_GREATEREQUAL .or
- /*greatergreaterequals .emit OPERATOR_RSHASSIGN .or*/
- /*greatergreater .emit OPERATOR_RSHIFT .or*/
- greater .emit OPERATOR_GREATER .or
- equalsequals .emit OPERATOR_EQUAL .or
- equals .emit OPERATOR_ASSIGN .or
- /*percentequals .emit OPERATOR_MODASSIGN .or*/
- /*percent .emit OPERATOR_MODULUS .or*/
- /*ampersandequals .emit OPERATOR_ANDASSIGN */
- /*ampersand .emit OPERATOR_BITAND .or*/
- /*barequals .emit OPERATOR_ORASSIGN .or*/
- /*bar .emit OPERATOR_BITOR .or*/
- /*tilde .emit OPERATOR_COMPLEMENT .or*/
- /*caretequals .emit OPERATOR_XORASSIGN .or*/
- caretcaret .emit OPERATOR_LOGICALXOR /*.or
- caret .emit OPERATOR_BITXOR*/;
-
-/*
- <parameter_declarator> ::= <type_specifier> <identifier>
- | <type_specifier> <identifier> "[" <constant_expression>
- "]"
-*/
-parameter_declarator
- parameter_declarator_nospace .or parameter_declarator_space;
-parameter_declarator_nospace
- type_specifier_nospace .and identifier .and parameter_declarator_1;
-parameter_declarator_space
- type_specifier_space .and space .and identifier .and parameter_declarator_1;
-parameter_declarator_1
- parameter_declarator_2 .emit PARAMETER_ARRAY_PRESENT .or
- .true .emit PARAMETER_ARRAY_NOT_PRESENT;
-parameter_declarator_2
- lbracket .and constant_expression .and rbracket;
-
-/*
- <parameter_declaration> ::= <type_qualifier> <parameter_qualifier>
- <parameter_declarator>
- | <type_qualifier> <parameter_qualifier>
- <parameter_type_specifier>
- | <parameter_qualifier> <parameter_declarator>
- | <parameter_qualifier> <parameter_type_specifier>
-*/
-parameter_declaration
- parameter_declaration_1 .emit PARAMETER_NEXT;
-parameter_declaration_1
- parameter_declaration_2 .or parameter_declaration_3;
-parameter_declaration_2
- type_qualifier .and space .and parameter_qualifier .and parameter_declaration_4;
-parameter_declaration_3
- parameter_qualifier .emit TYPE_QUALIFIER_NONE .and parameter_declaration_4;
-parameter_declaration_4
- parameter_declarator .or parameter_type_specifier;
-
-/*
- <parameter_qualifier> ::= "in"
- | "out"
- | "inout"
- | ""
-*/
-parameter_qualifier
- parameter_qualifier_1 .or .true .emit PARAM_QUALIFIER_IN;
-parameter_qualifier_1
- parameter_qualifier_2 .and space;
-parameter_qualifier_2
- "in" .emit PARAM_QUALIFIER_IN .or
- "out" .emit PARAM_QUALIFIER_OUT .or
- "inout" .emit PARAM_QUALIFIER_INOUT;
-
-/*
- <parameter_type_specifier> ::= <type_specifier>
- | <type_specifier> "[" <constant_expression> "]"
-*/
-parameter_type_specifier
- parameter_type_specifier_1 .and .true .emit '\0' .and parameter_type_specifier_2;
-parameter_type_specifier_1
- type_specifier_nospace .or type_specifier_space;
-parameter_type_specifier_2
- parameter_type_specifier_3 .emit PARAMETER_ARRAY_PRESENT .or
- .true .emit PARAMETER_ARRAY_NOT_PRESENT;
-parameter_type_specifier_3
- lbracket .and constant_expression .and rbracket;
-
-/*
- <init_declarator_list> ::= <single_declaration>
- | <init_declarator_list> "," <identifier>
- | <init_declarator_list> "," <identifier> "[" "]"
- | <init_declarator_list> "," <identifier> "["
- <constant_expression> "]"
- | <init_declarator_list> "," <identifier> "="
- <initializer>
-*/
-init_declarator_list
- single_declaration .and .loop init_declarator_list_1 .emit DECLARATOR_NEXT .and
- .true .emit DECLARATOR_NONE;
-init_declarator_list_1
- comma .and identifier .emit VARIABLE_IDENTIFIER .and init_declarator_list_2;
-init_declarator_list_2
- init_declarator_list_3 .or init_declarator_list_4 .or .true .emit VARIABLE_NONE;
-init_declarator_list_3
- equals .and initializer .emit VARIABLE_INITIALIZER;
-init_declarator_list_4
- lbracket .and init_declarator_list_5 .and rbracket;
-init_declarator_list_5
- constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;
-
-/*
- <single_declaration> ::= <fully_specified_type>
- | <fully_specified_type> <identifier>
- | <fully_specified_type> <identifier> "[" "]"
- | <fully_specified_type> <identifier> "["
- <constant_expression> "]"
- | <fully_specified_type> <identifier> "=" <initializer>
-*/
-single_declaration
- single_declaration_nospace .or single_declaration_space;
-single_declaration_space
- fully_specified_type_space .and single_declaration_space_1;
-single_declaration_nospace
- fully_specified_type_nospace .and single_declaration_nospace_1;
-single_declaration_space_1
- single_declaration_space_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;
-single_declaration_nospace_1
- single_declaration_nospace_2 .emit VARIABLE_IDENTIFIER .or .true .emit VARIABLE_NONE;
-single_declaration_space_2
- space .and identifier .and single_declaration_3;
-single_declaration_nospace_2
- identifier .and single_declaration_3;
-single_declaration_3
- single_declaration_4 .or single_declaration_5 .or .true .emit VARIABLE_NONE;
-single_declaration_4
- equals .and initializer .emit VARIABLE_INITIALIZER;
-single_declaration_5
- lbracket .and single_declaration_6 .and rbracket;
-single_declaration_6
- constant_expression .emit VARIABLE_ARRAY_EXPLICIT .or .true .emit VARIABLE_ARRAY_UNKNOWN;
-
-/*
- <fully_specified_type> ::= <type_specifier>
- | <type_qualifier> <type_specifier>
-*/
-fully_specified_type_space
- fully_specified_type_1 .and type_specifier_space;
-fully_specified_type_nospace
- fully_specified_type_1 .and type_specifier_nospace;
-fully_specified_type_1
- fully_specified_type_2 .or .true .emit TYPE_QUALIFIER_NONE;
-fully_specified_type_2
- type_qualifier .and space;
-
-/*
- <type_qualifier> ::= "const"
- | "attribute" // Vertex only.
- | "varying"
- | "uniform"
- | "__fixed_output"
- | "__fixed_input"
-
-note: this is an extension to the standard language specification - normally slang disallows
- __fixed_output and __fixed_input type qualifiers
-*/
-type_qualifier
- "const" .emit TYPE_QUALIFIER_CONST .or
- .if (shader_type == 2) "attribute" .emit TYPE_QUALIFIER_ATTRIBUTE .or
- "varying" .emit TYPE_QUALIFIER_VARYING .or
- "uniform" .emit TYPE_QUALIFIER_UNIFORM .or
- .if (parsing_builtin != 0) "__fixed_output" .emit TYPE_QUALIFIER_FIXEDOUTPUT .or
- .if (parsing_builtin != 0) "__fixed_input" .emit TYPE_QUALIFIER_FIXEDINPUT;
-
-/*
- <type_specifier> ::= "void"
- | "float"
- | "int"
- | "bool"
- | "vec2"
- | "vec3"
- | "vec4"
- | "bvec2"
- | "bvec3"
- | "bvec4"
- | "ivec2"
- | "ivec3"
- | "ivec4"
- | "mat2"
- | "mat3"
- | "mat4"
- | "sampler1D"
- | "sampler2D"
- | "sampler3D"
- | "samplerCube"
- | "sampler1DShadow"
- | "sampler2DShadow"
- | <struct_specifier>
- | <type_name>
-*/
-type_specifier_space
- "void" .emit TYPE_SPECIFIER_VOID .or
- "float" .emit TYPE_SPECIFIER_FLOAT .or
- "int" .emit TYPE_SPECIFIER_INT .or
- "bool" .emit TYPE_SPECIFIER_BOOL .or
- "vec2" .emit TYPE_SPECIFIER_VEC2 .or
- "vec3" .emit TYPE_SPECIFIER_VEC3 .or
- "vec4" .emit TYPE_SPECIFIER_VEC4 .or
- "bvec2" .emit TYPE_SPECIFIER_BVEC2 .or
- "bvec3" .emit TYPE_SPECIFIER_BVEC3 .or
- "bvec4" .emit TYPE_SPECIFIER_BVEC4 .or
- "ivec2" .emit TYPE_SPECIFIER_IVEC2 .or
- "ivec3" .emit TYPE_SPECIFIER_IVEC3 .or
- "ivec4" .emit TYPE_SPECIFIER_IVEC4 .or
- "mat2" .emit TYPE_SPECIFIER_MAT2 .or
- "mat3" .emit TYPE_SPECIFIER_MAT3 .or
- "mat4" .emit TYPE_SPECIFIER_MAT4 .or
- "sampler1D" .emit TYPE_SPECIFIER_SAMPLER1D .or
- "sampler2D" .emit TYPE_SPECIFIER_SAMPLER2D .or
- "sampler3D" .emit TYPE_SPECIFIER_SAMPLER3D .or
- "samplerCube" .emit TYPE_SPECIFIER_SAMPLERCUBE .or
- "sampler1DShadow" .emit TYPE_SPECIFIER_SAMPLER1DSHADOW .or
- "sampler2DShadow" .emit TYPE_SPECIFIER_SAMPLER2DSHADOW .or
- type_name .emit TYPE_SPECIFIER_TYPENAME;
-type_specifier_nospace
- struct_specifier .emit TYPE_SPECIFIER_STRUCT;
-
-/*
- <struct_specifier> ::= "struct" <identifier> "{" <struct_declaration_list> "}"
- | "struct" "{" <struct_declaration_list> "}"
-*/
-struct_specifier
- "struct" .and struct_specifier_1 .and optional_space .and lbrace .error LBRACE_EXPECTED .and
- struct_declaration_list .and rbrace .emit FIELD_NONE;
-struct_specifier_1
- struct_specifier_2 .or .true .emit '\0';
-struct_specifier_2
- space .and identifier;
-
-/*
- <struct_declaration_list> ::= <struct_declaration>
- | <struct_declaration_list> <struct_declaration>
-*/
-struct_declaration_list
- struct_declaration .and .loop struct_declaration .emit FIELD_NEXT;
-
-/*
- <struct_declaration> ::= <type_specifier> <struct_declarator_list> ";"
-*/
-struct_declaration
- struct_declaration_nospace .or struct_declaration_space;
-struct_declaration_space
- type_specifier_space .and space .and struct_declarator_list .and semicolon .emit FIELD_NONE;
-struct_declaration_nospace
- type_specifier_nospace .and struct_declarator_list .and semicolon .emit FIELD_NONE;
-
-/*
- <struct_declarator_list> ::= <struct_declarator>
- | <struct_declarator_list> "," <struct_declarator>
-*/
-struct_declarator_list
- struct_declarator .and .loop struct_declarator_list_1 .emit FIELD_NEXT;
-struct_declarator_list_1
- comma .and struct_declarator;
-
-/*
- <struct_declarator> ::= <identifier>
- | <identifier> "[" <constant_expression> "]"
-*/
-struct_declarator
- identifier .and struct_declarator_1;
-struct_declarator_1
- struct_declarator_2 .emit FIELD_ARRAY .or .true .emit FIELD_NONE;
-struct_declarator_2
- lbracket .and constant_expression .and rbracket;
-
-/*
- <initializer> ::= <assignment_expression>
-*/
-initializer
- assignment_expression .and .true .emit OP_END;
-
-/*
- <declaration_statement> ::= <declaration>
-*/
-declaration_statement
- declaration;
-
-/*
- <statement> ::= <compound_statement>
- | <simple_statement>
-*/
-statement
- compound_statement .or simple_statement;
-statement_space
- compound_statement .or statement_space_1;
-statement_space_1
- space .and simple_statement;
-
-/*
- <simple_statement> ::= <__asm_statement>
- | <selection_statement>
- | <iteration_statement>
- | <jump_statement>
- | <expression_statement>
- | <declaration_statement>
-
-note: this is an extension to the standard language specification - normally slang disallows
- use of __asm statements
-*/
-simple_statement
- .if (parsing_builtin != 0) __asm_statement .emit OP_ASM .or
- selection_statement .or
- iteration_statement .or
- jump_statement .or
- expression_statement .emit OP_EXPRESSION .or
- declaration_statement .emit OP_DECLARE;
-
-/*
- <compound_statement> ::= "{" "}"
- | "{" <statement_list> "}"
-*/
-compound_statement
- compound_statement_1 .emit OP_BLOCK_BEGIN_NEW_SCOPE .and .true .emit OP_END;
-compound_statement_1
- compound_statement_2 .or compound_statement_3;
-compound_statement_2
- lbrace .and rbrace;
-compound_statement_3
- lbrace .and statement_list .and rbrace;
-
-/*
- <statement_no_new_scope> ::= <compound_statement_no_new_scope>
- | <simple_statement>
-*/
-statement_no_new_scope
- compound_statement_no_new_scope .or simple_statement;
-
-/*
- <compound_statement_no_new_scope> ::= "{" "}"
- | "{" <statement_list> "}"
-*/
-compound_statement_no_new_scope
- compound_statement_no_new_scope_1 .emit OP_BLOCK_BEGIN_NO_NEW_SCOPE .and .true .emit OP_END;
-compound_statement_no_new_scope_1
- compound_statement_no_new_scope_2 .or compound_statement_no_new_scope_3;
-compound_statement_no_new_scope_2
- lbrace .and rbrace;
-compound_statement_no_new_scope_3
- lbrace .and statement_list .and rbrace;
-
-/*
- <statement_list> ::= <statement>
- | <statement_list> <statement>
-*/
-statement_list
- statement .and .loop statement;
-
-/*
- <expression_statement> ::= ";"
- | <expression> ";"
-*/
-expression_statement
- expression_statement_1 .or expression_statement_2;
-expression_statement_1
- semicolon .emit OP_PUSH_VOID .emit OP_END;
-expression_statement_2
- expression .and semicolon .emit OP_END;
-
-/*
- <selection_statement> ::= "if" "(" <expression> ")" <selection_rest_statement>
-*/
-selection_statement
- "if" .emit OP_IF .and lparen .error LPAREN_EXPECTED .and expression .and
- rparen .error RPAREN_EXPECTED .emit OP_END .and selection_rest_statement;
-
-/*
- <selection_rest_statement> ::= <statement> "else" <statement>
- | <statement>
-*/
-selection_rest_statement
- statement .and selection_rest_statement_1;
-selection_rest_statement_1
- selection_rest_statement_2 .or .true .emit OP_EXPRESSION .emit OP_PUSH_VOID .emit OP_END;
-selection_rest_statement_2
- "else" .and optional_space .and statement;
-
-/*
- <condition> ::= <expression>
- | <fully_specified_type> <identifier> "=" <initializer>
-
-note: if <condition_1> is executed, the emit format must match <declaration> emit format
-*/
-condition
- condition_1 .emit OP_DECLARE .emit DECLARATION_INIT_DECLARATOR_LIST .or
- condition_3 .emit OP_EXPRESSION;
-condition_1
- condition_1_nospace .or condition_1_space;
-condition_1_nospace
- fully_specified_type_nospace .and condition_2;
-condition_1_space
- fully_specified_type_space .and space .and condition_2;
-condition_2
- identifier .emit VARIABLE_IDENTIFIER .and equals .emit VARIABLE_INITIALIZER .and
- initializer .and .true .emit DECLARATOR_NONE;
-condition_3
- expression .and .true .emit OP_END;
-
-/*
- <iteration_statement> ::= "while" "(" <condition> ")" <statement_no_new_scope>
- | "do" <statement> "while" "(" <expression> ")" ";"
- | "for" "(" <for_init_statement> <for_rest_statement> ")"
- <statement_no_new_scope>
-*/
-iteration_statement
- iteration_statement_1 .or iteration_statement_2 .or iteration_statement_3;
-iteration_statement_1
- "while" .emit OP_WHILE .and lparen .error LPAREN_EXPECTED .and condition .and
- rparen .error RPAREN_EXPECTED .and statement_no_new_scope;
-iteration_statement_2
- "do" .emit OP_DO .and statement_space .and "while" .and lparen .error LPAREN_EXPECTED .and
- expression .and rparen .error RPAREN_EXPECTED .emit OP_END .and semicolon;
-iteration_statement_3
- "for" .emit OP_FOR .and lparen .error LPAREN_EXPECTED .and for_init_statement .and
- for_rest_statement .and rparen .error RPAREN_EXPECTED .and statement_no_new_scope;
-
-/*
- <for_init_statement> ::= <expression_statement>
- | <declaration_statement>
-*/
-for_init_statement
- expression_statement .emit OP_EXPRESSION .or declaration_statement .emit OP_DECLARE;
-
-/*
- <conditionopt> ::= <condition>
- | ""
-
-note: <conditionopt> is used only by "for" statement - if <condition> is ommitted, parser
- simulates default behaviour, that is simulates "true" expression
-*/
-conditionopt
- condition .or
- .true .emit OP_EXPRESSION .emit OP_PUSH_BOOL .emit 2 .emit '1' .emit '\0' .emit OP_END;
-
-/*
- <for_rest_statement> ::= <conditionopt> ";"
- | <conditionopt> ";" <expression>
-*/
-for_rest_statement
- conditionopt .and semicolon .and for_rest_statement_1;
-for_rest_statement_1
- for_rest_statement_2 .or .true .emit OP_PUSH_VOID .emit OP_END;
-for_rest_statement_2
- expression .and .true .emit OP_END;
-
-/*
- <jump_statement> ::= "continue" ";"
- | "break" ";"
- | "return" ";"
- | "return" <expression> ";"
- | "discard" ";" // Fragment shader only.
-*/
-jump_statement
- jump_statement_1 .or jump_statement_2 .or jump_statement_3 .or jump_statement_4 .or
- .if (shader_type == 1) jump_statement_5;
-jump_statement_1
- "continue" .and semicolon .emit OP_CONTINUE;
-jump_statement_2
- "break" .and semicolon .emit OP_BREAK;
-jump_statement_3
- "return" .emit OP_RETURN .and optional_space .and expression .and semicolon .emit OP_END;
-jump_statement_4
- "return" .emit OP_RETURN .and semicolon .emit OP_PUSH_VOID .emit OP_END;
-jump_statement_5
- "discard" .and semicolon .emit OP_DISCARD;
-
-/*
- <__asm_statement> ::= "__asm" <identifier> <asm_arguments> ";"
-
-note: this is an extension to the standard language specification - normally slang disallows
- __asm statements
-*/
-__asm_statement
- "__asm" .and space .and identifier .and space .and asm_arguments .and semicolon .emit OP_END;
-
-/*
- <asm_arguments> ::= <identifier>
- | <asm_arguments> "," <identifier>
-
-note: this is an extension to the standard language specification - normally slang disallows
- __asm statements
-*/
-asm_arguments
- variable_identifier .and .true .emit OP_END .and .loop asm_arguments_1;
-asm_arguments_1
- comma .and variable_identifier .and .true .emit OP_END;
-
-/*
- <translation_unit> ::= <external_declaration>
- | <translation_unit> <external_declaration>
-*/
-translation_unit
- optional_space .emit REVISION .and external_declaration .error INVALID_EXTERNAL_DECLARATION .and
- .loop external_declaration .and optional_space .and
- '\0' .error INVALID_EXTERNAL_DECLARATION .emit EXTERNAL_NULL;
-
-/*
- <external_declaration> ::= <function_definition>
- | <declaration>
-*/
-external_declaration
- function_definition .emit EXTERNAL_FUNCTION_DEFINITION .or
- declaration .emit EXTERNAL_DECLARATION;
-
-/*
- <function_definition> :: <function_prototype> <compound_statement_no_new_scope>
-*/
-function_definition
- function_prototype .and compound_statement_no_new_scope;
-
-/* helper rulez, not part of the official language syntax */
-
-digit_oct
- '0'-'7';
-
-digit_dec
- '0'-'9';
-
-digit_hex
- '0'-'9' .or 'A'-'F' .or 'a'-'f';
-
-id_character_first
- 'a'-'z' .or 'A'-'Z' .or '_';
-
-id_character_next
- id_character_first .or digit_dec;
-
-identifier
- id_character_first .emit * .and .loop id_character_next .emit * .and .true .emit '\0';
-
-float
- float_1 .or float_2;
-float_1
- float_fractional_constant .and float_optional_exponent_part;
-float_2
- float_digit_sequence .and .true .emit '\0' .and float_exponent_part;
-
-float_fractional_constant
- float_fractional_constant_1 .or float_fractional_constant_2 .or float_fractional_constant_3;
-float_fractional_constant_1
- float_digit_sequence .and '.' .and float_digit_sequence;
-float_fractional_constant_2
- float_digit_sequence .and '.' .and .true .emit '\0';
-float_fractional_constant_3
- '.' .emit '\0' .and float_digit_sequence;
-
-float_optional_exponent_part
- float_exponent_part .or .true .emit '\0';
-
-float_digit_sequence
- digit_dec .emit * .and .loop digit_dec .emit * .and .true .emit '\0';
-
-float_exponent_part
- float_exponent_part_1 .or float_exponent_part_2;
-float_exponent_part_1
- 'e' .and float_optional_sign .and float_digit_sequence;
-float_exponent_part_2
- 'E' .and float_optional_sign .and float_digit_sequence;
-
-float_optional_sign
- float_sign .or .true;
-
-float_sign
- '+' .or '-' .emit '-';
-
-integer
- integer_hex .or integer_oct .or integer_dec;
-
-integer_hex
- '0' .and integer_hex_1 .emit 0x10 .and digit_hex .emit * .and .loop digit_hex .emit * .and
- .true .emit '\0';
-integer_hex_1
- 'x' .or 'X';
-
-integer_oct
- '0' .emit 8 .emit * .and .loop digit_oct .emit * .and .true .emit '\0';
-
-integer_dec
- digit_dec .emit 10 .emit * .and .loop digit_dec .emit * .and .true .emit '\0';
-
-boolean
- "true" .emit 2 .emit '1' .emit '\0' .or
- "false" .emit 2 .emit '0' .emit '\0';
-
-type_name
- identifier;
-
-field_selection
- identifier;
-
-floatconstant
- float .emit OP_PUSH_FLOAT;
-
-intconstant
- integer .emit OP_PUSH_INT;
-
-boolconstant
- boolean .emit OP_PUSH_BOOL;
-
-optional_space
- .loop single_space;
-
-space
- single_space .and .loop single_space;
-
-single_space
- white_char .or c_style_comment_block .or cpp_style_comment_block;
-
-white_char
- ' ' .or '\t' .or new_line .or '\v' .or '\f';
-
-new_line
- cr_lf .or lf_cr .or '\n' .or '\r';
-
-cr_lf
- '\r' .and '\n';
-
-lf_cr
- '\n' .and '\r';
-
-c_style_comment_block
- '/' .and '*' .and c_style_comment_rest;
-
-c_style_comment_rest
- .loop c_style_comment_char_no_star .and c_style_comment_rest_1;
-c_style_comment_rest_1
- c_style_comment_end .or c_style_comment_rest_2;
-c_style_comment_rest_2
- '*' .and c_style_comment_rest;
-
-c_style_comment_char_no_star
- '\x2B'-'\xFF' .or '\x01'-'\x29';
-
-c_style_comment_end
- '*' .and '/';
-
-cpp_style_comment_block
- '/' .and '/' .and cpp_style_comment_block_1;
-cpp_style_comment_block_1
- cpp_style_comment_block_2 .or cpp_style_comment_block_3;
-cpp_style_comment_block_2
- .loop cpp_style_comment_char .and new_line;
-cpp_style_comment_block_3
- .loop cpp_style_comment_char;
-
-cpp_style_comment_char
- '\x0E'-'\xFF' .or '\x01'-'\x09' .or '\x0B'-'\x0C';
-
-/* lexical rulez */
-
-/*ampersand
- optional_space .and '&' .and optional_space;*/
-
-ampersandampersand
- optional_space .and '&' .and '&' .and optional_space;
-
-/*ampersandequals
- optional_space .and '&' .and '=' .and optional_space;*/
-
-/*bar
- optional_space .and '|' .and optional_space;*/
-
-barbar
- optional_space .and '|' .and '|' .and optional_space;
-
-/*barequals
- optional_space .and '|' .and '=' .and optional_space;*/
-
-bang
- optional_space .and '!' .and optional_space;
-
-bangequals
- optional_space .and '!' .and '=' .and optional_space;
-
-/*caret
- optional_space .and '^' .and optional_space;*/
-
-caretcaret
- optional_space .and '^' .and '^' .and optional_space;
-
-/*caretequals
- optional_space .and '^' .and '=' .and optional_space;*/
-
-colon
- optional_space .and ':' .and optional_space;
-
-comma
- optional_space .and ',' .and optional_space;
-
-dot
- optional_space .and '.' .and optional_space;
-
-equals
- optional_space .and '=' .and optional_space;
-
-equalsequals
- optional_space .and '=' .and '=' .and optional_space;
-
-greater
- optional_space .and '>' .and optional_space;
-
-greaterequals
- optional_space .and '>' .and '=' .and optional_space;
-
-/*greatergreater
- optional_space .and '>' .and '>' .and optional_space;*/
-
-/*greatergreaterequals
- optional_space .and '>' .and '>' .and '=' .and optional_space;*/
-
-lbrace
- optional_space .and '{' .and optional_space;
-
-lbracket
- optional_space .and '[' .and optional_space;
-
-less
- optional_space .and '<' .and optional_space;
-
-lessequals
- optional_space .and '<' .and '=' .and optional_space;
-
-/*lessless
- optional_space .and '<' .and '<' .and optional_space;*/
-
-/*lesslessequals
- optional_space .and '<' .and '<' .and '=' .and optional_space;*/
-
-lparen
- optional_space .and '(' .and optional_space;
-
-minus
- optional_space .and '-' .and optional_space;
-
-minusequals
- optional_space .and '-' .and '=' .and optional_space;
-
-minusminus
- optional_space .and '-' .and '-' .and optional_space;
-
-/*percent
- optional_space .and '%' .and optional_space;*/
-
-/*percentequals
- optional_space .and '%' .and '=' .and optional_space;*/
-
-plus
- optional_space .and '+' .and optional_space;
-
-plusequals
- optional_space .and '+' .and '=' .and optional_space;
-
-plusplus
- optional_space .and '+' .and '+' .and optional_space;
-
-question
- optional_space .and '?' .and optional_space;
-
-rbrace
- optional_space .and '}' .and optional_space;
-
-rbracket
- optional_space .and ']' .and optional_space;
-
-rparen
- optional_space .and ')' .and optional_space;
-
-semicolon
- optional_space .and ';' .and optional_space;
-
-slash
- optional_space .and '/' .and optional_space;
-
-slashequals
- optional_space .and '/' .and '=' .and optional_space;
-
-star
- optional_space .and '*' .and optional_space;
-
-starequals
- optional_space .and '*' .and '=' .and optional_space;
-
-/*tilde
- optional_space .and '~' .and optional_space;*/
-
-/* string rulez - these are used internally by the parser when parsing quoted strings */
-
-.string string_lexer;
-
-string_lexer
- lex_first_identifier_character .and .loop lex_next_identifier_character;
-
-lex_first_identifier_character
- 'a'-'z' .or 'A'-'Z' .or '_';
-
-lex_next_identifier_character
- 'a'-'z' .or 'A'-'Z' .or '0'-'9' .or '_';
-
-/* error rulez - these are used by error messages */
-
-err_token
- '~' .or '`' .or '!' .or '@' .or '#' .or '$' .or '%' .or '^' .or '&' .or '*' .or '(' .or ')' .or
- '-' .or '+' .or '=' .or '|' .or '\\' .or '[' .or ']' .or '{' .or '}' .or ':' .or ';' .or '"' .or
- '\'' .or '<' .or ',' .or '>' .or '.' .or '/' .or '?' .or err_identifier;
-
-err_identifier
- id_character_first .and .loop id_character_next;
-
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_version.syn b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_version.syn deleted file mode 100755 index 3a8c7046b..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_version.syn +++ /dev/null @@ -1,118 +0,0 @@ -/*
- * Mesa 3-D graphics library
- * Version: 6.3
- *
- * Copyright (C) 2005 Brian Paul All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/**
- * \file slang_version.syn
- * slang #version directive syntax
- * \author Michal Krol
- */
-
-.syntax version_directive;
-
-version_directive
- version_directive_1 .and .loop version_directive_2;
-version_directive_1
- prior_optional_spaces .and optional_version_directive .and .true .emit $;
-version_directive_2
- prior_optional_spaces .and version_directive_body .and .true .emit $;
-
-optional_version_directive
- version_directive_body .or .true .emit 10 .emit 1;
-
-version_directive_body
- '#' .and optional_space .and "version" .and space .and version_number .and optional_space .and
- new_line;
-
-version_number
- version_number_110;
-
-version_number_110
- leading_zeroes .and "110" .emit 10 .emit 1;
-
-leading_zeroes
- .loop zero;
-
-zero
- '0';
-
-space
- single_space .and .loop single_space;
-
-optional_space
- .loop single_space;
-
-single_space
- ' ' .or '\t';
-
-prior_optional_spaces
- .loop prior_space;
-
-prior_space
- c_style_comment_block .or cpp_style_comment_block .or space .or new_line;
-
-c_style_comment_block
- '/' .and '*' .and c_style_comment_rest;
-
-c_style_comment_rest
- .loop c_style_comment_char_no_star .and c_style_comment_rest_1;
-c_style_comment_rest_1
- c_style_comment_end .or c_style_comment_rest_2;
-c_style_comment_rest_2
- '*' .and c_style_comment_rest;
-
-c_style_comment_char_no_star
- '\x2B'-'\xFF' .or '\x01'-'\x29';
-
-c_style_comment_end
- '*' .and '/';
-
-cpp_style_comment_block
- '/' .and '/' .and cpp_style_comment_block_1;
-cpp_style_comment_block_1
- cpp_style_comment_block_2 .or cpp_style_comment_block_3;
-cpp_style_comment_block_2
- .loop cpp_style_comment_char .and new_line;
-cpp_style_comment_block_3
- .loop cpp_style_comment_char;
-
-cpp_style_comment_char
- '\x0E'-'\xFF' .or '\x01'-'\x09' .or '\x0B'-'\x0C';
-
-new_line
- cr_lf .or lf_cr .or '\n' .or '\r';
-
-cr_lf
- '\r' .and '\n';
-
-lf_cr
- '\n' .and '\r';
-
-.string __string_filter;
-
-__string_filter
- .loop __identifier_char;
-
-__identifier_char
- 'a'-'z' .or 'A'-'Z' .or '_' .or '0'-'9';
-
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_vertex_builtin.gc b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_vertex_builtin.gc deleted file mode 100755 index 850fd2bb8..000000000 --- a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_vertex_builtin.gc +++ /dev/null @@ -1,262 +0,0 @@ - -// -// 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: -// - -__fixed_output vec4 gl_Position; // must be written to -__fixed_output float gl_PointSize; // may be written to -__fixed_output vec4 gl_ClipVertex; // may be written to - -// -// If gl_PointSize or gl_ClipVertex are not written to, their values are undefined. Any of these -// variables can be read back by the shader after writing to them, to retrieve what was written. -// Reading them before writing them results in undefined behavior. If they are written more than -// once, it is the last value written that is consumed by the subsequent operations. -// -// These built-in variables have global scope. -// - -// -// The following attribute names are built into the OpenGL vertex language and can be used from -// within a vertex shader to access the current values of attributes declared by OpenGL. All page -// numbers and notations are references to the OpenGL 1.4 specification. -// - -// -// Vertex Attributes, p. 19. -// - -attribute vec4 gl_Color; -attribute vec4 gl_SecondaryColor; -attribute vec3 gl_Normal; -attribute vec4 gl_Vertex; -attribute vec4 gl_MultiTexCoord0; -attribute vec4 gl_MultiTexCoord1; -attribute vec4 gl_MultiTexCoord2; -attribute vec4 gl_MultiTexCoord3; -attribute vec4 gl_MultiTexCoord4; -attribute vec4 gl_MultiTexCoord5; -attribute vec4 gl_MultiTexCoord6; -attribute vec4 gl_MultiTexCoord7; -attribute float gl_FogCoord; - -// -// Unlike user-defined varying variables, the built-in varying variables don't have a strict -// one-to-one correspondence between the vertex language and the fragment language. Two sets are -// provided, one for each language. Their relationship is described below. -// -// The following built-in varying variables are available to write to in a vertex shader. -// A particular one should be written to if any functionality in a corresponding fragment shader -// or fixed pipeline uses it or state derived from it. Otherwise, behavior is undefined. -// - -varying vec4 gl_FrontColor; -varying vec4 gl_BackColor; -varying vec4 gl_FrontSecondaryColor; -varying vec4 gl_BackSecondaryColor; -varying vec4 gl_TexCoord[]; // at most will be gl_MaxTextureCoords -varying float gl_FogFragCoord; - -// -// For gl_FogFragCoord, the value written will be used as the "c" value on page 160 of the -// OpenGL 1.4 Specification by the fixed functionality pipeline. For example, if the z-coordinate -// of the fragment in eye space is desired as "c", then that's what the vertex shader should write -// into gl_FogFragCoord. -// -// As with all arrays, indices used to subscript gl_TexCoord must either be 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: -// -// * They expose some necessary hardware functionality in a convenient way such as accessing -// a texture map. There is no way in the language for these functions to be emulated by a shader. -// -// * They represent a trivial operation (clamp, mix, etc.) that is very simple for the user -// to write, but they are very common and may have direct hardware support. It is a very hard -// problem for the compiler to map expressions to complex assembler instructions. -// -// * They represent an operation graphics hardware is likely to accelerate at some point. The -// trigonometry functions fall into this category. -// -// Many of the functions are similar to the same named ones in common C libraries, but they support -// vector input as well as the more traditional scalar input. -// -// Applications should be encouraged to use the built-in functions rather than do the equivalent -// computations in their own shader code since the built-in functions are assumed to be optimal -// (e.g., perhaps supported directly in hardware). -// -// User code can replace built-in functions with their own if they choose, by simply re-declaring -// and defining the same name and argument list. -// - -// -// Geometric Functions -// -// These operate on vectors as vectors, not component-wise. -// - -// -// For vertex shaders only. This function will ensure that the incoming vertex value will be -// transformed in a way that produces exactly the same result as would be produced by OpenGL's -// fixed functionality transform. It is intended to be used to compute gl_Position, e.g., -// gl_Position = ftransform() -// This function should be used, for example, when an application is rendering the same geometry in -// separate passes, and one pass uses the fixed functionality path to render and another pass uses -// programmable shaders. -// - -vec4 ftransform () { - return gl_ModelViewProjectionMatrix * gl_Vertex; -} - -// -// 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 "Lod" are allowed only in a vertex shader. For the "Lod" functions, -// lod is directly used as the level of detail. -// - -// -// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate coord.s is divided by -// the last component of coord. -// -// XXX -vec4 texture1DLod (sampler1D sampler, float coord, float lod) { - return vec4 (0.0); -} -vec4 texture1DProjLod (sampler1D sampler, vec2 coord, float lod) { - return texture1DLod (sampler, coord.s / coord.t, lod); -} -vec4 texture1DProjLod (sampler1D sampler, vec4 coord, float lod) { - return texture1DLod (sampler, coord.s / coord.q, lod); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate (coord.s, coord.t) is -// divided by the last component of coord. The third component of coord is ignored for the vec4 -// coord variant. -// -// XXX -vec4 texture2DLod (sampler2D sampler, vec2 coord, float lod) { - return vec4 (0.0); -} -vec4 texture2DProjLod (sampler2D sampler, vec3 coord, float lod) { - return texture2DLod (sampler, vec2 (coord.s / coord.p, coord.t / coord.p), lod); -} -vec4 texture2DProjLod (sampler2D sampler, vec4 coord, float lod) { - return texture2DLod (sampler, vec2 (coord.s / coord.q, coord.t / coord.q), lod); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound -// to sampler. For the projective ("Proj") versions, the texture coordinate is divided by coord.q. -// -// XXX -vec4 texture3DLod (sampler3D sampler, vec3 coord, float lod) { - return vec4 (0.0); -} -vec4 texture3DProjLod (sampler3D sampler, vec4 coord, float lod) { - return texture3DLod (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.s / coord.q), - lod); -} - -// -// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound -// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture -// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification. -// -// XXX -vec4 textureCubeLod (samplerCube sampler, vec3 coord, float lod) { - return vec4 (0.0); -} - -// -// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound -// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd -// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a -// depth texture, or results are undefined. For the projective ("Proj") version of each built-in, -// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The -// second component of coord is ignored for the "1D" variants. -// -// XXX -vec4 shadow1DLod (sampler1DShadow sampler, vec3 coord, float lod) { - return vec4 (0.0); -} -// XXX -vec4 shadow2DLod (sampler2DShadow sampler, vec3 coord, float lod) { - return vec4 (0.0); -} -vec4 shadow1DProjLod (sampler1DShadow sampler, vec4 coord, float lod) { - return shadow1DLod (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q), lod); -} -vec4 shadow2DProjLod (sampler2DShadow sampler, vec4 coord, float lod) { - return shadow2DLod (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q), - lod); -} - |