From f459b9f9c0ac4f0634028a7edb6275bb1201a055 Mon Sep 17 00:00:00 2001 From: Michal Krol Date: Mon, 18 Oct 2004 12:18:33 +0000 Subject: [PATCH] conform to shader spec 1.10.59 --- src/mesa/shader/slang_common_builtin.gc | 2711 +++++++++++---------- src/mesa/shader/slang_fragment_builtin.gc | 720 +++--- src/mesa/shader/slang_vertex_builtin.gc | 522 ++-- 3 files changed, 2037 insertions(+), 1916 deletions(-) diff --git a/src/mesa/shader/slang_common_builtin.gc b/src/mesa/shader/slang_common_builtin.gc index 994e1a31fb1..65c5c79e6dc 100755 --- a/src/mesa/shader/slang_common_builtin.gc +++ b/src/mesa/shader/slang_common_builtin.gc @@ -1,1302 +1,1409 @@ - -// -// TODO: -// - implement sin, asin, acos, atan, pow, log2, floor, ceil, -// - implement texture1D, texture2D, texture3D, textureCube, -// - implement shadow1D, shadow2D, -// - implement noise1, noise2, noise3, noise4, -// - -// -// From Shader Spec, ver. 1.051 -// -// The following built-in constants are provided to vertex and fragment shaders. -// - -// -// Implementation dependent constants. The example values below -// are the minimum values allowed for these maximums. -// - -const int gl_MaxLights = 8; // GL 1.0 -const int gl_MaxClipPlanes = 6; // GL 1.0 -const int gl_MaxTextureUnits = 2; // GL 1.2 -const int gl_MaxTextureCoordsARB = 2; // ARB_fragment_program -const int gl_MaxVertexAttributesGL2 = 16; // GL2_vertex_shader -const int gl_MaxVertexUniformFloatsGL2 = 512; // GL2_vertex_shader -const int gl_MaxVaryingFloatsGL2 = 32; // GL2_vertex_shader -const int gl_MaxVertexTextureUnitsGL2 = 1; // GL2_vertex_shader -const int gl_MaxFragmentTextureUnitsGL2 = 2; // GL2_fragment_shader -const int gl_MaxFragmentUniformFloatsGL2 = 64; // GL2_fragment_shader - -// -// As an aid to accessing OpenGL processing state, the following uniform variables are built into -// the OpenGL Shading Language. All page numbers and notations are references to the 1.4 -// specification. -// - -// -// Matrix state. p. 31, 32, 37, 39, 40. -// - -uniform mat4 gl_ModelViewMatrix; -uniform mat4 gl_ProjectionMatrix; -uniform mat4 gl_ModelViewProjectionMatrix; -uniform mat3 gl_NormalMatrix; // derived -uniform mat4 gl_TextureMatrix[gl_MaxTextureCoordsARB]; - -// -// Normal scaling p. 39. -// - -uniform float gl_NormalScale; - -// -// Depth range in window coordinates, p. 33 -// - -struct gl_DepthRangeParameters { - float near; // n - float far; // f - float diff; // f - n -}; - -uniform gl_DepthRangeParameters gl_DepthRange; - -// -// Clip planes p. 42. -// - -uniform vec4 gl_ClipPlane[gl_MaxClipPlanes]; - -// -// Point Size, p. 66, 67. -// - -struct gl_PointParameters { - float size; - float sizeMin; - float sizeMax; - float fadeThresholdSize; - float distanceConstantAttenuation; - float distanceLinearAttenuation; - float distanceQuadraticAttenuation; -}; - -uniform gl_PointParameters gl_Point; - -// -// Material State p. 50, 55. -// - -struct gl_MaterialParameters { - vec4 emission; // Ecm - vec4 ambient; // Acm - vec4 diffuse; // Dcm - vec4 specular; // Scm - float shininess; // Srm -}; - -uniform gl_MaterialParameters gl_FrontMaterial; -uniform gl_MaterialParameters gl_BackMaterial; - -// -// Light State p 50, 53, 55. -// - -struct gl_LightSourceParameters { - vec4 ambient; // Acli - vec4 diffuse; // Dcli - vec4 specular; // Scli - vec4 position; // Ppli - vec4 halfVector; // Derived: Hi - vec3 spotDirection; // Sdli - float spotExponent; // Srli - float spotCutoff; // Crli - // (range: [0.0,90.0], 180.0) - float spotCosCutoff; // Derived: cos(Crli) - // (range: [1.0,0.0],-1.0) - float constantAttenuation; // K0 - float linearAttenuation; // K1 - float quadraticAttenuation; // K2 -}; - -uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights]; - -struct gl_LightModelParameters { - vec4 ambient; // Acs -}; - -uniform gl_LightModelParameters gl_LightModel; - -// -// Derived state from products of light and material. -// - -struct gl_LightModelProducts { - vec4 sceneColor; // Derived. Ecm + Acm * Acs -}; - -uniform gl_LightModelProducts gl_FrontLightModelProduct; -uniform gl_LightModelProducts gl_BackLightModelProduct; - -struct gl_LightProducts { - vec4 ambient; // Acm * Acli - vec4 diffuse; // Dcm * Dcli - vec4 specular; // Scm * Scli -}; - -uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights]; -uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights]; - -// -// Textureg Environment and Generation, p. 152, p. 40-42. -// - -uniform vec4 gl_TextureEnvColor[gl_MaxFragmentTextureUnitsGL2]; -uniform vec4 gl_EyePlaneS[gl_MaxTextureCoordsARB]; -uniform vec4 gl_EyePlaneT[gl_MaxTextureCoordsARB]; -uniform vec4 gl_EyePlaneR[gl_MaxTextureCoordsARB]; -uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoordsARB]; -uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoordsARB]; -uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoordsARB]; -uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoordsARB]; -uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoordsARB]; - -// -// Fog p. 161 -// - -struct gl_FogParameters { - vec4 color; - float density; - float start; - float end; - float scale; // 1 / (gl_FogEnd - gl_FogStart) -}; - -uniform gl_FogParameters gl_Fog; - -// -// The OpenGL Shading Language defines an assortment of built-in convenience functions for scalar -// and vector operations. Many of these built-in functions can be used in more than one type -// of shader, but some are intended to provide a direct mapping to hardware and so are available -// only for a specific type of shader. -// -// The built-in functions basically fall into three categories: -// -// • They expose some necessary hardware functionality in a convenient way such as accessing -// a texture map. There is no way in the language for these functions to be emulated by a shader. -// -// • They represent a trivial operation (clamp, mix, etc.) that is very simple for the user -// to write, but they are very common and may have direct hardware support. It is a very hard -// problem for the compiler to map expressions to complex assembler instructions. -// -// • They represent an operation graphics hardware is likely to accelerate at some point. The -// trigonometry functions fall into this category. -// -// Many of the functions are similar to the same named ones in common C libraries, but they support -// vector input as well as the more traditional scalar input. -// -// Applications should be encouraged to use the built-in functions rather than do the equivalent -// computations in their own shader code since the built-in functions are assumed to be optimal -// (e.g., perhaps supported directly in hardware). -// -// User code can replace built-in functions with their own if they choose, by simply re-declaring -// and defining the same name and argument list. -// - -// -// Angle and Trigonometry Functions -// -// Function parameters specified as angle are assumed to be in units of radians. In no case will -// any of these functions result in a divide by zero error. If the divisor of a ratio is 0, then -// results will be undefined. -// -// These all operate component-wise. -// - -// -// Converts degrees to radians and returns the result, i.e., result = PI*deg/180. -// - -float radians (float deg) { - return 3.141593 * deg / 180.0; -} -vec2 radians (vec2 deg) { - return vec2 (radians (deg.x), radians (deg.y)); -} -vec3 radians (vec3 deg) { - return vec3 (radians (deg.x), radians (deg.y), radians (deg.z)); -} -vec4 radians (vec4 deg) { - return vec4 (radians (deg.x), radians (deg.y), radians (deg.z), radians (deg.w)); -} - -// -// Converts radians to degrees and returns the result, i.e., result = 180*rad/PI. -// - -float degrees (float rad) { - return 180.0 * rad / 3.141593; -} -vec2 degrees (vec2 rad) { - return vec2 (degrees (rad.x), degrees (rad.y)); -} -vec3 degrees (vec3 rad) { - return vec3 (degrees (rad.x), degrees (rad.y), degrees (rad.z)); -} -vec4 degrees (vec4 rad) { - return vec4 (degrees (rad.x), degrees (rad.y), degrees (rad.z), degrees (rad.w)); -} - -// -// The standard trigonometric sine function. -// -// XXX -float sin (float angle) { - return 0.0; -} -vec2 sin (vec2 angle) { - return vec2 (sin (angle.x), sin (angle.y)); -} -vec3 sin (vec3 angle) { - return vec3 (sin (angle.x), sin (angle.y), sin (angle.z)); -} -vec4 sin (vec4 angle) { - return vec4 (sin (angle.x), sin (angle.y), sin (angle.z), sin (angle.w)); -} - -// -// The standard trigonometric cosine function. -// - -float cos (float angle) { - return sin (angle + 1.5708); -} -vec2 cos (vec2 angle) { - return vec2 (cos (angle.x), cos (angle.y)); -} -vec3 cos (vec3 angle) { - return vec3 (cos (angle.x), cos (angle.y), cos (angle.z)); -} -vec4 cos (vec4 angle) { - return vec4 (cos (angle.x), cos (angle.y), cos (angle.z), cos (angle.w)); -} - -// -// The standard trigonometric tangent. -// - -float tan (float angle) { - return sin (angle) / cos (angle); -} -vec2 tan (vec2 angle) { - return vec2 (tan (angle.x), tan (angle.y)); -} -vec3 tan (vec3 angle) { - return vec3 (tan (angle.x), tan (angle.y), tan (angle.z)); -} -vec4 tan (vec4 angle) { - return vec4 (tan (angle.x), tan (angle.y), tan (angle.z), tan (angle.w)); -} - -// -// Arc sine. Returns an angle whose sine is x. The range of values returned by this function is -// [–PI/2, PI/2]. Results are undefined if |x| > 1. -// -// XXX -float asin (float x) { - return 0.0; -} -vec2 asin (vec2 x) { - return vec2 (asin (x.x), asin (x.y)); -} -vec3 asin (vec3 x) { - return vec3 (asin (x.x), asin (x.y), asin (x.z)); -} -vec4 asin (vec4 x) { - return vec4 (asin (x.x), asin (x.y), asin (x.z), asin (x.w)); -} - -// -// Arc cosine. Returns an angle whose cosine is x. The range of values returned by this function is -// [0, PI]. Results are undefined if |x| > 1. -// -// XXX -float acos (float x) { - return 0.0; -} -vec2 acos (vec2 x) { - return vec2 (acos (x.x), acos (x.y)); -} -vec3 acos (vec3 x) { - return vec3 (acos (x.x), acos (x.y), acos (x.z)); -} -vec4 acos (vec4 x) { - return vec4 (acos (x.x), acos (x.y), acos (x.z), acos (x.w)); -} - -// -// Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine -// what quadrant the angle is in. The range of values returned by this function is [–PI, PI]. -// Results are undefined if x and y are both 0. -// -// XXX -float atan (float x, float y) { - return 0.0; -} -vec2 atan (vec2 x, vec2 y) { - return vec2 (atan (x.x, y.x), atan (x.y, y.y)); -} -vec3 atan (vec3 x, vec3 y) { - return vec3 (atan (x.x, y.x), atan (x.y, y.y), atan (x.z, y.z)); -} -vec4 atan (vec4 x, vec4 y) { - return vec4 (atan (x.x, y.x), atan (x.y, y.y), atan (x.z, y.z), atan (x.w, y.w)); -} - -// -// Arc tangent. Returns an angle whose tangent is y_over_x. The range of values returned by this -// function is [–PI/2, PI/2]. -// -// XXX -float atan (float y_over_x) { - return 0.0; -} -vec2 atan (vec2 y_over_x) { - return vec2 (atan (y_over_x.x), atan (y_over_x.y)); -} -vec3 atan (vec3 y_over_x) { - return vec3 (atan (y_over_x.x), atan (y_over_x.y), atan (y_over_x.z)); -} -vec4 atan (vec4 y_over_x) { - return vec4 (atan (y_over_x.x), atan (y_over_x.y), atan (y_over_x.z), atan (y_over_x.w)); -} - -// -// Exponential Functions -// -// These all operate component-wise. -// - -// -// Returns x raised to the y power, i.e., x^y -// -// XXX -float pow (float x, float y) { - return 0.0; -} -vec2 pow (vec2 x, vec2 y) { - return vec2 (pow (x.x, y.x), pow (x.y, y.y)); -} -vec3 pow (vec3 x, vec3 y) { - return vec3 (pow (x.x, y.x), pow (x.y, y.y), pow (x.z, y.z)); -} -vec4 pow (vec4 x, vec4 y) { - return vec4 (pow (x.x, y.x), pow (x.y, y.y), pow (x.z, y.z), pow (x.w, y.w)); -} - -// -// Returns 2 raised to the x power, i.e., 2^x -// - -float exp2 (float x) { - return pow (2.0, x); -} -vec2 exp2 (vec2 x) { - return vec2 (exp2 (x.x), exp2 (x.y)); -} -vec3 exp2 (vec3 x) { - return vec3 (exp2 (x.x), exp2 (x.y), exp2 (x.z)); -} -vec4 exp2 (vec4 x) { - return vec4 (exp2 (x.x), exp2 (x.y), exp2 (x.z), exp2 (x.w)); -} - -// -// Returns the base 2 log of x, i.e., returns the value y which satisfies the equation x = 2^y -// -// XXX -float log2 (float x) { - return 0.0; -} -vec2 log2 (vec2 x) { - return vec2 (log2 (x.x), log2 (x.y)); -} -vec3 log2 (vec3 x) { - return vec3 (log2 (x.x), log2 (x.y), log2 (x.z)); -} -vec4 log2 (vec4 x) { - return vec4 (log2 (x.x), log2 (x.y), log2 (x.z), log2 (x.w)); -} - -// -// Returns the positive square root of x -// - -float sqrt (float x) { - return pow (x, 0.5); -} -vec2 sqrt (vec2 x) { - return vec2 (sqrt (x.x), sqrt (x.y)); -} -vec3 sqrt (vec3 x) { - return vec3 (sqrt (x.x), sqrt (x.y), sqrt (x.z)); -} -vec4 sqrt (vec4 x) { - return vec4 (sqrt (x.x), sqrt (x.y), sqrt (x.z), sqrt (x.w)); -} - -// -// Returns the reciprocal of the positive square root of x -// - -float inversesqrt (float x) { - return 1.0 / sqrt (x); -} -vec2 inversesqrt (vec2 x) { - return vec2 (inversesqrt (x.x), inversesqrt (x.y)); -} -vec3 inversesqrt (vec3 x) { - return vec3 (inversesqrt (x.x), inversesqrt (x.y), inversesqrt (x.z)); -} -vec4 inversesqrt (vec4 x) { - return vec4 (inversesqrt (x.x), inversesqrt (x.y), inversesqrt (x.z), inversesqrt (x.w)); -} - -// -// Common Functions -// -// These all operate component-wise. -// - -// -// Returns x if x >= 0, otherwise it returns –x -// - -float abs (float x) { - return x >= 0.0 ? x : -x; -} -vec2 abs (vec2 x) { - return vec2 (abs (x.x), abs (x.y)); -} -vec3 abs (vec3 x) { - return vec3 (abs (x.x), abs (x.y), abs (x.z)); -} -vec4 abs (vec4 x) { - return vec4 (abs (x.x), abs (x.y), abs (x.z), abs (x.w)); -} - -// -// Returns 1.0 if x > 0, 0.0 if x = 0, or –1.0 if x < 0 -// - -float sign (float x) { - return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : 0.0; -} -vec2 sign (vec2 x) { - return vec2 (sign (x.x), sign (x.y)); -} -vec3 sign (vec3 x) { - return vec3 (sign (x.x), sign (x.y), sign (x.z)); -} -vec4 sign (vec4 x) { - return vec4 (sign (x.x), sign (x.y), sign (x.z), sign (x.w)); -} - -// -// Returns a value equal to the nearest integer that is less than or equal to x -// -// XXX -float floor (float x) { - return 0.0; -} -vec2 floor (vec2 x) { - return vec2 (floor (x.x), floor (x.y)); -} -vec3 floor (vec3 x) { - return vec3 (floor (x.x), floor (x.y), floor (x.z)); -} -vec4 floor (vec4 x) { - return vec4 (floor (x.x), floor (x.y), floor (x.z), floor (x.w)); -} - -// -// Returns a value equal to the nearest integer that is greater than or equal to x -// -// XXX -float ceil (float x) { - return 0.0; -} -vec2 ceil (vec2 x) { - return vec2 (ceil (x.x), ceil (x.y)); -} -vec3 ceil (vec3 x) { - return vec3 (ceil (x.x), ceil (x.y), ceil (x.z)); -} -vec4 ceil (vec4 x) { - return vec4 (ceil (x.x), ceil (x.y), ceil (x.z), ceil (x.w)); -} - -// -// Returns x – floor (x) -// - -float fract (float x) { - return x - floor (x); -} -vec2 fract (vec2 x) { - return vec2 (fract (x.x), fract (x.y)); -} -vec3 fract (vec3 x) { - return vec3 (fract (x.x), fract (x.y), fract (x.z)); -} -vec4 fract (vec4 x) { - return vec4 (fract (x.x), fract (x.y), fract (x.z), fract (x.w)); -} - -// -// Modulus. Returns x – y * floor (x/y) -// - -float mod (float x, float y) { - return x - y * floor (x / y); -} -vec2 mod (vec2 x, float y) { - return vec2 (mod (x.x, y), mod (x.y, y)); -} -vec3 mod (vec3 x, float y) { - return vec3 (mod (x.x, y), mod (x.y, y), mod (x.z, y)); -} -vec4 mod (vec4 x, float y) { - return vec4 (mod (x.x, y), mod (x.y, y), mod (x.z, y), mod (x.w, y)); -} -vec2 mod (vec2 x, vec2 y) { - return vec2 (mod (x.x, y.x), mod (x.y, y.y)); -} -vec3 mod (vec3 x, vec3 y) { - return vec3 (mod (x.x, y.x), mod (x.y, y.y), mod (x.z, y.z)); -} -vec4 mod (vec4 x, vec4 y) { - return vec4 (mod (x.x, y.x), mod (x.y, y.y), mod (x.z, y.z), mod (x.w, y.w)); -} - -// -// Returns y if y < x, otherwise it returns x -// - -float min (float x, float y) { - return y < x ? y : x; -} -vec2 min (vec2 x, float y) { - return vec2 (min (x.x, y), min (x.y, y)); -} -vec3 min (vec3 x, float y) { - return vec3 (min (x.x, y), min (x.y, y), min (x.z, y)); -} -vec4 min (vec4 x, float y) { - return vec4 (min (x.x, y), min (x.y, y), min (x.z, y), min (x.w, y)); -} -vec2 min (vec2 x, vec2 y) { - return vec2 (min (x.x, y.x), min (x.y, y.y)); -} -vec3 min (vec3 x, vec3 y) { - return vec3 (min (x.x, y.x), min (x.y, y.y), min (x.z, y.z)); -} -vec4 min (vec4 x, vec4 y) { - return vec4 (min (x.x, y.x), min (x.y, y.y), min (x.z, y.z), min (x.w, y.w)); -} - -// -// Returns y if x < y, otherwise it returns x -// - -float max (float x, float y) { - return min (y, x); -} -vec2 max (vec2 x, float y) { - return vec2 (max (x.x, y), max (x.y, y)); -} -vec3 max (vec3 x, float y) { - return vec3 (max (x.x, y), max (x.y, y), max (x.z, y)); -} -vec4 max (vec4 x, float y) { - return vec4 (max (x.x, y), max (x.y, y), max (x.z, y), max (x.w, y)); -} -vec2 max (vec2 x, vec2 y) { - return vec2 (max (x.x, y.x), max (x.y, y.y)); -} -vec3 max (vec3 x, vec3 y) { - return vec3 (max (x.x, y.x), max (x.y, y.y), max (x.z, y.z)); -} -vec4 max (vec4 x, vec4 y) { - return vec4 (max (x.x, y.x), max (x.y, y.y), max (x.z, y.z), max (x.w, y.w)); -} - -// -// Returns min (max (x, minVal), maxVal) -// -// Note that colors and depths written by fragment shaders will be clamped by the implementation -// after the fragment shader runs. -// - -float clamp (float x, float minVal, float maxVal) { - return min (max (x, minVal), maxVal); -} -vec2 clamp (vec2 x, float minVal, float maxVal) { - return vec2 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal)); -} -vec3 clamp (vec3 x, float minVal, float maxVal) { - return vec3 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal), - clamp (x.z, minVal, maxVal)); -} -vec4 clamp (vec4 x, float minVal, float maxVal) { - return vec4 (clamp (x.x, minVal, maxVal), clamp (x.y, minVal, maxVal), - clamp (x.z, minVal, maxVal), clamp (x.w, minVal, maxVal)); -} -vec2 clamp (vec2 x, vec2 minVal, vec2 maxVal) { - return vec2 (clamp (x.x, minVal.x, maxVal.x), clamp (x.y, minVal.y, maxVal.y)); -} -vec3 clamp (vec3 x, vec3 minVal, vec3 maxVal) { - return vec3 (clamp (x.x, minVal.x, maxVal.x), clamp (x.y, minVal.y, maxVal.y), - clamp (x.z, minVal.z, maxVal.z)); -} -vec4 clamp (vec4 x, vec4 minVal, vec4 maxVal) { - return vec4 (clamp (x.x, minVal.x, maxVal.y), clamp (x.y, minVal.y, maxVal.y), - clamp (x.z, minVal.z, maxVal.z), clamp (x.w, minVal.w, maxVal.w)); -} - -// -// Returns x * (1 – a) + y * a, i.e., the linear blend of x and y -// - -float mix (float x, float y, float a) { - return x * (1.0 - a) + y * a; -} -vec2 mix (vec2 x, vec2 y, float a) { - return vec2 (mix (x.x, y.x, a), mix (x.y, y.y, a)); -} -vec3 mix (vec3 x, vec3 y, float a) { - return vec3 (mix (x.x, y.x, a), mix (x.y, y.y, a), mix (x.z, y.z, a)); -} -vec4 mix (vec4 x, vec4 y, float a) { - return vec4 (mix (x.x, y.x, a), mix (x.y, y.y, a), mix (x.z, y.z, a), mix (x.w, y.w, a)); -} -vec2 mix (vec2 x, vec2 y, vec2 a) { - return vec2 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y)); -} -vec3 mix (vec3 x, vec3 y, vec3 a) { - return vec3 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y), mix (x.z, y.z, a.z)); -} -vec4 mix (vec4 x, vec4 y, vec4 a) { - return vec4 (mix (x.x, y.x, a.x), mix (x.y, y.y, a.y), mix (x.z, y.z, a.z), - mix (x.w, y.w, a.w)); -} - -// -// Returns 0.0 if x <= edge, otherwise it returns 1.0 -// - -float step (float edge, float x) { - return x <= edge ? 0.0 : 1.0; -} -vec2 step (float edge, vec2 x) { - return vec2 (step (edge, x.x), step (edge, x.y)); -} -vec3 step (float edge, vec3 x) { - return vec3 (step (edge, x.x), step (edge, x.y), step (edge, x.z)); -} -vec4 step (float edge, vec4 x) { - return vec4 (step (edge, x.x), step (edge, x.y), step (edge, x.z), step (edge, x.w)); -} -vec2 step (vec2 edge, vec2 x) { - return vec2 (step (edge.x, x.x), step (edge.y, x.y)); -} -vec3 step (vec3 edge, vec3 x) { - return vec3 (step (edge.x, x.x), step (edge.y, x.y), step (edge.z, x.z)); -} -vec4 step (vec4 edge, vec4 x) { - return vec4 (step (edge.x, x.x), step (edge.y, x.y), step (edge.z, x.z), step (edge.w, x.w)); -} - -// -// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation -// between 0 and 1 when edge0 < x < edge1. This is useful in cases where you would want a threshold -// function with a smooth transition. This is equivalent to: -// t; -// t = clamp ((x – edge0) / (edge1 – edge0), 0, 1); -// return t * t * (3 – 2 * t); -// - -float smoothstep (float edge0, float edge1, float x) { - const float t = clamp ((x - edge0) / (edge1 - edge0), 0.0, 1.0); - return t * t * (3.0 - 2.0 * t); -} -vec2 smoothstep (float edge0, float edge1, vec2 x) { - return vec2 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y)); -} -vec3 smoothstep (float edge0, float edge1, vec3 x) { - return vec3 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y), - smoothstep (edge0, edge1, x.z)); -} -vec4 smoothstep (float edge0, float edge1, vec4 x) { - return vec4 (smoothstep (edge0, edge1, x.x), smoothstep (edge0, edge1, x.y), - smoothstep (edge0, edge1, x.z), smoothstep (edge0, edge1, x.w)); -} -vec2 smoothstep (vec2 edge0, vec2 edge1, vec2 x) { - return vec2 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y)); -} -vec3 smoothstep (vec3 edge0, vec3 edge1, vec3 x) { - return vec3 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y), - smoothstep (edge0.z, edge1.z, x.z)); -} -vec4 smoothstep (vec4 edge0, vec4 edge1, vec4 x) { - return vec4 (smoothstep (edge0.x, edge1.x, x.x), smoothstep (edge0.y, edge1.y, x.y), - smoothstep (edge0.z, edge1.z, x.z), smoothstep (edge0.w, edge1.w, x.w)); -} - -// -// Geometric Functions -// -// These operate on vectors as vectors, not component-wise. -// - -// -// Returns the dot product of x and y, i.e., result = x[0] * y[0] + x[1] * y[1] + ... -// - -float dot (float x, float y) { - return x * y; -} -float dot (vec2 x, vec2 y) { - return dot (x.x, y.x) + dot (x.y, y.y); -} -float dot (vec3 x, vec3 y) { - return dot (x.x, y.x) + dot (x.y, y.y) + dot (x.z, y.z); -} -float dot (vec4 x, vec4 y) { - return dot (x.x, y.x) + dot (x.y, y.y) + dot (x.z, y.z) + dot (x.w, y.w); -} - -// -// Returns the length of vector x, i.e., sqrt (x[0] * x[0] + x[1] * x[1] + ...) -// - -float length (float x) { - return sqrt (dot (x, x)); -} -float length (vec2 x) { - return sqrt (dot (x, x)); -} -float length (vec3 x) { - return sqrt (dot (x, x)); -} -float length (vec4 x) { - return sqrt (dot (x, x)); -} - -// -// Returns the distance between p0 and p1, i.e. length (p0 – p1) -// - -float distance (float x, float y) { - return length (x - y); -} -float distance (vec2 x, vec2 y) { - return length (x - y); -} -float distance (vec3 x, vec3 y) { - return length (x - y); -} -float distance (vec4 x, vec4 y) { - return length (x - y); -} - -// -// Returns the cross product of x and y, i.e. -// result.0 = x[1] * y[2] - y[1] * x[2] -// result.1 = x[2] * y[0] - y[2] * x[0] -// result.2 = x[0] * y[1] - y[0] * x[1] -// - -vec3 cross (vec3 x, vec3 y) { - return vec3 (x.y * y.z - y.y * x.z, x.z * y.x - y.z * x.x, x.x * y.y - y.x * x.y); -} - -// -// Returns a vector in the same direction as x but with a length of 1. -// - -float normalize (float x) { - return 1.0; -} -vec2 normalize (vec2 x) { - return x / length (x); -} -vec3 normalize (vec3 x) { - return x / length (x); -} -vec4 normalize (vec4 x) { - return x / length (x); -} - -// -// If dot (Nref, I) < 0 return N otherwise return –N -// - -float faceforward (float N, float I, float Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} -vec2 faceforward (vec2 N, vec2 I, vec2 Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} -vec3 faceforward (vec3 N, vec3 I, vec3 Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} -vec4 faceforward (vec4 N, vec4 I, vec4 Nref) { - return dot (Nref, I) < 0.0 ? N : -N; -} - -// -// For the incident vector I and surface orientation N, returns the reflection direction: -// result = I – 2 * dot (N, I) * N -// N should be normalized in order to achieve the desired result. - -float reflect (float I, float N) { - return I - 2.0 * dot (N, I) * N; -} -vec2 reflect (vec2 I, vec2 N) { - return I - 2.0 * dot (N, I) * N; -} -vec3 reflect (vec3 I, vec3 N) { - return I - 2.0 * dot (N, I) * N; -} -vec4 reflect (vec4 I, vec4 N) { - return I - 2.0 * dot (N, I) * N; -} - -// -// Matrix Functions -// - -// -// Multiply matrix x by matrix y component-wise, i.e., result[i][j] is the scalar product -// of x[i][j] and y[i][j]. -// Note: to get linear algebraic matrix multiplication, use the multiply operator (*). -// - -mat2 matrixCompMult (mat2 x, mat2 y) { - return mat2 ( - x[0].x * y[0].x, x[0].y * y[0].y, - x[1].x * y[1].x, x[1].y * y[1].y - ); -} -mat3 matrixCompMult (mat3 x, mat3 y) { - return mat4 ( - x[0].x * y[0].x, x[0].y * y[0].y, x[0].z * y[0].z, - x[1].x * y[1].x, x[1].y * y[1].y, x[1].z * y[1].z, - x[2].x * y[2].x, x[2].y * y[2].y, x[2].z * y[2].z - ); -} -mat4 matrixCompMult (mat4 x, mat4 y) { - return mat4 ( - x[0].x * y[0].x, x[0].y * y[0].y, x[0].z * y[0].z + x[0].w * y[0].w, - x[1].x * y[1].x, x[1].y * y[1].y, x[1].z * y[1].z + x[1].w * y[1].w, - x[2].x * y[2].x, x[2].y * y[2].y, x[2].z * y[2].z + x[2].w * y[2].w, - x[3].x * y[3].x, x[3].y * y[3].y, x[3].z * y[3].z + x[3].w * y[3].w - ); -} - -// -// Vector Relational Functions -// -// Relational and equality operators (<, <=, >, >=, ==, !=) are defined (or reserved) to produce -// scalar Boolean results. -// - -// -// Returns the component-wise compare of x < y. -// - -bvec2 lessThan (vec2 x, vec2 y) { - return bvec2 (x.x < y.x, x.y < y.y); -} -bvec3 lessThan (vec3 x, vec3 y) { - return bvec3 (x.x < y.x, x.y < y.y, x.z < y.z); -} -bvec4 lessThan (vec4 x, vec4 y) { - return bvec4 (x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w); -} -bvec2 lessThan (ivec2 x, ivec2 y) { - return bvec2 (x.x < y.x, x.y < y.y); -} -bvec3 lessThan (ivec3 x, ivec3 y) { - return bvec3 (x.x < y.x, x.y < y.y, x.z < y.z); -} -bvec4 lessThan (ivec4 x, ivec4 y) { - return bvec4 (x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w); -} - -// -// Returns the component-wise compare of x <= y. -// - -bvec2 lessThanEqual (vec2 x, vec2 y) { - return bvec2 (x.x <= y.x, x.y <= y.y); -} -bvec3 lessThanEqual (vec3 x, vec3 y) { - return bvec3 (x.x <= y.x, x.y <= y.y, x.z <= y.z); -} -bvec4 lessThanEqual (vec4 x, vec4 y) { - return bvec4 (x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w); -} -bvec2 lessThanEqual (ivec2 x, ivec2 y) { - return bvec2 (x.x <= y.x, x.y <= y.y); -} -bvec3 lessThanEqual (ivec3 x, ivec3 y) { - return bvec3 (x.x <= y.x, x.y <= y.y, x.z <= y.z); -} -bvec4 lessThanEqual (ivec4 x, ivec4 y) { - return bvec4 (x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w); -} - -// -// Returns the component-wise compare of x > y. -// - -bvec2 greaterThan (vec2 x, vec2 y) { - return bvec2 (x.x > y.x, x.y > y.y); -} -bvec3 greaterThan (vec3 x, vec3 y) { - return bvec3 (x.x > y.x, x.y > y.y, x.z > y.z); -} -bvec4 greaterThan (vec4 x, vec4 y) { - return bvec4 (x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w); -} -bvec2 greaterThan (ivec2 x, ivec2 y) { - return bvec2 (x.x > y.x, x.y > y.y); -} -bvec3 greaterThan (ivec3 x, ivec3 y) { - return bvec3 (x.x > y.x, x.y > y.y, x.z > y.z); -} -bvec4 greaterThan (ivec4 x, ivec4 y) { - return bvec4 (x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w); -} - -// -// Returns the component-wise compare of x >= y. -// - -bvec2 greaterThanEqual (vec2 x, vec2 y) { - return bvec2 (x.x >= y.x, x.y >= y.y); -} -bvec3 greaterThanEqual (vec3 x, vec3 y) { - return bvec3 (x.x >= y.x, x.y >= y.y, x.z >= y.z); -} -bvec4 greaterThanEqual (vec4 x, vec4 y) { - return bvec4 (x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w); -} -bvec2 greaterThanEqual (ivec2 x, ivec2 y) { - return bvec2 (x.x >= y.x, x.y >= y.y); -} -bvec3 greaterThanEqual (ivec3 x, ivec3 y) { - return bvec3 (x.x >= y.x, x.y >= y.y, x.z >= y.z); -} -bvec4 greaterThanEqual (ivec4 x, ivec4 y) { - return bvec4 (x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w); -} - -// -// Returns the component-wise compare of x == y. -// - -bvec2 equal (vec2 x, vec2 y) { - return bvec2 (x.x == y.x, x.y == y.y); -} -bvec3 equal (vec3 x, vec3 y) { - return bvec3 (x.x == y.x, x.y == y.y, x.z == y.z); -} -bvec4 equal (vec4 x, vec4 y) { - return bvec4 (x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w); -} -bvec2 equal (ivec2 x, ivec2 y) { - return bvec2 (x.x == y.x, x.y == y.y); -} -bvec3 equal (ivec3 x, ivec3 y) { - return bvec3 (x.x == y.x, x.y == y.y, x.z == y.z); -} -bvec4 equal (ivec4 x, ivec4 y) { - return bvec4 (x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w); -} - -// -// Returns the component-wise compare of x != y. -// - -bvec2 notEqual (vec2 x, vec2 y) { - return bvec2 (x.x != y.x, x.y != y.y); -} -bvec3 notEqual (vec3 x, vec3 y) { - return bvec3 (x.x != y.x, x.y != y.y, x.z != y.z); -} -bvec4 notEqual (vec4 x, vec4 y) { - return (bvec4 (x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w); -} -bvec2 notEqual (ivec2 x, ivec2 y) { - return (bvec2 (x.x != y.x, x.y != y.y); -} -bvec3 notEqual (ivec3 x, ivec3 y) { - return (bvec3 (x.x != y.x, x.y != y.y, x.z != y.z); -} -bvec4 notEqual (ivec4 x, ivec4 y) { - return (bvec4 (x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w); -} - -// -// Returns true if any component of x is true. -// - -bool any (bvec2 x) { - return x.x || x.y; -} -bool any (bvec3 x) { - return x.x || x.y || x.z; -} -bool any (bvec4 x) { - return x.x || x.y || x.z || x.w; -} - -// -// Returns true only if all components of x are true. -// - -bool all (bvec2 x) { - return x.x && x.y; -} -bool all (bvec3 x) { - return x.x && x.y && x.z; -} -bool all (bvec4 x) { - return x.x && x.y && x.z && x.w; -} - -// -// Returns the component-wise logical complement of x. -// - -bvec2 not (bvec2 x) { - return bvec2 (!x.x, !x.y); -} -bvec3 not (bvec3 x) { - return bvec3 (!x.x, !x.y, !x.z); -} -bvec4 not (bvec4 x) { - return bvec4 (!x.x, !x.y, !x.z, !x.w); -} - -// -// Texture Lookup Functions -// -// Texture lookup functions are available to both vertex and fragment shaders. However, level -// of detail is not computed by fixed functionality for vertex shaders, so there are some -// differences in operation between vertex and fragment texture lookups. The functions in the table -// below provide access to textures through samplers, as set up through the OpenGL API. Texture -// properties such as size, pixel format, number of dimensions, filtering method, number of mip-map -// levels, depth comparison, and so on are also defined by OpenGL API calls. Such properties are -// taken into account as the texture is accessed via the built-in functions defined below. -// -// If a non-shadow texture call is made to a sampler whose texture has depth comparisons enabled, -// then results are undefined. If a shadow texture call is made to a sampler whose texture does not -// have depth comparisions enabled, the results are also undefined. -// -// In all functions below, the bias parameter is optional for fragment shaders. The bias parameter -// is not accepted in a vertex shader. For a fragment shader, if bias is present, it is added to -// the calculated level of detail prior to performing the texture access operation. If the bias -// parameter is not provided, then the implementation automatically selects level of detail: -// For a texture that is not mip-mapped, the texture is used directly. If it is mip-mapped and -// running in a fragment shader, the LOD computed by the implementation is used to do the texture -// lookup. If it is mip-mapped and running on the vertex shader, then the base texture is used. -// -// The built-ins suffixed with “Lod” are allowed only in a vertex shader. For the “Lod” functions, -// lod is directly used as the level of detail. -// - -// -// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate coord.s is divided by -// the last component of coord. -// -// XXX -vec4 texture1D (sampler1D sampler, float coord) { - return vec4 (0.0); -} -vec4 texture1DProj (sampler1D sampler, vec2 coord) { - return texture1D (sampler, coord.s / coord.t); -} -vec4 texture1DProj (sampler1D sampler, vec4 coord) { - return texture1D (sampler, coord.s / coord.q); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate (coord.s, coord.t) is -// divided by the last component of coord. The third component of coord is ignored for the vec4 -// coord variant. -// -// XXX -vec4 texture2D (sampler2D sampler, vec2 coord) { - return vec4 (0.0); -} -vec4 texture2DProj (sampler2D sampler, vec3 coord) { - return texture2D (sampler, vec2 (coord.s / coord.p, coord.t / coord.p)); -} -vec4 texture2DProj (sampler2D sampler, vec4 coord) { - return texture2D (sampler, vec2 (coord.s / coord.q, coord.t / coord.q)); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate is divided by coord.q. -// -// XXX -vec4 texture3D (sampler3D sampler, vec3 coord) { - return vec4 (0.0); -} -vec4 texture3DProj (sampler3D sampler, vec4 coord) { - return texture3D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q)); -} - -// -// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound -// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture -// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification. -// -// XXX -vec4 textureCube (samplerCube sampler, vec3 coord) { - return vec4 (0.0); -} - -// -// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound -// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd -// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a -// depth texture, or results are undefined. For the projective (“Proj”) version of each built-in, -// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The -// second component of coord is ignored for the “1D” variants. -// -// XXX -vec4 shadow1D (sampler1DShadow sampler, vec3 coord) { - return vec4 (0.0); -} -// XXX -vec4 shadow2D (sampler2DShadow sampler, vec3 coord) { - return vec4 (0.0); -} -vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord) { - return shadow1D (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q)); -} -vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord) { - return shadow2D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q)); -} - -// -// Noise Functions -// -// Noise functions are available to both fragment and vertex shaders. They are stochastic functions -// that can be used to increase visual complexity. Values returned by the following noise functions -// give the appearance of randomness, but are not truly random. The noise functions below are -// defined to have the following characteristics: -// -// • The return value(s) are always in the range [-1,1] -// • The return value(s) have an overall average of 0.0 -// • They are repeatable, in that a particular input value will always produce the same return value -// • They are statistically invariant under rotation (i.e., no matter how the domain is rotated, it -// has the same statistical character) -// • They have a statistical invariance under translation (i.e., no matter how the domain is -// translated, it has the same statistical character) -// • They typically give different results under translation. -// • They have a narrow bandpass limit in frequency (i.e., it has no visible features larger or -// smaller than a certain narrow size range) -// - -// -// Returns a 1D noise value based on the input value x. -// -// XXX -float noise1 (float x) { - return 0.0; -} -// XXX -float noise1 (vec2 x) { - return 0.0; -} -// XXX -float noise1 (vec3 x) { - return 0.0; -} -// XXX -float noise1 (vec4 x) { - return 0.0; -} - -// -// Returns a 2D noise value based on the input value x. -// -// XXX -vec2 noise2 (float x) { - return vec2 (0.0); -} -// XXX -vec2 noise2 (vec2 x) { - return vec2 (0.0); -} -// XXX -vec2 noise2 (vec3 x) { - return vec2 (0.0); -} -// XXX -vec2 noise2 (vec4 x) { - return vec2 (0.0); -} - -// -// Returns a 3D noise value based on the input value x. -// -// XXX -vec3 noise3 (float x) { - return vec3 (0.0); -} -// XXX -vec3 noise3 (vec2 x) { - return vec3 (0.0); -} -// XXX -vec3 noise3 (vec3 x) { - return vec3 (0.0); -} -// XXX -vec3 noise3 (vec4 x) { - return vec3 (0.0); -} - -// -// Returns a 4D noise value based on the input value x. -// -// XXX -vec4 noise4 (float x) { - return vec4 (0.0); -} -// XXX -vec4 noise4 (vec2 x) { - return vec4 (0.0); -} -// XXX -vec4 noise4 (vec3 x) { - return vec4 (0.0); -} -// XXX -vec4 noise4 (vec4 x) { - return vec4 (0.0); -} - + +// +// 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: +// 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/src/mesa/shader/slang_fragment_builtin.gc b/src/mesa/shader/slang_fragment_builtin.gc index 6ccf0e7c0fc..ec282924ecd 100755 --- a/src/mesa/shader/slang_fragment_builtin.gc +++ b/src/mesa/shader/slang_fragment_builtin.gc @@ -1,354 +1,366 @@ - -// -// TODO: -// - implement texture1D, texture2D, texture3D, textureCube, -// - implement shadow1D, shadow2D, -// - implement dFdx, dFdy, -// - -// -// From Shader Spec, ver. 1.051 -// -// The output of the fragment shader goes on to be processed by the fixed function operations at -// the back end of the OpenGL pipeline. Fragment shaders interface with the back end of the OpenGL -// pipeline using the built-in variables gl_FragColor and gl_FragDepth, or by executing the discard -// keyword. -// -// These variables may be written more than once within a fragment shader. If so, the last value -// assigned is the one used in the subsequent fixed function pipeline. The values written to these -// variables may be read back after writing them. Reading from these variables before writing them -// results in an undefined value. The fixed functionality computed depth for a fragment may be -// obtained by reading gl_FragCoord.z, described below. -// -// Writing to gl_FragColor specifies the fragment color that will be used by the subsequent fixed -// functionality pipeline. If subsequent fixed functionality consumes fragment color and an -// execution of a fragment shader does not write a value to gl_FragColor then the fragment color -// consumed is undefined. -// -// If the frame buffer is configured as a color index buffer then behavior is undefined when using -// a fragment shader. -// -// Writing to gl_FragDepth will establish the depth value for the fragment being processed. If -// depth buffering is enabled, and a shader does not write gl_FragDepth, then the fixed function -// value for depth will be used as the fragment’s depth value. If a shader statically assigns -// a value to gl_FragDepth, and there is an execution path through the shader that does not set -// gl_FragDepth, then the value of the fragment’s depth may be undefined for some executions of -// the shader. That is, if a shader statically writes gl_FragDepth, then it is responsible for -// always writing it. There is also no guarantee that a shader can compute the same depth value -// as the fixed function value; an implementation will provide invariant results within shaders -// computing depth with the same source-level expression, but invariance is not provided between -// shaders and fixed functionality. -// -// Writes to gl_FragColor and gl_FragDepth need not be clamped within a shader. The fixed -// functionality pipeline following the fragment shader will clamp these values. -// -// If a shader executes the discard keyword, the fragment is discarded, and the values of -// gl_FragDepth and gl_FragColor become irrelevant. -// -// The variable gl_FragCoord is available as a read-only variable from within fragment shaders -// and it holds the window relative coordinates x, y, z, and 1/w values for the fragment. This -// value is the result of the fixed functionality that interpolates primitives after vertex -// processing to generate fragments. The z component is the depth value that would be used for -// the fragment’s depth if a shader contained no writes to gl_FragDepth. This is useful for -// invariance if a shader conditionally computes gl_FragDepth but otherwise wants the fixed -// functionality fragment depth. -// -// The fragment shader has access to the read-only built-in variable gl_FrontFacing whose value -// is true if the fragment belongs to a front-facing primitive. One use of this is to emulate -// two-sided lighting by selecting one of two colors calculated by the vertex shader. -// -// The built-in variables that are accessible from a fragment shader are intrinsically given types -// as follows: -// - -vec4 gl_FragCoord; -bool gl_FrontFacing; -vec4 gl_FragColor; -float gl_FragDepth; - -// -// However, they do not behave like variables with no qualifier; their behavior is as described -// above. These built-in variables have global scope. -// - -// -// Unlike user-defined varying variables, the built-in varying variables don’t have a strict -// one-to-one correspondence between the vertex language and the fragment language. Two sets are -// provided, one for each language. Their relationship is described below. -// -// The following varying variables are available to read from in a fragment shader. The gl_Color -// and gl_SecondaryColor names are the same names as attributes passed to the vertex shader. -// However, there is no name conflict, because attributes are visible only in vertex shaders -// and the following are only visible in a fragment shader. -// - -varying vec4 gl_Color; -varying vec4 gl_SecondaryColor; -varying vec4 gl_TexCoord[]; // at most will be gl_MaxTextureCoordsARB -varying float gl_FogFragCoord; - -// -// The values in gl_Color and gl_SecondaryColor will be derived automatically by the system from -// gl_FrontColor, gl_BackColor, gl_FrontSecondaryColor, and gl_BackSecondaryColor based on which -// face is visible. If fixed functionality is used for vertex processing, then gl_FogFragCoord will -// either be the z-coordinate of the fragment in eye space, or the interpolation of the fog -// coordinate, as described in section 3.10 of the OpenGL 1.4 Specification. The gl_TexCoord[] -// values are the interpolated gl_TexCoord[] values from a vertex shader or the texture coordinates -// of any fixed pipeline based vertex functionality. -// -// Indices to the fragment shader gl_TexCoord array are as described above in the vertex shader -// text. -// - -// -// The OpenGL Shading Language defines an assortment of built-in convenience functions for scalar -// and vector operations. Many of these built-in functions can be used in more than one type -// of shader, but some are intended to provide a direct mapping to hardware and so are available -// only for a specific type of shader. -// -// The built-in functions basically fall into three categories: -// -// • They expose some necessary hardware functionality in a convenient way such as accessing -// a texture map. There is no way in the language for these functions to be emulated by a shader. -// -// • They represent a trivial operation (clamp, mix, etc.) that is very simple for the user -// to write, but they are very common and may have direct hardware support. It is a very hard -// problem for the compiler to map expressions to complex assembler instructions. -// -// • They represent an operation graphics hardware is likely to accelerate at some point. The -// trigonometry functions fall into this category. -// -// Many of the functions are similar to the same named ones in common C libraries, but they support -// vector input as well as the more traditional scalar input. -// -// Applications should be encouraged to use the built-in functions rather than do the equivalent -// computations in their own shader code since the built-in functions are assumed to be optimal -// (e.g., perhaps supported directly in hardware). -// -// User code can replace built-in functions with their own if they choose, by simply re-declaring -// and defining the same name and argument list. -// - -// -// Texture Lookup Functions -// -// Texture lookup functions are available to both vertex and fragment shaders. However, level -// of detail is not computed by fixed functionality for vertex shaders, so there are some -// differences in operation between vertex and fragment texture lookups. The functions in the table -// below provide access to textures through samplers, as set up through the OpenGL API. Texture -// properties such as size, pixel format, number of dimensions, filtering method, number of mip-map -// levels, depth comparison, and so on are also defined by OpenGL API calls. Such properties are -// taken into account as the texture is accessed via the built-in functions defined below. -// -// If a non-shadow texture call is made to a sampler whose texture has depth comparisons enabled, -// then results are undefined. If a shadow texture call is made to a sampler whose texture does not -// have depth comparisions enabled, the results are also undefined. -// -// In all functions below, the bias parameter is optional for fragment shaders. The bias parameter -// is not accepted in a vertex shader. For a fragment shader, if bias is present, it is added to -// the calculated level of detail prior to performing the texture access operation. If the bias -// parameter is not provided, then the implementation automatically selects level of detail: -// For a texture that is not mip-mapped, the texture is used directly. If it is mip-mapped and -// running in a fragment shader, the LOD computed by the implementation is used to do the texture -// lookup. If it is mip-mapped and running on the vertex shader, then the base texture is used. -// -// The built-ins suffixed with “Lod” are allowed only in a vertex shader. For the “Lod” functions, -// lod is directly used as the level of detail. -// - -// -// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate coord.s is divided by -// the last component of coord. -// -// XXX -vec4 texture1D (sampler1D sampler, float coord, float bias) { - return vec4 (0.0); -} -vec4 texture1DProj (sampler1D sampler, vec2 coord, float bias) { - return texture1D (sampler, coord.s / coord.t, bias); -} -vec4 texture1DProj (sampler1D sampler, vec4 coord, float bias) { - return texture1D (sampler, coord.s / coord.q, bias); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate (coord.s, coord.t) is -// divided by the last component of coord. The third component of coord is ignored for the vec4 -// coord variant. -// -// XXX -vec4 texture2D (sampler2D sampler, vec2 coord, float bias) { - return vec4 (0.0); -} -vec4 texture2DProj (sampler2D sampler, vec3 coord, float bias) { - return texture2D (sampler, vec2 (coord.s / coord.p, coord.t / coord.p), bias); -} -vec4 texture2DProj (sampler2D sampler, vec4 coord, float bias) { - return texture2D (sampler, vec2 (coord.s / coord.q, coord.s / coord.q), bias); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate is divided by coord.q. -// -// XXX -vec4 texture3D (sampler3D sampler, vec3 coord, float bias) { - return vec4 (0.0); -} -vec4 texture3DProj (sampler3D sampler, vec4 coord, float bias) { - return texture3DProj (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q), - bias); -} - -// -// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound -// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture -// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification. -// -// XXX -vec4 textureCube (samplerCube sampler, vec3 coord, float bias) { - return vec4 (0.0); -} - -// -// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound -// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd -// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a -// depth texture, or results are undefined. For the projective (“Proj”) version of each built-in, -// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The -// second component of coord is ignored for the “1D” variants. -// -// XXX -vec4 shadow1D (sampler1DShadow sampler, vec3 coord, float bias) { - return vec4 (0.0); -} -// XXX -vec4 shadow2D (sampler2DShadow sampler, vec3 coord, float bias) { - return vec4 (0.0); -} -vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord, float bias) { - return shadow1D (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q), bias); -} -vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord, float bias) { - return shadow2D (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q), bias); -} - -// -// Fragment processing functions are only available in shaders intended for use on the fragment -// processor. Derivatives may be computationally expensive and/or numerically unstable. Therefore, -// an OpenGL implementation may approximate the true derivatives by using a fast but not entirely -// accurate derivative computation. -// -// The expected behavior of a derivative is specified using forward/backward differencing. -// -// Forward differencing: -// -// F(x+dx) - F(x) ~ dFdx(x) * dx 1a -// dFdx(x) ~ (F(x+dx) - F(x)) / dx 1b -// -// Backward differencing: -// -// F(x-dx) - F(x) ~ -dFdx(x) * dx 2a -// dFdx(x) ~ (F(x) - F(x-dx)) / dx 2b -// -// With single-sample rasterization, dx <= 1.0 in equations 1b and 2b. For multi-sample -// rasterization, dx < 2.0 in equations 1b and 2b. -// -// dFdy is approximated similarly, with y replacing x. -// -// A GL implementation may use the above or other methods to perform the calculation, subject -// to the following conditions: -// -// 1) The method may use piecewise linear approximations. Such linear approximations imply that -// higher order derivatives, dFdx(dFdx(x)) and above, are undefined. -// -// 2) The method may assume that the function evaluated is continuous. Therefore derivatives within -// the body of a non-uniform conditional are undefined. -// -// 3) The method may differ per fragment, subject to the constraint that the method may vary by -// window coordinates, not screen coordinates. The invariance requirement described in section -// 3.1 of the OpenGL 1.4 specification is relaxed for derivative calculations, because -// the method may be a function of fragment location. -// -// Other properties that are desirable, but not required, are: -// -// 4) Functions should be evaluated within the interior of a primitive (interpolated, not -// extrapolated). -// -// 5) Functions for dFdx should be evaluated while holding y constant. Functions for dFdy should -// be evaluated while holding x constant. However, mixed higher order derivatives, like -// dFdx(dFdy(y)) and dFdy(dFdx(x)) are undefined. -// -// In some implementations, varying degrees of derivative accuracy may be obtained by providing -// GL hints (section 5.6 of the OpenGL 1.4 specification), allowing a user to make an image -// quality versus speed tradeoff. -// - -// -// Returns the derivative in x using local differencing for the input argument p. -// -// XXX -float dFdx (float p) { - return 0.0; -} -// XXX -vec2 dFdx (vec2 p) { - return vec2 (0.0); -} -// XXX -vec3 dFdx (vec3 p) { - return vec3 (0.0); -} -// XXX -vec4 dFdx (vec4 p) { - return vec4 (0.0); -} - -// -// Returns the derivative in y using local differencing for the input argument p. -// -// These two functions are commonly used to estimate the filter width used to anti-alias procedural -// textures.We are assuming that the expression is being evaluated in parallel on a SIMD array so -// that at any given point in time the value of the function is known at the grid points -// represented by the SIMD array. Local differencing between SIMD array elements can therefore -// be used to derive dFdx, dFdy, etc. -// -// XXX -float dFdy (float p) { - return 0.0; -} -// XXX -vec2 dFdy (vec2 p) { - return vec2 (0.0); -} -// XXX -vec3 dFdy (vec3 p) { - return vec3 (0.0); -} -// XXX -vec4 dFdy (vec4 p) { - return vec4 (0.0); -} - -// -// Returns the sum of the absolute derivative in x and y using local differencing for the input -// argument p, i.e.: -// -// return = abs (dFdx (p)) + abs (dFdy (p)); -// - -float fwidth (float p) { - return abs (dFdx (p)) + abs (dFdy (p)); -} -vec2 fwidth (vec2 p) { - return abs (dFdx (p)) + abs (dFdy (p)); -} -vec3 fwidth (vec3 p) { - return abs (dFdx (p)) + abs (dFdy (p)); -} -vec4 fwidth (vec4 p) { - return abs (dFdx (p)) + abs (dFdy (p)); -} - + +// +// 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: +// + +vec4 gl_FragCoord; +bool gl_FrontFacing; +vec4 gl_FragColor; +vec4 gl_FragData[gl_MaxDrawBuffers]; +float gl_FragDepth; + +// +// However, they do not behave like variables with no qualifier; their behavior is as described +// above. These built-in variables have global scope. +// + +// +// Unlike user-defined varying variables, the built-in varying variables don’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/src/mesa/shader/slang_vertex_builtin.gc b/src/mesa/shader/slang_vertex_builtin.gc index ed89be9808e..cb043623869 100755 --- a/src/mesa/shader/slang_vertex_builtin.gc +++ b/src/mesa/shader/slang_vertex_builtin.gc @@ -1,260 +1,262 @@ - -// -// TODO: -// - what to do with ftransform? can it stay in the current form? -// - implement texture1DLod, texture2DLod, texture3DLod, textureCubeLod, -// - implement shadow1DLod, shadow2DLod, -// - -// -// From Shader Spec, ver. 1.051 -// -// Some OpenGL operations still continue to occur in fixed functionality in between the vertex -// processor and the fragment processor. Other OpenGL operations continue to occur in fixed -// functionality after the fragment processor. Shaders communicate with the fixed functionality -// of OpenGL through the use of built-in variables. -// -// The variable gl_Position is available only in the vertex language and is intended for writing -// the homogeneous vertex position. All executions of a well-formed vertex shader must write -// a value into this variable. It can be written at any time during shader execution. It may also -// be read back by the shader after being written. This value will be used by primitive assembly, -// clipping, culling, and other fixed functionality operations that operate on primitives after -// vertex processing has occurred. Compilers may generate a diagnostic message if they detect -// gl_Position is not written, or read before being written, but not all such cases are detectable. -// Results are undefined if a vertex shader is executed and does not write gl_Position. -// -// The variable gl_PointSize is available only in the vertex language and is intended for a vertex -// shader to write the size of the point to be rasterized. It is measured in pixels. -// -// The variable gl_ClipVertex is available only in the vertex language and provides a place for -// vertex shaders to write the coordinate to be used with the user clipping planes. The user must -// ensure the clip vertex and user clipping planes are defined in the same coordinate space. User -// clip planes work properly only under linear transform. It is undefined what happens under -// non-linear transform. -// -// These built-in vertex shader variables for communicating with fixed functionality are -// intrinsically declared with the following types: -// - -vec4 gl_Position; // must be written to -float gl_PointSize; // may be written to -vec4 gl_ClipVertex; // may be written to - -// -// If gl_PointSize or gl_ClipVertex are not written to, their values are undefined. Any of these -// variables can be read back by the shader after writing to them, to retrieve what was written. -// Reading them before writing them results in undefined behavior. If they are written more than -// once, it is the last value written that is consumed by the subsequent operations. -// -// These built-in variables have global scope. -// - -// -// The following attribute names are built into the OpenGL vertex language and can be used from -// within a vertex shader to access the current values of attributes declared by OpenGL. All page -// numbers and notations are references to the OpenGL 1.4 specification. -// - -// -// Vertex Attributes, p. 19. -// - -attribute vec4 gl_Color; -attribute vec4 gl_SecondaryColor; -attribute vec3 gl_Normal; -attribute vec4 gl_Vertex; -attribute vec4 gl_MultiTexCoord0; -attribute vec4 gl_MultiTexCoord1; -attribute vec4 gl_MultiTexCoord2; -attribute vec4 gl_MultiTexCoord3; -attribute vec4 gl_MultiTexCoord4; -attribute vec4 gl_MultiTexCoord5; -attribute vec4 gl_MultiTexCoord6; -attribute vec4 gl_MultiTexCoord7; -attribute float gl_FogCoord; - -// -// Unlike user-defined varying variables, the built-in varying variables don’t have a strict -// one-to-one correspondence between the vertex language and the fragment language. Two sets are -// provided, one for each language. Their relationship is described below. -// -// The following built-in varying variables are available to write to in a vertex shader. -// A particular one should be written to if any functionality in a corresponding fragment shader -// or fixed pipeline uses it or state derived from it. Otherwise, behavior is undefined. -// - -varying vec4 gl_FrontColor; -varying vec4 gl_BackColor; -varying vec4 gl_FrontSecondaryColor; -varying vec4 gl_BackSecondaryColor; -varying vec4 gl_TexCoord[]; // at most will be gl_MaxTextureCoordsARB -varying float gl_FogFragCoord; - -// -// For gl_FogFragCoord, the value written will be used as the “c” value on page 160 of the -// OpenGL 1.4 Specification by the fixed functionality pipeline. For example, if the z-coordinate -// of the fragment in eye space is desired as “c”, then that's what the vertex shader should write -// into gl_FogFragCoord. -// -// As with all arrays, indices used to subscript gl_TexCoord must either be integral constant -// expressions, or this array must be re-declared by the shader with a size. The size can be -// at most gl_MaxTextureCoordsARB. Using indexes close to 0 may aid the implementation -// in preserving varying resources. -// - -// -// The OpenGL Shading Language defines an assortment of built-in convenience functions for scalar -// and vector operations. Many of these built-in functions can be used in more than one type -// of shader, but some are intended to provide a direct mapping to hardware and so are available -// only for a specific type of shader. -// -// The built-in functions basically fall into three categories: -// -// • They expose some necessary hardware functionality in a convenient way such as accessing -// a texture map. There is no way in the language for these functions to be emulated by a shader. -// -// • They represent a trivial operation (clamp, mix, etc.) that is very simple for the user -// to write, but they are very common and may have direct hardware support. It is a very hard -// problem for the compiler to map expressions to complex assembler instructions. -// -// • They represent an operation graphics hardware is likely to accelerate at some point. The -// trigonometry functions fall into this category. -// -// Many of the functions are similar to the same named ones in common C libraries, but they support -// vector input as well as the more traditional scalar input. -// -// Applications should be encouraged to use the built-in functions rather than do the equivalent -// computations in their own shader code since the built-in functions are assumed to be optimal -// (e.g., perhaps supported directly in hardware). -// -// User code can replace built-in functions with their own if they choose, by simply re-declaring -// and defining the same name and argument list. -// - -// -// Geometric Functions -// -// These operate on vectors as vectors, not component-wise. -// - -// -// For vertex shaders only. This function will ensure that the incoming vertex value will be -// transformed in a way that produces exactly the same result as would be produced by OpenGL’s -// fixed functionality transform. It is intended to be used to compute gl_Position, e.g., -// gl_Position = ftransform() -// This function should be used, for example, when an application is rendering the same geometry in -// separate passes, and one pass uses the fixed functionality path to render and another pass uses -// programmable shaders. -// - -vec4 ftransform () { - return gl_ModelViewProjectionMatrix * gl_Vertex; -} - -// -// Texture Lookup Functions -// -// Texture lookup functions are available to both vertex and fragment shaders. However, level -// of detail is not computed by fixed functionality for vertex shaders, so there are some -// differences in operation between vertex and fragment texture lookups. The functions in the table -// below provide access to textures through samplers, as set up through the OpenGL API. Texture -// properties such as size, pixel format, number of dimensions, filtering method, number of mip-map -// levels, depth comparison, and so on are also defined by OpenGL API calls. Such properties are -// taken into account as the texture is accessed via the built-in functions defined below. -// -// If a non-shadow texture call is made to a sampler whose texture has depth comparisons enabled, -// then results are undefined. If a shadow texture call is made to a sampler whose texture does not -// have depth comparisions enabled, the results are also undefined. -// -// In all functions below, the bias parameter is optional for fragment shaders. The bias parameter -// is not accepted in a vertex shader. For a fragment shader, if bias is present, it is added to -// the calculated level of detail prior to performing the texture access operation. If the bias -// parameter is not provided, then the implementation automatically selects level of detail: -// For a texture that is not mip-mapped, the texture is used directly. If it is mip-mapped and -// running in a fragment shader, the LOD computed by the implementation is used to do the texture -// lookup. If it is mip-mapped and running on the vertex shader, then the base texture is used. -// -// The built-ins suffixed with “Lod” are allowed only in a vertex shader. For the “Lod” functions, -// lod is directly used as the level of detail. -// - -// -// Use the texture coordinate coord to do a texture lookup in the 1D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate coord.s is divided by -// the last component of coord. -// -// XXX -vec4 texture1DLod (sampler1D sampler, float coord, float lod) { - return vec4 (0.0); -} -vec4 texture1DProjLod (sampler1D sampler, vec2 coord, float lod) { - return texture1DLod (sampler, coord.s / coord.t, lod); -} -vec4 texture1DProjLod (sampler1D sampler, vec4 coord, float lod) { - return texture1DLod (sampler, coord.s / coord.q, lod); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 2D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate (coord.s, coord.t) is -// divided by the last component of coord. The third component of coord is ignored for the vec4 -// coord variant. -// -// XXX -vec4 texture2DLod (sampler2D sampler, vec2 coord, float lod) { - return vec4 (0.0); -} -vec4 texture2DProjLod (sampler2D sampler, vec3 coord, float lod) { - return texture2DLod (sampler, vec2 (coord.s / coord.p, coord.t / coord.p), lod); -} -vec4 texture2DProjLod (sampler2D sampler, vec4 coord, float lod) { - return texture2DLod (sampler, vec2 (coord.s / coord.q, coord.t / coord.q), lod); -} - -// -// Use the texture coordinate coord to do a texture lookup in the 3D texture currently bound -// to sampler. For the projective (“Proj”) versions, the texture coordinate is divided by coord.q. -// -// XXX -vec4 texture3DLod (sampler3D sampler, vec3 coord, float lod) { - return vec4 (0.0); -} -vec4 texture3DProjLod (sampler3D sampler, vec4 coord, float lod) { - return texture3DLod (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.s / coord.q), - lod); -} - -// -// Use the texture coordinate coord to do a texture lookup in the cube map texture currently bound -// to sampler. The direction of coord is used to select which face to do a 2-dimensional texture -// lookup in, as described in section 3.8.6 in version 1.4 of the OpenGL specification. -// -// XXX -vec4 textureCubeLod (samplerCube sampler, vec3 coord, float lod) { - return vec4 (0.0); -} - -// -// Use texture coordinate coord to do a depth comparison lookup on the depth texture bound -// to sampler, as described in section 3.8.14 of version 1.4 of the OpenGL specification. The 3rd -// component of coord (coord.p) is used as the R value. The texture bound to sampler must be a -// depth texture, or results are undefined. For the projective (“Proj”) version of each built-in, -// the texture coordinate is divide by coord.q, giving a depth value R of coord.p/coord.q. The -// second component of coord is ignored for the “1D” variants. -// -// XXX -vec4 shadow1DLod (sampler1DShadow sampler, vec3 coord, float lod) { - return vec4 (0.0); -} -// XXX -vec4 shadow2DLod (sampler2DShadow sampler, vec3 coord, float lod) { - return vec4 (0.0); -} -vec4 shadow1DProjLod(sampler1DShadow sampler, vec4 coord, float lod) { - return shadow1DLod (sampler, vec3 (coord.s / coord.q, 0.0, coord.p / coord.q), lod); -} -vec4 shadow2DProjLod(sampler2DShadow sampler, vec4 coord, float lod) { - return shadow2DLod (sampler, vec3 (coord.s / coord.q, coord.t / coord.q, coord.p / coord.q), - lod); -} - + +// +// TODO: +// - what to do with ftransform? can it stay in the current form? +// - implement texture1DLod, texture2DLod, texture3DLod, textureCubeLod, +// - implement shadow1DLod, shadow2DLod, +// + +// +// From Shader Spec, ver. 1.10, rev. 59 +// +// Some OpenGL operations still continue to occur in fixed functionality in between the vertex +// processor and the fragment processor. Other OpenGL operations continue to occur in fixed +// functionality after the fragment processor. Shaders communicate with the fixed functionality +// of OpenGL through the use of built-in variables. +// +// The variable gl_Position is available only in the vertex language and is intended for writing +// the homogeneous vertex position. All executions of a well-formed vertex shader must write +// a value into this variable. It can be written at any time during shader execution. It may also +// be read back by the shader after being written. This value will be used by primitive assembly, +// clipping, culling, and other fixed functionality operations that operate on primitives after +// vertex processing has occurred. Compilers may generate a diagnostic message if they detect +// gl_Position is not written, or read before being written, but not all such cases are detectable. +// Results are undefined if a vertex shader is executed and does not write gl_Position. +// +// The variable gl_PointSize is available only in the vertex language and is intended for a vertex +// shader to write the size of the point to be rasterized. It is measured in pixels. +// +// The variable gl_ClipVertex is available only in the vertex language and provides a place for +// vertex shaders to write the coordinate to be used with the user clipping planes. The user must +// ensure the clip vertex and user clipping planes are defined in the same coordinate space. User +// clip planes work properly only under linear transform. It is undefined what happens under +// non-linear transform. +// +// These built-in vertex shader variables for communicating with fixed functionality are +// intrinsically declared with the following types: +// + +vec4 gl_Position; // must be written to +float gl_PointSize; // may be written to +vec4 gl_ClipVertex; // may be written to + +// +// If gl_PointSize or gl_ClipVertex are not written to, their values are undefined. Any of these +// variables can be read back by the shader after writing to them, to retrieve what was written. +// Reading them before writing them results in undefined behavior. If they are written more than +// once, it is the last value written that is consumed by the subsequent operations. +// +// These built-in variables have global scope. +// + +// +// The following attribute names are built into the OpenGL vertex language and can be used from +// within a vertex shader to access the current values of attributes declared by OpenGL. All page +// numbers and notations are references to the OpenGL 1.4 specification. +// + +// +// Vertex Attributes, p. 19. +// + +attribute vec4 gl_Color; +attribute vec4 gl_SecondaryColor; +attribute vec3 gl_Normal; +attribute vec4 gl_Vertex; +attribute vec4 gl_MultiTexCoord0; +attribute vec4 gl_MultiTexCoord1; +attribute vec4 gl_MultiTexCoord2; +attribute vec4 gl_MultiTexCoord3; +attribute vec4 gl_MultiTexCoord4; +attribute vec4 gl_MultiTexCoord5; +attribute vec4 gl_MultiTexCoord6; +attribute vec4 gl_MultiTexCoord7; +attribute float gl_FogCoord; + +// +// Unlike user-defined varying variables, the built-in varying variables don’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); +} + -- 2.30.2