path: root/src/mesa/shader/slang/MachineIndependent/Initialize.cpp

//
//Copyright (C) 2002-2004  3Dlabs Inc. Ltd.
//All rights reserved.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions
//are met:
//
//    Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
//    Redistributions in binary form must reproduce the above
//    copyright notice, this list of conditions and the following
//    disclaimer in the documentation and/or other materials provided
//    with the distribution.
//
//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//POSSIBILITY OF SUCH DAMAGE.
//

//
// Create strings that declare built-in definitions, add built-ins that
// cannot be expressed in the files, and establish mappings between 
// built-in functions and operators.
//

#include "../Include/intermediate.h"
#include "Initialize.h"
#include <assert.h>

void TBuiltIns::initialize(TBuiltInResource &resources)
{
    //
    // Initialize all the built-in strings for parsing.
    //
    TString BuiltInFunctions;
    TString BuiltInFunctionsVertex;
    TString BuiltInFunctionsFragment;
    TString StandardVertexVaryings;
    TString StandardFragmentVaryings;
    TString StandardVertexAttributes;
    TString StandardUniforms;

    {
        //============================================================================
        //
        // Prototypes for built-in functions seen by both vertex and fragment shaders.
        //
        //============================================================================

        TString& s = BuiltInFunctions;

        //
        // Angle and Trigonometric Functions.
        //
        s.append(TString("float radians(float degrees);"));
        s.append(TString("vec2  radians(vec2  degrees);"));
        s.append(TString("vec3  radians(vec3  degrees);"));
        s.append(TString("vec4  radians(vec4  degrees);"));

        s.append(TString("float degrees(float radians);"));
        s.append(TString("vec2  degrees(vec2  radians);"));
        s.append(TString("vec3  degrees(vec3  radians);"));
        s.append(TString("vec4  degrees(vec4  radians);"));

        s.append(TString("float sin(float angle);"));
        s.append(TString("vec2  sin(vec2  angle);"));
        s.append(TString("vec3  sin(vec3  angle);"));
        s.append(TString("vec4  sin(vec4  angle);"));

        s.append(TString("float cos(float angle);"));
        s.append(TString("vec2  cos(vec2  angle);"));
        s.append(TString("vec3  cos(vec3  angle);"));
        s.append(TString("vec4  cos(vec4  angle);"));

        s.append(TString("float tan(float angle);"));
        s.append(TString("vec2  tan(vec2  angle);"));
        s.append(TString("vec3  tan(vec3  angle);"));
        s.append(TString("vec4  tan(vec4  angle);"));

        s.append(TString("float asin(float x);"));
        s.append(TString("vec2  asin(vec2  x);"));
        s.append(TString("vec3  asin(vec3  x);"));
        s.append(TString("vec4  asin(vec4  x);"));

        s.append(TString("float acos(float x);"));
        s.append(TString("vec2  acos(vec2  x);"));
        s.append(TString("vec3  acos(vec3  x);"));
        s.append(TString("vec4  acos(vec4  x);"));

        s.append(TString("float atan(float y, float x);"));
        s.append(TString("vec2  atan(vec2  y, vec2  x);"));
        s.append(TString("vec3  atan(vec3  y, vec3  x);"));
        s.append(TString("vec4  atan(vec4  y, vec4  x);"));

        s.append(TString("float atan(float y_over_x);"));
        s.append(TString("vec2  atan(vec2  y_over_x);"));
        s.append(TString("vec3  atan(vec3  y_over_x);"));
        s.append(TString("vec4  atan(vec4  y_over_x);"));

        //
        // Exponential Functions.
        //
        s.append(TString("float pow(float x, float y);"));
        s.append(TString("vec2  pow(vec2  x, vec2  y);"));
        s.append(TString("vec3  pow(vec3  x, vec3  y);"));
        s.append(TString("vec4  pow(vec4  x, vec4  y);"));

        s.append(TString("float exp(float x);"));
        s.append(TString("vec2  exp(vec2  x);"));
        s.append(TString("vec3  exp(vec3  x);"));
        s.append(TString("vec4  exp(vec4  x);"));

        s.append(TString("float log(float x);"));
        s.append(TString("vec2  log(vec2  x);"));
        s.append(TString("vec3  log(vec3  x);"));
        s.append(TString("vec4  log(vec4  x);"));

        s.append(TString("float exp2(float x);"));
        s.append(TString("vec2  exp2(vec2  x);"));
        s.append(TString("vec3  exp2(vec3  x);"));
        s.append(TString("vec4  exp2(vec4  x);"));

        s.append(TString("float log2(float x);"));
        s.append(TString("vec2  log2(vec2  x);"));
        s.append(TString("vec3  log2(vec3  x);"));
        s.append(TString("vec4  log2(vec4  x);"));

        s.append(TString("float sqrt(float x);"));
        s.append(TString("vec2  sqrt(vec2  x);"));
        s.append(TString("vec3  sqrt(vec3  x);"));
        s.append(TString("vec4  sqrt(vec4  x);"));

        s.append(TString("float inversesqrt(float x);"));
        s.append(TString("vec2  inversesqrt(vec2  x);"));
        s.append(TString("vec3  inversesqrt(vec3  x);"));
        s.append(TString("vec4  inversesqrt(vec4  x);"));

        //
        // Common Functions.
        //
        s.append(TString("float abs(float x);"));
        s.append(TString("vec2  abs(vec2  x);"));
        s.append(TString("vec3  abs(vec3  x);"));
        s.append(TString("vec4  abs(vec4  x);"));

        s.append(TString("float sign(float x);"));
        s.append(TString("vec2  sign(vec2  x);"));
        s.append(TString("vec3  sign(vec3  x);"));
        s.append(TString("vec4  sign(vec4  x);"));

        s.append(TString("float floor(float x);"));
        s.append(TString("vec2  floor(vec2  x);"));
        s.append(TString("vec3  floor(vec3  x);"));
        s.append(TString("vec4  floor(vec4  x);"));

        s.append(TString("float ceil(float x);"));
        s.append(TString("vec2  ceil(vec2  x);"));
        s.append(TString("vec3  ceil(vec3  x);"));
        s.append(TString("vec4  ceil(vec4  x);"));

        s.append(TString("float fract(float x);"));
        s.append(TString("vec2  fract(vec2  x);"));
        s.append(TString("vec3  fract(vec3  x);"));
        s.append(TString("vec4  fract(vec4  x);"));

        s.append(TString("float mod(float x, float y);"));
        s.append(TString("vec2  mod(vec2  x, float y);"));
        s.append(TString("vec3  mod(vec3  x, float y);"));
        s.append(TString("vec4  mod(vec4  x, float y);"));
        s.append(TString("vec2  mod(vec2  x, vec2  y);"));
        s.append(TString("vec3  mod(vec3  x, vec3  y);"));
        s.append(TString("vec4  mod(vec4  x, vec4  y);"));

        s.append(TString("float min(float x, float y);"));
        s.append(TString("vec2  min(vec2  x, float y);"));
        s.append(TString("vec3  min(vec3  x, float y);"));
        s.append(TString("vec4  min(vec4  x, float y);"));
        s.append(TString("vec2  min(vec2  x, vec2  y);"));
        s.append(TString("vec3  min(vec3  x, vec3  y);"));
        s.append(TString("vec4  min(vec4  x, vec4  y);"));

        s.append(TString("float max(float x, float y);"));
        s.append(TString("vec2  max(vec2  x, float y);"));
        s.append(TString("vec3  max(vec3  x, float y);"));
        s.append(TString("vec4  max(vec4  x, float y);"));
        s.append(TString("vec2  max(vec2  x, vec2  y);"));
        s.append(TString("vec3  max(vec3  x, vec3  y);"));
        s.append(TString("vec4  max(vec4  x, vec4  y);"));

        s.append(TString("float clamp(float x, float minVal, float maxVal);"));
        s.append(TString("vec2  clamp(vec2  x, float minVal, float maxVal);"));
        s.append(TString("vec3  clamp(vec3  x, float minVal, float maxVal);"));
        s.append(TString("vec4  clamp(vec4  x, float minVal, float maxVal);"));
        s.append(TString("vec2  clamp(vec2  x, vec2  minVal, vec2  maxVal);"));
        s.append(TString("vec3  clamp(vec3  x, vec3  minVal, vec3  maxVal);"));
        s.append(TString("vec4  clamp(vec4  x, vec4  minVal, vec4  maxVal);"));

        s.append(TString("float mix(float x, float y, float a);"));
        s.append(TString("vec2  mix(vec2  x, vec2  y, float a);"));
        s.append(TString("vec3  mix(vec3  x, vec3  y, float a);"));
        s.append(TString("vec4  mix(vec4  x, vec4  y, float a);"));
        s.append(TString("vec2  mix(vec2  x, vec2  y, vec2  a);"));
        s.append(TString("vec3  mix(vec3  x, vec3  y, vec3  a);"));
        s.append(TString("vec4  mix(vec4  x, vec4  y, vec4  a);"));

        s.append(TString("float step(float edge, float x);"));
        s.append(TString("vec2  step(vec2  edge, vec2  x);"));
        s.append(TString("vec3  step(vec3  edge, vec3  x);"));
        s.append(TString("vec4  step(vec4  edge, vec4  x);"));
        s.append(TString("vec2  step(float edge, vec2  x);"));
        s.append(TString("vec3  step(float edge, vec3  x);"));
        s.append(TString("vec4  step(float edge, vec4  x);"));

        s.append(TString("float smoothstep(float edge0, float edge1, float x);"));
        s.append(TString("vec2  smoothstep(vec2  edge0, vec2  edge1, vec2  x);"));
        s.append(TString("vec3  smoothstep(vec3  edge0, vec3  edge1, vec3  x);"));
        s.append(TString("vec4  smoothstep(vec4  edge0, vec4  edge1, vec4  x);"));
        s.append(TString("vec2  smoothstep(float edge0, float edge1, vec2  x);"));
        s.append(TString("vec3  smoothstep(float edge0, float edge1, vec3  x);"));
        s.append(TString("vec4  smoothstep(float edge0, float edge1, vec4  x);"));

        //
        // Geometric Functions.
        //
        s.append(TString("float length(float x);"));
        s.append(TString("float length(vec2  x);"));
        s.append(TString("float length(vec3  x);"));
        s.append(TString("float length(vec4  x);"));

        s.append(TString("float distance(float p0, float p1);"));
        s.append(TString("float distance(vec2  p0, vec2  p1);"));
        s.append(TString("float distance(vec3  p0, vec3  p1);"));
        s.append(TString("float distance(vec4  p0, vec4  p1);"));

        s.append(TString("float dot(float x, float y);"));
        s.append(TString("float dot(vec2  x, vec2  y);"));
        s.append(TString("float dot(vec3  x, vec3  y);"));
        s.append(TString("float dot(vec4  x, vec4  y);"));

        s.append(TString("vec3 cross(vec3 x, vec3 y);"));
        s.append(TString("float normalize(float x);"));
        s.append(TString("vec2  normalize(vec2  x);"));
        s.append(TString("vec3  normalize(vec3  x);"));
        s.append(TString("vec4  normalize(vec4  x);"));

        s.append(TString("float faceforward(float N, float I, float Nref);"));
        s.append(TString("vec2  faceforward(vec2  N, vec2  I, vec2  Nref);"));
        s.append(TString("vec3  faceforward(vec3  N, vec3  I, vec3  Nref);"));
        s.append(TString("vec4  faceforward(vec4  N, vec4  I, vec4  Nref);"));

        s.append(TString("float reflect(float I, float N);"));
        s.append(TString("vec2  reflect(vec2  I, vec2  N);"));
        s.append(TString("vec3  reflect(vec3  I, vec3  N);"));
        s.append(TString("vec4  reflect(vec4  I, vec4  N);"));

        s.append(TString("float refract(float I, float N, float eta);"));
        s.append(TString("vec2  refract(vec2  I, vec2  N, float eta);"));
        s.append(TString("vec3  refract(vec3  I, vec3  N, float eta);"));
        s.append(TString("vec4  refract(vec4  I, vec4  N, float eta);"));

        //
        // Matrix Functions.
        //
        s.append(TString("mat2 matrixCompMult(mat2 x, mat2 y);"));
        s.append(TString("mat3 matrixCompMult(mat3 x, mat3 y);"));
        s.append(TString("mat4 matrixCompMult(mat4 x, mat4 y);"));

        //
        // Vector relational functions.
        //
        s.append(TString("bvec2 lessThan(vec2 x, vec2 y);"));
        s.append(TString("bvec3 lessThan(vec3 x, vec3 y);"));
        s.append(TString("bvec4 lessThan(vec4 x, vec4 y);"));

        s.append(TString("bvec2 lessThan(ivec2 x, ivec2 y);"));
        s.append(TString("bvec3 lessThan(ivec3 x, ivec3 y);"));
        s.append(TString("bvec4 lessThan(ivec4 x, ivec4 y);"));

        s.append(TString("bvec2 lessThanEqual(vec2 x, vec2 y);"));
        s.append(TString("bvec3 lessThanEqual(vec3 x, vec3 y);"));
        s.append(TString("bvec4 lessThanEqual(vec4 x, vec4 y);"));

        s.append(TString("bvec2 lessThanEqual(ivec2 x, ivec2 y);"));
        s.append(TString("bvec3 lessThanEqual(ivec3 x, ivec3 y);"));
        s.append(TString("bvec4 lessThanEqual(ivec4 x, ivec4 y);"));

        s.append(TString("bvec2 greaterThan(vec2 x, vec2 y);"));
        s.append(TString("bvec3 greaterThan(vec3 x, vec3 y);"));
        s.append(TString("bvec4 greaterThan(vec4 x, vec4 y);"));

        s.append(TString("bvec2 greaterThan(ivec2 x, ivec2 y);"));
        s.append(TString("bvec3 greaterThan(ivec3 x, ivec3 y);"));
        s.append(TString("bvec4 greaterThan(ivec4 x, ivec4 y);"));

        s.append(TString("bvec2 greaterThanEqual(vec2 x, vec2 y);"));
        s.append(TString("bvec3 greaterThanEqual(vec3 x, vec3 y);"));
        s.append(TString("bvec4 greaterThanEqual(vec4 x, vec4 y);"));

        s.append(TString("bvec2 greaterThanEqual(ivec2 x, ivec2 y);"));
        s.append(TString("bvec3 greaterThanEqual(ivec3 x, ivec3 y);"));
        s.append(TString("bvec4 greaterThanEqual(ivec4 x, ivec4 y);"));

        s.append(TString("bvec2 equal(vec2 x, vec2 y);"));
        s.append(TString("bvec3 equal(vec3 x, vec3 y);"));
        s.append(TString("bvec4 equal(vec4 x, vec4 y);"));

        s.append(TString("bvec2 equal(ivec2 x, ivec2 y);"));
        s.append(TString("bvec3 equal(ivec3 x, ivec3 y);"));
        s.append(TString("bvec4 equal(ivec4 x, ivec4 y);"));

        s.append(TString("bvec2 equal(bvec2 x, bvec2 y);"));
        s.append(TString("bvec3 equal(bvec3 x, bvec3 y);"));
        s.append(TString("bvec4 equal(bvec4 x, bvec4 y);"));

        s.append(TString("bvec2 notEqual(vec2 x, vec2 y);"));
        s.append(TString("bvec3 notEqual(vec3 x, vec3 y);"));
        s.append(TString("bvec4 notEqual(vec4 x, vec4 y);"));

        s.append(TString("bvec2 notEqual(ivec2 x, ivec2 y);"));
        s.append(TString("bvec3 notEqual(ivec3 x, ivec3 y);"));
        s.append(TString("bvec4 notEqual(ivec4 x, ivec4 y);"));

        s.append(TString("bvec2 notEqual(bvec2 x, bvec2 y);"));
        s.append(TString("bvec3 notEqual(bvec3 x, bvec3 y);"));
        s.append(TString("bvec4 notEqual(bvec4 x, bvec4 y);"));

        s.append(TString("bool any(bvec2 x);"));
        s.append(TString("bool any(bvec3 x);"));
        s.append(TString("bool any(bvec4 x);"));

        s.append(TString("bool all(bvec2 x);"));
        s.append(TString("bool all(bvec3 x);"));
        s.append(TString("bool all(bvec4 x);"));

        s.append(TString("bvec2 not(bvec2 x);"));
        s.append(TString("bvec3 not(bvec3 x);"));
        s.append(TString("bvec4 not(bvec4 x);"));

        //
        // Texture Functions.
        //
        s.append(TString("vec4 texture1D(sampler1D sampler, float coord);"));
        s.append(TString("vec4 texture1D(sampler1D sampler, float coord, float bias);"));
        s.append(TString("vec4 texture1DProj(sampler1D sampler, vec2 coord);"));
        s.append(TString("vec4 texture1DProj(sampler1D sampler, vec2 coord, float bias);"));
        s.append(TString("vec4 texture1DProj(sampler1D sampler, vec4 coord);"));
        s.append(TString("vec4 texture1DProj(sampler1D sampler, vec4 coord, float bias);"));
        s.append(TString("vec4 texture1DLod(sampler1D sampler, float coord, float lod);"));
        s.append(TString("vec4 texture1DProjLod(sampler1D sampler, vec2 coord, float lod);"));
        s.append(TString("vec4 texture1DProjLod(sampler1D sampler, vec4 coord, float lod);"));

        s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord);"));
        s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord, float bias);"));
        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord);"));
        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord, float bias);"));
        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord);"));
        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord, float bias);"));
        s.append(TString("vec4 texture2DLod(sampler2D sampler, vec2 coord, float lod);"));
        s.append(TString("vec4 texture2DProjLod(sampler2D sampler, vec3 coord, float lod);"));
        s.append(TString("vec4 texture2DProjLod(sampler2D sampler, vec4 coord, float lod);"));

        s.append(TString("vec4 texture3D(sampler3D sampler, vec3 coord);"));
        s.append(TString("vec4 texture3D(sampler3D sampler, vec3 coord, float bias);"));
        s.append(TString("vec4 texture3DProj(sampler3D sampler, vec4 coord);"));
        s.append(TString("vec4 texture3DProj(sampler3D sampler, vec4 coord, float bias);"));
        s.append(TString("vec4 texture3DLod(sampler3D sampler, vec3 coord, float lod);"));
        s.append(TString("vec4 texture3DProjLod(sampler3D sampler, vec4 coord, float lod);"));

        s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord);"));
        s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord, float bias);"));
        s.append(TString("vec4 textureCubeLod(samplerCube sampler, vec3 coord, float lod);"));

        s.append(TString("vec4 shadow1D(sampler1DShadow sampler, vec3 coord);"));
        s.append(TString("vec4 shadow1D(sampler1DShadow sampler, vec3 coord, float bias);"));

        s.append(TString("vec4 shadow2D(sampler2DShadow sampler, vec3 coord);"));
        s.append(TString("vec4 shadow2D(sampler2DShadow sampler, vec3 coord, float bias);"));

        s.append(TString("vec4 shadow1DProj(sampler1DShadow sampler, vec4 coord);"));
        s.append(TString("vec4 shadow1DProj(sampler1DShadow sampler, vec4 coord, float bias);"));

        s.append(TString("vec4 shadow2DProj(sampler2DShadow sampler, vec4 coord);"));
        s.append(TString("vec4 shadow2DProj(sampler2DShadow sampler, vec4 coord, float bias);"));

        s.append(TString("vec4 shadow1DLod(sampler1DShadow sampler, vec3 coord, float lod);"));
        s.append(TString("vec4 shadow2DLod(sampler2DShadow sampler, vec3 coord, float lod);"));

        s.append(TString("vec4 shadow1DProjLod(sampler1DShadow sampler, vec4 coord, float lod);"));
        s.append(TString("vec4 shadow2DProjLod(sampler2DShadow sampler, vec4 coord, float lod);"));

        //
        // Noise functions.
        //
        s.append(TString("float noise1(float x);"));
        s.append(TString("float noise1(vec2  x);"));
        s.append(TString("float noise1(vec3  x);"));
        s.append(TString("float noise1(vec4  x);"));

        s.append(TString("vec2 noise2(float x);"));
        s.append(TString("vec2 noise2(vec2  x);"));
        s.append(TString("vec2 noise2(vec3  x);"));
        s.append(TString("vec2 noise2(vec4  x);"));

        s.append(TString("vec3 noise3(float x);"));
        s.append(TString("vec3 noise3(vec2  x);"));
        s.append(TString("vec3 noise3(vec3  x);"));
        s.append(TString("vec3 noise3(vec4  x);"));

        s.append(TString("vec4 noise4(float x);"));
        s.append(TString("vec4 noise4(vec2  x);"));
        s.append(TString("vec4 noise4(vec3  x);"));
        s.append(TString("vec4 noise4(vec4  x);"));

        s.append(TString("\n"));
    }
    {
        //============================================================================
        //
        // Prototypes for built-in functions seen by vertex shaders only.
        //
        //============================================================================

        TString& s = BuiltInFunctionsVertex;

        //
        // Geometric Functions.
        //
        s.append(TString("vec4 ftransform();"));

        s.append(TString("\n"));
    }
    {
        //============================================================================
        //
        // Prototypes for built-in functions seen by fragment shaders only.
        //
        //============================================================================

        TString& s = BuiltInFunctionsFragment;

        s.append(TString("float dFdx(float p);"));
        s.append(TString("vec2  dFdx(vec2  p);"));
        s.append(TString("vec3  dFdx(vec3  p);"));
        s.append(TString("vec4  dFdx(vec4  p);"));

        s.append(TString("float dFdy(float p);"));
        s.append(TString("vec2  dFdy(vec2  p);"));
        s.append(TString("vec3  dFdy(vec3  p);"));
        s.append(TString("vec4  dFdy(vec4  p);"));

        s.append(TString("float fwidth(float p);"));
        s.append(TString("vec2  fwidth(vec2  p);"));
        s.append(TString("vec3  fwidth(vec3  p);"));
        s.append(TString("vec4  fwidth(vec4  p);"));

        s.append(TString("\n"));
    }
    {
        //============================================================================
        //
        // Standard Uniforms
        //
        //============================================================================

        TString& s = StandardUniforms;
       
        //
        // Implementation dependent constants.  The example values below
        // are the minimum values allowed for these maximums.
        //
        char builtInConstant[80];
        sprintf(builtInConstant, "const int  gl_MaxLights = %d;", resources.maxLights); // GL 1.0
        s.append(TString(builtInConstant));                            
        
        sprintf(builtInConstant, "const int  gl_MaxClipPlanes = %d;", resources.maxClipPlanes);  // GL 1.0
        s.append(TString(builtInConstant));
        
        sprintf(builtInConstant, "const int  gl_MaxTextureUnits = %d;", resources.maxTextureUnits); // GL 1.2
        s.append(TString(builtInConstant));
        
        sprintf(builtInConstant, "const int  gl_MaxTextureCoords = %d;", resources.maxTextureCoords); // ARB_fragment_program
        s.append(TString(builtInConstant));
        
        sprintf(builtInConstant, "const int  gl_MaxVertexAttribs = %d;", resources.maxVertexAttribs); // ARB_vertex_shader
        s.append(TString(builtInConstant));
        
        sprintf(builtInConstant, "const int  gl_MaxVertexUniformComponents = %d;", resources.maxVertexUniformComponents); // ARB_vertex_shader
        s.append(TString(builtInConstant));       
        
        sprintf(builtInConstant, "const int  gl_MaxVaryingFloats = %d;", resources.maxVaryingFloats); // ARB_vertex_shader
        s.append(TString(builtInConstant));        
        
        sprintf(builtInConstant, "const int  gl_MaxVertexTextureImageUnits = %d;", resources.maxVertexTextureImageUnits); // ARB_vertex_shader
        s.append(TString(builtInConstant));        
        
        sprintf(builtInConstant, "const int  gl_MaxCombinedTextureImageUnits = %d;", resources.maxCombinedTextureImageUnits); // ARB_vertex_shader
        s.append(TString(builtInConstant));        
        
        sprintf(builtInConstant, "const int  gl_MaxTextureImageUnits = %d;", resources.maxTextureImageUnits); // ARB_fragment_shader
        s.append(TString(builtInConstant));        
        
        sprintf(builtInConstant, "const int  gl_MaxFragmentUniformComponents = %d;", resources.maxFragmentUniformComponents); // ARB_fragment_shader
        s.append(TString(builtInConstant));        
        
        sprintf(builtInConstant, "const int  gl_MaxDrawBuffers = %d;", resources.maxDrawBuffers); // proposed ARB_draw_buffers
        s.append(TString(builtInConstant));

        //
        // OpenGL'uniform' state.  Page numbers are in reference to version
        // 1.4 of the OpenGL specification.
        //

        //
        // Matrix state. p. 31, 32, 37, 39, 40.
        //
        s.append(TString("uniform mat4  gl_ModelViewMatrix;"));
        s.append(TString("uniform mat4  gl_ProjectionMatrix;"));
        s.append(TString("uniform mat4  gl_ModelViewProjectionMatrix;"));
        s.append(TString("uniform mat4  gl_TextureMatrix[gl_MaxTextureCoords];"));

        //
        // Derived matrix state that provides inverse and transposed versions
        // of the matrices above.
        //
        s.append(TString("uniform mat3  gl_NormalMatrix;"));

        s.append(TString("uniform mat4  gl_ModelViewMatrixInverse;"));
        s.append(TString("uniform mat4  gl_ProjectionMatrixInverse;"));
        s.append(TString("uniform mat4  gl_ModelViewProjectionMatrixInverse;"));
        s.append(TString("uniform mat4  gl_TextureMatrixInverse[gl_MaxTextureCoords];"));

        s.append(TString("uniform mat4  gl_ModelViewMatrixTranspose;"));
        s.append(TString("uniform mat4  gl_ProjectionMatrixTranspose;"));
        s.append(TString("uniform mat4  gl_ModelViewProjectionMatrixTranspose;"));
        s.append(TString("uniform mat4  gl_TextureMatrixTranspose[gl_MaxTextureCoords];"));

        s.append(TString("uniform mat4  gl_ModelViewMatrixInverseTranspose;"));
        s.append(TString("uniform mat4  gl_ProjectionMatrixInverseTranspose;"));
        s.append(TString("uniform mat4  gl_ModelViewProjectionMatrixInverseTranspose;"));
        s.append(TString("uniform mat4  gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];"));

        //
        // Normal scaling p. 39.
        //
        s.append(TString("uniform float gl_NormalScale;"));

        //
        // Depth range in window coordinates, p. 33
        //
        s.append(TString("struct gl_DepthRangeParameters {"));
        s.append(TString("    float near;"));        // n
        s.append(TString("    float far;"));         // f
        s.append(TString("    float diff;"));        // f - n
        s.append(TString("};"));
        s.append(TString("uniform gl_DepthRangeParameters gl_DepthRange;"));

        //
        // Clip planes p. 42.
        //
        s.append(TString("uniform vec4  gl_ClipPlane[gl_MaxClipPlanes];"));

        //
        // Point Size, p. 66, 67.
        //
        s.append(TString("struct gl_PointParameters {"));
        s.append(TString("    float size;"));
        s.append(TString("    float sizeMin;"));
        s.append(TString("    float sizeMax;"));
        s.append(TString("    float fadeThresholdSize;"));
        s.append(TString("    float distanceConstantAttenuation;"));
        s.append(TString("    float distanceLinearAttenuation;"));
        s.append(TString("    float distanceQuadraticAttenuation;"));
        s.append(TString("};"));
         
        s.append(TString("uniform gl_PointParameters gl_Point;"));

        //
        // Material State p. 50, 55.
        //
        s.append(TString("struct gl_MaterialParameters {"));
        s.append(TString("    vec4  emission;"));    // Ecm
        s.append(TString("    vec4  ambient;"));     // Acm
        s.append(TString("    vec4  diffuse;"));     // Dcm
        s.append(TString("    vec4  specular;"));    // Scm
        s.append(TString("    float shininess;"));   // Srm
        s.append(TString("};"));
        s.append(TString("uniform gl_MaterialParameters  gl_FrontMaterial;"));
        s.append(TString("uniform gl_MaterialParameters  gl_BackMaterial;"));

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

        s.append(TString("struct gl_LightSourceParameters {"));
        s.append(TString("    vec4  ambient;"));             // Acli
        s.append(TString("    vec4  diffuse;"));             // Dcli
        s.append(TString("    vec4  specular;"));            // Scli
        s.append(TString("    vec4  position;"));            // Ppli
        s.append(TString("    vec4  halfVector;"));          // Derived: Hi
        s.append(TString("    vec3  spotDirection;"));       // Sdli
        s.append(TString("    float spotExponent;"));        // Srli
        s.append(TString("    float spotCutoff;"));          // Crli
                                                             // (range: [0.0,90.0], 180.0)
        s.append(TString("    float spotCosCutoff;"));       // Derived: cos(Crli)
                                                             // (range: [1.0,0.0],-1.0)
        s.append(TString("    float constantAttenuation;")); // K0
        s.append(TString("    float linearAttenuation;"));   // K1
        s.append(TString("    float quadraticAttenuation;"));// K2
        s.append(TString("};"));

        s.append(TString("uniform gl_LightSourceParameters  gl_LightSource[gl_MaxLights];"));

        s.append(TString("struct gl_LightModelParameters {"));
        s.append(TString("    vec4  ambient;"));       // Acs
        s.append(TString("};"));

        s.append(TString("uniform gl_LightModelParameters  gl_LightModel;"));

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

        s.append(TString("struct gl_LightModelProducts {"));
        s.append(TString("    vec4  sceneColor;"));     // Derived. Ecm + Acm * Acs
        s.append(TString("};"));

        s.append(TString("uniform gl_LightModelProducts gl_FrontLightModelProduct;"));
        s.append(TString("uniform gl_LightModelProducts gl_BackLightModelProduct;"));

        s.append(TString("struct gl_LightProducts {"));
        s.append(TString("    vec4  ambient;"));        // Acm * Acli
        s.append(TString("    vec4  diffuse;"));        // Dcm * Dcli
        s.append(TString("    vec4  specular;"));       // Scm * Scli
        s.append(TString("};"));

        s.append(TString("uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];"));
        s.append(TString("uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];"));

        //
        // Textureg Environment and Generation, p. 152, p. 40-42.
        //
        s.append(TString("uniform vec4  gl_TextureEnvColor[gl_MaxTextureImageUnits];"));
        s.append(TString("uniform vec4  gl_EyePlaneS[gl_MaxTextureCoords];"));
        s.append(TString("uniform vec4  gl_EyePlaneT[gl_MaxTextureCoords];"));
        s.append(TString("uniform vec4  gl_EyePlaneR[gl_MaxTextureCoords];"));
        s.append(TString("uniform vec4  gl_EyePlaneQ[gl_MaxTextureCoords];"));
        s.append(TString("uniform vec4  gl_ObjectPlaneS[gl_MaxTextureCoords];"));
        s.append(TString("uniform vec4  gl_ObjectPlaneT[gl_MaxTextureCoords];"));
        s.append(TString("uniform vec4  gl_ObjectPlaneR[gl_MaxTextureCoords];"));
        s.append(TString("uniform vec4  gl_ObjectPlaneQ[gl_MaxTextureCoords];"));

        //
        // Fog p. 161
        //
        s.append(TString("struct gl_FogParameters {"));
        s.append(TString("    vec4  color;"));
        s.append(TString("    float density;"));
        s.append(TString("    float start;"));
        s.append(TString("    float end;"));
        s.append(TString("    float scale;"));   //  1 / (gl_FogEnd - gl_FogStart)
        s.append(TString("};"));
         
        s.append(TString("uniform gl_FogParameters gl_Fog;"));

        s.append(TString("\n"));
    }
    {
        //============================================================================
        //
        // Vertex attributes, p. 19.
        //
        //============================================================================

        TString& s = StandardVertexAttributes;

        s.append(TString("attribute vec4  gl_Color;"));
        s.append(TString("attribute vec4  gl_SecondaryColor;"));
        s.append(TString("attribute vec3  gl_Normal;"));
        s.append(TString("attribute vec4  gl_Vertex;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord0;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord1;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord2;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord3;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord4;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord5;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord6;"));
        s.append(TString("attribute vec4  gl_MultiTexCoord7;"));
        s.append(TString("attribute float gl_FogCoord;"));

        s.append(TString("\n"));
    }
    {
        //============================================================================
        //
        // Define the output varying interface from the vertex shader.
        //
        //============================================================================

        TString& s = StandardVertexVaryings;

        s.append(TString("varying vec4  gl_FrontColor;"));
        s.append(TString("varying vec4  gl_BackColor;"));
        s.append(TString("varying vec4  gl_FrontSecondaryColor;"));
        s.append(TString("varying vec4  gl_BackSecondaryColor;"));
        s.append(TString("varying vec4  gl_TexCoord[];"));
        s.append(TString("varying float gl_FogFragCoord;"));

        s.append(TString("\n"));
    }
    {
        //============================================================================
        //
        // Define the input varying interface to the fragment shader.
        //
        //============================================================================

        TString& s = StandardFragmentVaryings;

        s.append(TString("varying vec4  gl_Color;"));
        s.append(TString("varying vec4  gl_SecondaryColor;"));
        s.append(TString("varying vec4  gl_TexCoord[];"));
        s.append(TString("varying float gl_FogFragCoord;"));

        s.append(TString("\n"));
    }

    builtInStrings[EShLangFragment].push_back(BuiltInFunctions.c_str());
    builtInStrings[EShLangFragment].push_back(BuiltInFunctionsFragment);
    builtInStrings[EShLangFragment].push_back(StandardUniforms);
    builtInStrings[EShLangFragment].push_back(StandardFragmentVaryings);

    builtInStrings[EShLangVertex].push_back(BuiltInFunctions);
    builtInStrings[EShLangVertex].push_back(BuiltInFunctionsVertex);
    builtInStrings[EShLangVertex].push_back(StandardVertexVaryings);
    builtInStrings[EShLangVertex].push_back(StandardVertexAttributes);
    builtInStrings[EShLangVertex].push_back(StandardUniforms);
}

void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable, TBuiltInResource &resources)
{
    //
    // First, insert some special built-in variables that are not in 
    // the built-in header files.
    //
    switch(language) {

    case EShLangFragment: {
        symbolTable.insert(*new TVariable(NewPoolTString("gl_FrontFacing"), TType(EbtBool,  EvqFace, 1)));
        symbolTable.insert(*new TVariable(NewPoolTString("gl_FragCoord"),   TType(EbtFloat, EvqFragCoord,   4)));
        symbolTable.insert(*new TVariable(NewPoolTString("gl_FragColor"),   TType(EbtFloat, EvqFragColor,   4)));
        symbolTable.insert(*new TVariable(NewPoolTString("gl_FragDepth"),   TType(EbtFloat, EvqFragDepth,   1)));

            // Set up gl_FragData.  The array size.
            TType fragData(EbtFloat, EvqFragColor,   4, false, true);
            fragData.setArraySize(resources.maxDrawBuffers);
            symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"),    fragData));
        }
        break;

    case EShLangVertex:
        symbolTable.insert(*new TVariable(NewPoolTString("gl_Position"),    TType(EbtFloat, EvqPosition,    4)));
        symbolTable.insert(*new TVariable(NewPoolTString("gl_PointSize"),   TType(EbtFloat, EvqPointSize,   1)));
        symbolTable.insert(*new TVariable(NewPoolTString("gl_ClipVertex"),  TType(EbtFloat, EvqClipVertex,  4)));
        break;
	default: break;
    }

    //
    // Next, identify which built-ins from the already loaded headers have
    // a mapping to an operator.  Those that are not identified as such are
    // expected to be resolved through a library of functions, versus as
    // operations.
    //
    symbolTable.relateToOperator("not",              EOpVectorLogicalNot);

    symbolTable.relateToOperator("matrixCompMult",   EOpMul);
    symbolTable.relateToOperator("mod",              EOpMod);

    symbolTable.relateToOperator("equal",            EOpVectorEqual);
    symbolTable.relateToOperator("notEqual",         EOpVectorNotEqual);
    symbolTable.relateToOperator("lessThan",         EOpLessThan);
    symbolTable.relateToOperator("greaterThan",      EOpGreaterThan);
    symbolTable.relateToOperator("lessThanEqual",    EOpLessThanEqual);
    symbolTable.relateToOperator("greaterThanEqual", EOpGreaterThanEqual);
    
    symbolTable.relateToOperator("radians",      EOpRadians);
    symbolTable.relateToOperator("degrees",      EOpDegrees);
    symbolTable.relateToOperator("sin",          EOpSin);
    symbolTable.relateToOperator("cos",          EOpCos);
    symbolTable.relateToOperator("tan",          EOpTan);
    symbolTable.relateToOperator("asin",         EOpAsin);
    symbolTable.relateToOperator("acos",         EOpAcos);
    symbolTable.relateToOperator("atan",         EOpAtan);

    symbolTable.relateToOperator("pow",          EOpPow);
    symbolTable.relateToOperator("exp2",         EOpExp2);
    symbolTable.relateToOperator("log",          EOpLog);
    symbolTable.relateToOperator("exp",          EOpExp);
    symbolTable.relateToOperator("log2",         EOpLog2);
    symbolTable.relateToOperator("sqrt",         EOpSqrt);
    symbolTable.relateToOperator("inversesqrt",  EOpInverseSqrt);

    symbolTable.relateToOperator("abs",          EOpAbs);
    symbolTable.relateToOperator("sign",         EOpSign);
    symbolTable.relateToOperator("floor",        EOpFloor);
    symbolTable.relateToOperator("ceil",         EOpCeil);
    symbolTable.relateToOperator("fract",        EOpFract);
    symbolTable.relateToOperator("min",          EOpMin);
    symbolTable.relateToOperator("max",          EOpMax);
    symbolTable.relateToOperator("clamp",        EOpClamp);
    symbolTable.relateToOperator("mix",          EOpMix);
    symbolTable.relateToOperator("step",         EOpStep);
    symbolTable.relateToOperator("smoothstep",   EOpSmoothStep);

    symbolTable.relateToOperator("length",       EOpLength);
    symbolTable.relateToOperator("distance",     EOpDistance);
    symbolTable.relateToOperator("dot",          EOpDot);
    symbolTable.relateToOperator("cross",        EOpCross);
    symbolTable.relateToOperator("normalize",    EOpNormalize);
    symbolTable.relateToOperator("forward",      EOpFaceForward);
    symbolTable.relateToOperator("reflect",      EOpReflect);
    symbolTable.relateToOperator("refract",      EOpRefract);
    
    symbolTable.relateToOperator("any",          EOpAny);
    symbolTable.relateToOperator("all",          EOpAll);

    switch(language) {

    case EShLangVertex:
        break;
    
    case EShLangFragment:
        symbolTable.relateToOperator("dFdx",         EOpDPdx);             
        symbolTable.relateToOperator("dFdy",         EOpDPdy);             
        symbolTable.relateToOperator("fwidth",       EOpFwidth);

        break;

    case EShLangPack:
    case EShLangUnpack:
        symbolTable.relateToOperator("itof",         EOpItof);
        symbolTable.relateToOperator("ftoi",         EOpFtoi);
        symbolTable.relateToOperator("skipPixels",   EOpSkipPixels);
        symbolTable.relateToOperator("readInput",    EOpReadInput);
        symbolTable.relateToOperator("writePixel",   EOpWritePixel);
        symbolTable.relateToOperator("bitmapLSB",    EOpBitmapLsb);
        symbolTable.relateToOperator("bitmapMSB",    EOpBitmapMsb);
        symbolTable.relateToOperator("writeOutput",  EOpWriteOutput);
        symbolTable.relateToOperator("readPixel",    EOpReadPixel);
        break;
	default: assert (true && "Language not supported");
    }
}