2010-08-04 Kenneth Russell <kbr@google.com>
authorkbr@google.com <kbr@google.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 4 Aug 2010 19:31:44 +0000 (19:31 +0000)
committerkbr@google.com <kbr@google.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 4 Aug 2010 19:31:44 +0000 (19:31 +0000)
        Reviewed by Dimitri Glazkov.

        Update ANGLE to r352
        https://bugs.webkit.org/show_bug.cgi?id=43500

        Updated ANGLE to r352 (July 26, 2010). Built WebKit to test.

        * include/GLSLANG/ShaderLang.h:
        * src/compiler/Initialize.cpp:
        (BuiltInFunctionsCommon):
        (BuiltInFunctionsVertex):
        (BuiltInFunctionsFragment):
        (StandardUniforms):
        (DefaultPrecisionVertex):
        (DefaultPrecisionFragment):
        (BuiltInConstants):
        (TBuiltIns::initialize):
        (IdentifyBuiltIns):
        * src/compiler/Initialize.h:
        (TBuiltIns::getBuiltInStrings):
        * src/compiler/OutputGLSL.cpp:
        (TOutputGLSL::visitSelection):
        * src/compiler/ShHandle.h:
        (TCompiler::getLanguage):
        (TCompiler::getSpec):
        (TCompiler::getSymbolTable):
        (TCompiler::getInfoSink):
        * src/compiler/ShaderLang.cpp:
        (InitializeSymbolTable):
        (GenerateBuiltInSymbolTable):
        (ShInitialize):
        (ShConstructCompiler):
        (ShFinalize):
        (ShCompile):
        * src/compiler/SymbolTable.h:
        (TSymbolTable::atBuiltInLevel):
        (TSymbolTable::atGlobalLevel):
        (TSymbolTable::push):
        (TSymbolTable::getGlobalLevel):
        (TSymbolTable::currentLevel):
        * src/libGLESv2/Shader.cpp:
        (gl::Shader::Shader):
        (gl::Shader::compileToHLSL):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@64665 268f45cc-cd09-0410-ab3c-d52691b4dbfc

ANGLE/ChangeLog
ANGLE/include/GLSLANG/ShaderLang.h
ANGLE/src/compiler/Initialize.cpp
ANGLE/src/compiler/Initialize.h
ANGLE/src/compiler/OutputGLSL.cpp
ANGLE/src/compiler/ShHandle.h
ANGLE/src/compiler/ShaderLang.cpp
ANGLE/src/compiler/SymbolTable.h
ANGLE/src/libGLESv2/Shader.cpp

index 0251634a4cbee8807f1edf859dcd5fd970928174..1f578b5c8bff377f2da03b68d86bf84709f4faf8 100644 (file)
@@ -1,3 +1,49 @@
+2010-08-04  Kenneth Russell  <kbr@google.com>
+
+        Reviewed by Dimitri Glazkov.
+
+        Update ANGLE to r352
+        https://bugs.webkit.org/show_bug.cgi?id=43500
+
+        Updated ANGLE to r352 (July 26, 2010). Built WebKit to test.
+
+        * include/GLSLANG/ShaderLang.h:
+        * src/compiler/Initialize.cpp:
+        (BuiltInFunctionsCommon):
+        (BuiltInFunctionsVertex):
+        (BuiltInFunctionsFragment):
+        (StandardUniforms):
+        (DefaultPrecisionVertex):
+        (DefaultPrecisionFragment):
+        (BuiltInConstants):
+        (TBuiltIns::initialize):
+        (IdentifyBuiltIns):
+        * src/compiler/Initialize.h:
+        (TBuiltIns::getBuiltInStrings):
+        * src/compiler/OutputGLSL.cpp:
+        (TOutputGLSL::visitSelection):
+        * src/compiler/ShHandle.h:
+        (TCompiler::getLanguage):
+        (TCompiler::getSpec):
+        (TCompiler::getSymbolTable):
+        (TCompiler::getInfoSink):
+        * src/compiler/ShaderLang.cpp:
+        (InitializeSymbolTable):
+        (GenerateBuiltInSymbolTable):
+        (ShInitialize):
+        (ShConstructCompiler):
+        (ShFinalize):
+        (ShCompile):
+        * src/compiler/SymbolTable.h:
+        (TSymbolTable::atBuiltInLevel):
+        (TSymbolTable::atGlobalLevel):
+        (TSymbolTable::push):
+        (TSymbolTable::getGlobalLevel):
+        (TSymbolTable::currentLevel):
+        * src/libGLESv2/Shader.cpp:
+        (gl::Shader::Shader):
+        (gl::Shader::compileToHLSL):
+
 2010-08-03  Mark Rowe  <mrowe@apple.com>
 
         Rubber-stamped by Adele Peterson.
index b4d2f3cfcb6d515700dc11f8523d11c2a07ddf81..19e6df034d03fa019bbdab59eb68633e03568976 100644 (file)
@@ -70,7 +70,7 @@ typedef void* ShHandle;
 //
 // Driver calls these to create and destroy compiler objects.
 //
-ShHandle ShConstructCompiler(EShLanguage, EShSpec);  // one per shader
+ShHandle ShConstructCompiler(EShLanguage, EShSpec, const TBuiltInResource*);
 void ShDestruct(ShHandle);
 
 //
@@ -85,7 +85,6 @@ int ShCompile(
     const char* const shaderStrings[],
     const int numStrings,
     const EShOptimizationLevel,
-    const TBuiltInResource *resources,
     int debugOptions
     );
 
index ebd23fb5d5cee511d2c99cbd4f7755929cb7cac5..58c6162f32b749d593088e4fc9d7e2ec04b78115 100644 (file)
 
 #include "compiler/intermediate.h"
 
-void TBuiltIns::initialize()
+//============================================================================
+//
+// Prototypes for built-in functions seen by both vertex and fragment shaders.
+//
+//============================================================================
+static TString BuiltInFunctionsCommon()
 {
+    TString s;
+
     //
-    // Initialize all the built-in strings for parsing.
+    // Angle and Trigonometric Functions.
     //
-    TString BuiltInFunctions;
-    TString BuiltInFunctionsVertex;
-    TString BuiltInFunctionsFragment;
-    TString StandardUniforms;
-    TString VertexDefaultPrecision;
-    TString FragmentDefaultPrecision;
-
-    {
-        //============================================================================
-        //
-        // 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 texture2D(sampler2D sampler, vec2 coord);"));
-        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord);"));
-        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord);"));
-
-        s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord);"));
-
-        //
-        // 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();"));
-
-        //
-        // Texture Functions.
-        //
-        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 textureCubeLod(samplerCube sampler, vec3 coord, float lod);"));
-
-        s.append(TString("\n"));
-    }
-    {
-        //============================================================================
-        //
-        // Prototypes for built-in functions seen by fragment shaders only.
-        //
-        //============================================================================
-
-        TString& s = BuiltInFunctionsFragment;
-
-        //
-        // Texture Functions.
-        //
-        s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord, float bias);"));
-        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord, float bias);"));
-        s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord, float bias);"));
-
-        s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord, float bias);"));
-
-    // 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;
-
-        //
-        // Depth range in window coordinates
-        //
-        s.append(TString("struct gl_DepthRangeParameters {"));
-        s.append(TString("    highp float near;"));        // n
-        s.append(TString("    highp float far;"));         // f
-        s.append(TString("    highp float diff;"));        // f - n
-        s.append(TString("};"));
-        s.append(TString("uniform gl_DepthRangeParameters gl_DepthRange;"));
-
-        s.append(TString("\n"));
-    }
-    {
-        //============================================================================
-        //
-        // Default precision for vertex shaders.
-        //
-        //============================================================================
-
-        TString& s = VertexDefaultPrecision;
-
-        s.append(TString("precision highp int;"));
-        s.append(TString("precision highp float;"));
-        s.append(TString("\n"));
-    }
-    {
-        //============================================================================
-        //
-        // Default precision for fragment shaders.
-        //
-        //============================================================================
-        
-        TString& s = FragmentDefaultPrecision;
-        
-        s.append(TString("precision mediump int;"));
-        // No default precision for float in fragment shaders
-        s.append(TString("\n"));
-    }
+    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);"));
 
-    builtInStrings[EShLangFragment].push_back(FragmentDefaultPrecision);
-    builtInStrings[EShLangFragment].push_back(BuiltInFunctions.c_str());
-    builtInStrings[EShLangFragment].push_back(BuiltInFunctionsFragment);
-    builtInStrings[EShLangFragment].push_back(StandardUniforms);
-    
-    builtInStrings[EShLangVertex].push_back(VertexDefaultPrecision);
-    builtInStrings[EShLangVertex].push_back(BuiltInFunctions);
-    builtInStrings[EShLangVertex].push_back(BuiltInFunctionsVertex);
-    builtInStrings[EShLangVertex].push_back(StandardUniforms);
+    //
+    // 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 texture2D(sampler2D sampler, vec2 coord);"));
+    s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord);"));
+    s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord);"));
+
+    s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord);"));
+
+    //
+    // 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"));
+    return s;
 }
 
-void TBuiltIns::initialize(const TBuiltInResource &resources)
+//============================================================================
+//
+// Prototypes for built-in functions seen by vertex shaders only.
+//
+//============================================================================
+static TString BuiltInFunctionsVertex()
 {
-    TStringStream builtIns;
+    TString s;
 
-    // Implementation dependent constants
-    builtIns << "const int gl_MaxVertexAttribs = " << resources.maxVertexAttribs << ";";
-    builtIns << "const int gl_MaxVertexUniformVectors = " << resources.maxVertexUniformVectors << ";";
+    //
+    // Geometric Functions.
+    //
+    //s.append(TString("vec4 ftransform();"));
+
+    //
+    // Texture Functions.
+    //
+    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 textureCubeLod(samplerCube sampler, vec3 coord, float lod);"));
+
+    s.append(TString("\n"));
+    return s;
+}
 
-    builtIns << "const int gl_MaxVaryingVectors = " << resources.maxVaryingVectors << ";";
-    builtIns << "const int gl_MaxVertexTextureImageUnits = " << resources.maxVertexTextureImageUnits << ";";
-    builtIns << "const int gl_MaxCombinedTextureImageUnits = " << resources.maxCombinedTextureImageUnits << ";";
-    builtIns << "const int gl_MaxTextureImageUnits = " << resources.maxTextureImageUnits << ";";
-    builtIns << "const int gl_MaxFragmentUniformVectors = " << resources.maxFragmentUniformVectors << ";";
-    builtIns << "const int gl_MaxDrawBuffers = " << resources.maxDrawBuffers << ";";
+//============================================================================
+//
+// Prototypes for built-in functions seen by fragment shaders only.
+//
+//============================================================================
+static TString BuiltInFunctionsFragment()
+{
+    TString s;
 
-    builtInStrings[EShLangFragment].push_back(builtIns.str());
-    builtInStrings[EShLangVertex].push_back(builtIns.str());
+    //
+    // Texture Functions.
+    //
+    s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord, float bias);"));
+    s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord, float bias);"));
+    s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord, float bias);"));
+    s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord, float bias);"));
+
+    //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"));
+    return s;
 }
 
-void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable)
+//============================================================================
+//
+// Standard uniforms.
+//
+//============================================================================
+static TString StandardUniforms()
+{
+    TString s;
+
+    //
+    // Depth range in window coordinates
+    //
+    s.append(TString("struct gl_DepthRangeParameters {"));
+    s.append(TString("    highp float near;"));        // n
+    s.append(TString("    highp float far;"));         // f
+    s.append(TString("    highp float diff;"));        // f - n
+    s.append(TString("};"));
+    s.append(TString("uniform gl_DepthRangeParameters gl_DepthRange;"));
+
+    s.append(TString("\n"));
+    return s;
+}
+
+//============================================================================
+//
+// Default precision for vertex shaders.
+//
+//============================================================================
+static TString DefaultPrecisionVertex()
+{
+    TString s;
+
+    s.append(TString("precision highp int;"));
+    s.append(TString("precision highp float;"));
+
+    s.append(TString("\n"));
+    return s;
+}
+
+//============================================================================
+//
+// Default precision for fragment shaders.
+//
+//============================================================================
+static TString DefaultPrecisionFragment()
+{
+    TString s;
+
+    s.append(TString("precision mediump int;"));
+    // No default precision for float in fragment shaders
+
+    s.append(TString("\n"));
+    return s;
+}
+
+//============================================================================
+//
+// Implementation dependent built-in constants.
+//
+//============================================================================
+static TString BuiltInConstants(const TBuiltInResource &resources)
+{
+    TStringStream s;
+
+    s << "const int gl_MaxVertexAttribs = " << resources.maxVertexAttribs << ";";
+    s << "const int gl_MaxVertexUniformVectors = " << resources.maxVertexUniformVectors << ";";
+
+    s << "const int gl_MaxVaryingVectors = " << resources.maxVaryingVectors << ";";
+    s << "const int gl_MaxVertexTextureImageUnits = " << resources.maxVertexTextureImageUnits << ";";
+    s << "const int gl_MaxCombinedTextureImageUnits = " << resources.maxCombinedTextureImageUnits << ";";
+    s << "const int gl_MaxTextureImageUnits = " << resources.maxTextureImageUnits << ";";
+    s << "const int gl_MaxFragmentUniformVectors = " << resources.maxFragmentUniformVectors << ";";
+    s << "const int gl_MaxDrawBuffers = " << resources.maxDrawBuffers << ";";
+
+    return s.str();
+}
+
+void TBuiltIns::initialize(EShLanguage language, EShSpec spec, const TBuiltInResource& resources)
+{
+    switch (language) {
+    case EShLangFragment:
+        builtInStrings.push_back(DefaultPrecisionFragment());
+        builtInStrings.push_back(BuiltInFunctionsCommon());
+        builtInStrings.push_back(BuiltInFunctionsFragment());
+        builtInStrings.push_back(StandardUniforms());
+        break;
+
+    case EShLangVertex:
+        builtInStrings.push_back(DefaultPrecisionVertex());
+        builtInStrings.push_back(BuiltInFunctionsCommon());
+        builtInStrings.push_back(BuiltInFunctionsVertex());
+        builtInStrings.push_back(StandardUniforms());
+        break;
+
+    default: assert(false && "Language not supported");
+    }
+
+    builtInStrings.push_back(BuiltInConstants(resources));
+}
+
+void IdentifyBuiltIns(EShLanguage language, EShSpec spec, const TBuiltInResource& resources, TSymbolTable& symbolTable)
 {
     //
     // 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_FragCoord"),                   TType(EbtFloat, EbpMedium, EvqFragCoord,   4)));
-            symbolTable.insert(*new TVariable(NewPoolTString("gl_FrontFacing"),                 TType(EbtBool,  EbpUndefined, EvqFrontFacing, 1)));
-            symbolTable.insert(*new TVariable(NewPoolTString("gl_FragColor"),                   TType(EbtFloat, EbpMedium, EvqFragColor,   4)));
-            symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData[gl_MaxDrawBuffers]"), TType(EbtFloat, EbpMedium, EvqFragData,    4)));
-            symbolTable.insert(*new TVariable(NewPoolTString("gl_PointCoord"),                  TType(EbtFloat, EbpMedium, EvqPointCoord,  2)));
-
-        }
+    case EShLangFragment:
+        symbolTable.insert(*new TVariable(NewPoolTString("gl_FragCoord"),                   TType(EbtFloat, EbpMedium, EvqFragCoord,   4)));
+        symbolTable.insert(*new TVariable(NewPoolTString("gl_FrontFacing"),                 TType(EbtBool,  EbpUndefined, EvqFrontFacing, 1)));
+        symbolTable.insert(*new TVariable(NewPoolTString("gl_FragColor"),                   TType(EbtFloat, EbpMedium, EvqFragColor,   4)));
+        symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData[gl_MaxDrawBuffers]"), TType(EbtFloat, EbpMedium, EvqFragData,    4)));
+        symbolTable.insert(*new TVariable(NewPoolTString("gl_PointCoord"),                  TType(EbtFloat, EbpMedium, EvqPointCoord,  2)));
         break;
 
     case EShLangVertex:
         symbolTable.insert(*new TVariable(NewPoolTString("gl_Position"),    TType(EbtFloat, EbpHigh, EvqPosition,    4)));
         symbolTable.insert(*new TVariable(NewPoolTString("gl_PointSize"),   TType(EbtFloat, EbpMedium, EvqPointSize,   1)));
         break;
-    default: break;
+
+    default: assert(false && "Language not supported");
     }
 
     //
@@ -578,27 +590,20 @@ void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable)
     symbolTable.relateToOperator("any",          EOpAny);
     symbolTable.relateToOperator("all",          EOpAll);
 
-    switch(language)
-    {
-    case EShLangVertex:
-        break;
-    case EShLangFragment:
-    // symbolTable.relateToOperator("dFdx",         EOpDPdx);     // OES_standard_derivatives extension
-    // symbolTable.relateToOperator("dFdy",         EOpDPdy);     // OES_standard_derivatives extension
-    // symbolTable.relateToOperator("fwidth",       EOpFwidth);   // OES_standard_derivatives extension
-        break;
-    default: assert(false && "Language not supported");
-    }
-}
-
-void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable, const TBuiltInResource &resources)
-{
-    //
-    // First, insert some special built-in variables that are not in 
-    // the built-in header files.
-    //
+    // Map language-specific operators.
+    switch(language) {\r
+    case EShLangVertex:\r
+        break;\r
+    case EShLangFragment:\r
+        //symbolTable.relateToOperator("dFdx",   EOpDPdx);    // OES_standard_derivatives extension\r
+        //symbolTable.relateToOperator("dFdy",   EOpDPdy);    // OES_standard_derivatives extension\r
+        //symbolTable.relateToOperator("fwidth", EOpFwidth);  // OES_standard_derivatives extension\r
+        break;\r
+    default: break;\r
+    }\r
+
+    // Finally add resource-specific variables.
     switch(language) {
-
     case EShLangFragment: {
             // Set up gl_FragData.  The array size.
             TType fragData(EbtFloat, EbpMedium, EvqFragColor,   4, false, true);
@@ -606,14 +611,7 @@ void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable, const TBu
             symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"),    fragData));
         }
         break;
-
     default: break;
     }
 }
 
-const char* GetPreprocessorBuiltinString()
-{
-    static const char *PreprocessorBuiltinString = "";
-
-    return PreprocessorBuiltinString;
-}
index 777742e781090321fc6b24ed7175f0fb9455ed97..03c9937958e9d5fd4efcb376b1dc0e85f28e7e3d 100644 (file)
@@ -17,19 +17,18 @@ typedef TVector<TString> TBuiltInStrings;
 
 class TBuiltIns {
 public:
-       POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
-       void initialize();
-       void initialize(const TBuiltInResource& resources);
-       TBuiltInStrings* getBuiltInStrings() { return builtInStrings; }
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
+
+    void initialize(EShLanguage language, EShSpec spec, const TBuiltInResource& resources);
+    const TBuiltInStrings& getBuiltInStrings() { return builtInStrings; }
+
 protected:
-       TBuiltInStrings builtInStrings[EShLangCount];
+    TBuiltInStrings builtInStrings;
 };
 
-void IdentifyBuiltIns(EShLanguage, TSymbolTable&);
-void IdentifyBuiltIns(EShLanguage, TSymbolTable&, const TBuiltInResource &resources);
-bool GenerateBuiltInSymbolTable(const TBuiltInResource* resources, TInfoSink&, TSymbolTable*, EShLanguage language = EShLangCount);
-bool InitializeSymbolTable(TBuiltInStrings* BuiltInStrings, EShLanguage language, TInfoSink& infoSink, const TBuiltInResource *resources, TSymbolTable*);
-const char* GetPreprocessorBuiltinString();
+void IdentifyBuiltIns(EShLanguage language, EShSpec spec, const TBuiltInResource& resources,
+                      TSymbolTable& symbolTable);
+
 extern "C" int InitPreprocessor(void);
 extern "C" int FinalizePreprocessor(void);
 
index 6f43524f1be1d31004bc884036a98a28996d58c8..486a27adc5b39436c074f04756a4732ec801f660 100644 (file)
@@ -391,13 +391,17 @@ bool TOutputGLSL::visitSelection(Visit visit, TIntermSelection* node)
 
     if (node->usesTernaryOperator())
     {
-        out << "(";
+        // Notice two brackets at the beginning and end. The outer ones
+        // encapsulate the whole ternary expression. This preserves the
+        // order of precedence when ternary expressions are used in a
+        // compound expression, i.e., c = 2 * (a < b ? 1 : 2).
+        out << "((";
         node->getCondition()->traverse(this);
         out << ") ? (";
         node->getTrueBlock()->traverse(this);
         out << ") : (";
         node->getFalseBlock()->traverse(this);
-        out << ")";
+        out << "))";
     }
     else
     {
index 48a17dd87cebc7026ff9668738b1c11d6b657874..5ef5d30cf8b40f13f81aeb86f14b87f593e2e7d4 100644 (file)
@@ -17,6 +17,7 @@
 #include "GLSLANG/ShaderLang.h"
 
 #include "compiler/InfoSink.h"
+#include "compiler/SymbolTable.h"
 
 class TCompiler;
 class TIntermNode;
@@ -40,18 +41,24 @@ public:
     TCompiler(EShLanguage l, EShSpec s) : language(l), spec(s) { }
     virtual ~TCompiler() { }
 
-    EShLanguage getLanguage() { return language; }
-    EShSpec getSpec() { return spec; }
-    virtual TInfoSink& getInfoSink() { return infoSink; }
+    EShLanguage getLanguage() const { return language; }
+    EShSpec getSpec() const { return spec; }
+    TSymbolTable& getSymbolTable() { return symbolTable; }
+    TInfoSink& getInfoSink() { return infoSink; }
 
     virtual bool compile(TIntermNode* root) = 0;
 
     virtual TCompiler* getAsCompiler() { return this; }
 
-    TInfoSink infoSink;
 protected:
     EShLanguage language;
     EShSpec spec;
+
+    // Built-in symbol table for the given language, spec, and resources.
+    // It is preserved from compile-to-compile.
+    TSymbolTable symbolTable;
+    // Output sink.
+    TInfoSink infoSink;
 };
 
 //
index 9e33a9d87d050b491dbf7f84a1d41d87bac5eb02..3c36ef82f649a4e384b5660df535cd230a0f286f 100644 (file)
 #include "compiler/ShHandle.h"
 #include "compiler/SymbolTable.h"
 
-//
-// A symbol table for each language.  Each has a different
-// set of built-ins, and we want to preserve that from
-// compile to compile.
-//
-TSymbolTable* SymbolTables[EShLangCount];
+static bool InitializeSymbolTable(
+        const TBuiltInStrings& builtInStrings,
+        EShLanguage language, EShSpec spec, const TBuiltInResource& resources,
+        TInfoSink& infoSink, TSymbolTable& symbolTable)
+{
+    TIntermediate intermediate(infoSink);
+    TParseContext parseContext(symbolTable, intermediate, language, spec, infoSink);
+
+    GlobalParseContext = &parseContext;
+
+    setInitialState();
+
+    assert(symbolTable.isEmpty());       
+    //
+    // Parse the built-ins.  This should only happen once per
+    // language symbol table.
+    //
+    // Push the symbol table to give it an initial scope.  This
+    // push should not have a corresponding pop, so that built-ins
+    // are preserved, and the test for an empty table fails.
+    //
+    symbolTable.push();
+    
+    //Initialize the Preprocessor
+    if (InitPreprocessor())
+    {
+        infoSink.info.message(EPrefixInternalError,  "Unable to intialize the Preprocessor");
+        return false;
+    }
+
+    for (TBuiltInStrings::const_iterator i = builtInStrings.begin(); i != builtInStrings.end(); ++i)
+    {
+        const char* builtInShaders[1];
+        int builtInLengths[1];
+
+        builtInShaders[0] = (*i).c_str();
+        builtInLengths[0] = (int) (*i).size();
+
+        if (PaParseStrings(const_cast<char**>(builtInShaders), builtInLengths, 1, parseContext) != 0)
+        {
+            infoSink.info.message(EPrefixInternalError, "Unable to parse built-ins");
+            return false;
+        }
+    }
+
+    IdentifyBuiltIns(language, spec, resources, symbolTable);
+
+    FinalizePreprocessor();
+
+    return true;
+}
+
+static bool GenerateBuiltInSymbolTable(
+        EShLanguage language, EShSpec spec, const TBuiltInResource& resources,
+        TInfoSink& infoSink, TSymbolTable& symbolTable)
+{
+    TBuiltIns builtIns;
 
+    builtIns.initialize(language, spec, resources);
+    return InitializeSymbolTable(builtIns.getBuiltInStrings(), language, spec, resources, infoSink, symbolTable);
+}
 
-TPoolAllocator* PerProcessGPA = 0;
 //
 // This is the platform independent interface between an OGL driver
 // and the shading language compiler.
@@ -37,42 +90,7 @@ TPoolAllocator* PerProcessGPA = 0;
 //
 int ShInitialize()
 {
-    TInfoSink infoSink;
-    bool ret = true;
-
-    if (!InitProcess())
-        return 0;
-
-    // This method should be called once per process. If its called by multiple threads, then 
-    // we need to have thread synchronization code around the initialization of per process
-    // global pool allocator
-    if (!PerProcessGPA) { 
-        TPoolAllocator *builtInPoolAllocator = new TPoolAllocator(true);
-        builtInPoolAllocator->push();
-        TPoolAllocator* gPoolAllocator = &GlobalPoolAllocator;
-        SetGlobalPoolAllocatorPtr(builtInPoolAllocator);
-
-        TSymbolTable symTables[EShLangCount];
-        GenerateBuiltInSymbolTable(0, infoSink, symTables);
-
-        PerProcessGPA = new TPoolAllocator(true);
-        PerProcessGPA->push();
-        SetGlobalPoolAllocatorPtr(PerProcessGPA);
-
-        SymbolTables[EShLangVertex] = new TSymbolTable;
-        SymbolTables[EShLangVertex]->copyTable(symTables[EShLangVertex]);
-        SymbolTables[EShLangFragment] = new TSymbolTable;
-        SymbolTables[EShLangFragment]->copyTable(symTables[EShLangFragment]);
-
-        SetGlobalPoolAllocatorPtr(gPoolAllocator);
-
-        symTables[EShLangVertex].pop();
-        symTables[EShLangFragment].pop();
-
-        builtInPoolAllocator->popAll();
-        delete builtInPoolAllocator;        
-
-    }
+    bool ret = InitProcess();
 
     return ret ? 1 : 0;
 }
@@ -81,13 +99,22 @@ int ShInitialize()
 // Driver calls these to create and destroy compiler objects.
 //
 
-ShHandle ShConstructCompiler(EShLanguage language, EShSpec spec)
+ShHandle ShConstructCompiler(EShLanguage language, EShSpec spec, const TBuiltInResource* resources)
 {
     if (!InitThread())
         return 0;
 
     TShHandleBase* base = static_cast<TShHandleBase*>(ConstructCompiler(language, spec));
-    
+    TCompiler* compiler = base->getAsCompiler();
+    if (compiler == 0)
+        return 0;
+
+    // Generate built-in symbol table.
+    if (!GenerateBuiltInSymbolTable(language, spec, *resources, compiler->getInfoSink(), compiler->getSymbolTable())) {
+        ShDestruct(base);
+        return 0;
+    }
+
     return reinterpret_cast<void*>(base);
 }
 
@@ -106,97 +133,8 @@ void ShDestruct(ShHandle handle)
 // Cleanup symbol tables
 //
 int ShFinalize()
-{  
-  if (PerProcessGPA) {
-    PerProcessGPA->popAll();
-    delete PerProcessGPA;
-    PerProcessGPA = 0;
-  }
-  for (int i = 0; i < EShLangCount; ++i) {
-    delete SymbolTables[i];
-    SymbolTables[i] = 0;
-  }
-  return 1;
-}
-
-bool GenerateBuiltInSymbolTable(const TBuiltInResource* resources, TInfoSink& infoSink, TSymbolTable* symbolTables, EShLanguage language)
-{
-    TBuiltIns builtIns;
-    
-       if (resources) {
-               builtIns.initialize(*resources);
-               InitializeSymbolTable(builtIns.getBuiltInStrings(), language, infoSink, resources, symbolTables);
-       } else {
-               builtIns.initialize();
-               InitializeSymbolTable(builtIns.getBuiltInStrings(), EShLangVertex, infoSink, resources, symbolTables);
-               InitializeSymbolTable(builtIns.getBuiltInStrings(), EShLangFragment, infoSink, resources, symbolTables);
-       }
-
-    return true;
-}
-
-bool InitializeSymbolTable(TBuiltInStrings* BuiltInStrings, EShLanguage language, TInfoSink& infoSink, const TBuiltInResource* resources, TSymbolTable* symbolTables)
 {
-    TIntermediate intermediate(infoSink);      
-    TSymbolTable* symbolTable;
-       
-       if (resources)
-               symbolTable = symbolTables;
-       else
-               symbolTable = &symbolTables[language];
-
-    // TODO(alokp): Investigate if a parse-context is necessary here and
-    // if symbol-table can be shared between GLES2 and WebGL specs.
-    TParseContext parseContext(*symbolTable, intermediate, language, EShSpecGLES2, infoSink);
-
-    GlobalParseContext = &parseContext;
-    
-    setInitialState();
-
-    assert(symbolTable->isEmpty() || symbolTable->atSharedBuiltInLevel());
-       
-    //
-    // Parse the built-ins.  This should only happen once per
-    // language symbol table.
-    //
-    // Push the symbol table to give it an initial scope.  This
-    // push should not have a corresponding pop, so that built-ins
-    // are preserved, and the test for an empty table fails.
-    //
-
-    symbolTable->push();
-    
-    //Initialize the Preprocessor
-    int ret = InitPreprocessor();
-    if (ret) {
-        infoSink.info.message(EPrefixInternalError,  "Unable to intialize the Preprocessor");
-        return false;
-    }
-    
-    for (TBuiltInStrings::iterator i  = BuiltInStrings[parseContext.language].begin();
-                                    i != BuiltInStrings[parseContext.language].end();
-                                    ++i) {
-        const char* builtInShaders[1];
-        int builtInLengths[1];
-
-        builtInShaders[0] = (*i).c_str();
-        builtInLengths[0] = (int) (*i).size();
-
-        if (PaParseStrings(const_cast<char**>(builtInShaders), builtInLengths, 1, parseContext) != 0) {
-            infoSink.info.message(EPrefixInternalError, "Unable to parse built-ins");
-            return false;
-        }
-    }
-
-       if (resources) {
-               IdentifyBuiltIns(parseContext.language, *symbolTable, *resources);
-       } else {                                                                           
-               IdentifyBuiltIns(parseContext.language, *symbolTable);
-       }
-
-    FinalizePreprocessor();
-
-    return true;
+    return 1;
 }
 
 //
@@ -211,7 +149,6 @@ int ShCompile(
     const char* const shaderStrings[],
     const int numStrings,
     const EShOptimizationLevel optLevel,
-    const TBuiltInResource* resources,
     int debugOptions
     )
 {
@@ -227,7 +164,7 @@ int ShCompile(
         return 0;
     
     GlobalPoolAllocator.push();
-    TInfoSink& infoSink = compiler->infoSink;
+    TInfoSink& infoSink = compiler->getInfoSink();
     infoSink.info.erase();
     infoSink.debug.erase();
     infoSink.obj.erase();
@@ -236,25 +173,22 @@ int ShCompile(
         return 1;
 
     TIntermediate intermediate(infoSink);
-    TSymbolTable symbolTable(*SymbolTables[compiler->getLanguage()]);
-    
-    GenerateBuiltInSymbolTable(resources, infoSink, &symbolTable, compiler->getLanguage());
+    TSymbolTable& symbolTable = compiler->getSymbolTable();
 
     TParseContext parseContext(symbolTable, intermediate, compiler->getLanguage(), compiler->getSpec(), infoSink);
     parseContext.initializeExtensionBehavior();
-
     GlobalParseContext = &parseContext;
-    
     setInitialState();
 
-    InitPreprocessor();    
+    InitPreprocessor();
     //
     // Parse the application's shaders.  All the following symbol table
     // work will be throw-away, so push a new allocation scope that can
     // be thrown away, then push a scope for the current shader's globals.
     //
     bool success = true;
-    
+
     symbolTable.push();
     if (!symbolTable.atGlobalLevel())
         parseContext.infoSink.info.message(EPrefixInternalError, "Wrong symbol table level");
@@ -301,7 +235,7 @@ int ShCompile(
     // Ensure symbol table is returned to the built-in level,
     // throwing away all but the built-ins.
     //
-    while (! symbolTable.atSharedBuiltInLevel())
+    while (!symbolTable.atBuiltInLevel())
         symbolTable.pop();
 
     FinalizePreprocessor();
index 87c6e8aadef00f42c05190cc881474c0cb0cf67d..07c81d15c2b27a44c2176346c98539a56f247854 100644 (file)
@@ -31,9 +31,9 @@
 //
 
 #include <assert.h>
-#include "compiler/Common.h"
-#include "compiler/intermediate.h"
+
 #include "compiler/InfoSink.h"
+#include "compiler/intermediate.h"
 
 //
 // Symbol base class.  (Can build functions or variables out of these...)
@@ -239,13 +239,6 @@ public:
         //
     }
 
-    TSymbolTable(TSymbolTable& symTable)
-    {
-        table.push_back(symTable.table[0]);
-        precisionStack.push_back( symTable.precisionStack[0] );
-        uniqueId = symTable.uniqueId;
-    }
-
     ~TSymbolTable()
     {
         // level 0 is always built In symbols, so we never pop that out
@@ -259,11 +252,10 @@ public:
     // globals are at level 1.
     //
     bool isEmpty() { return table.size() == 0; }
-    bool atBuiltInLevel() { return atSharedBuiltInLevel() || atDynamicBuiltInLevel(); }
-    bool atSharedBuiltInLevel() { return table.size() == 1; }  
-    bool atGlobalLevel() { return table.size() <= 3; }
+    bool atBuiltInLevel() { return table.size() == 1; }
+    bool atGlobalLevel() { return table.size() <= 2; }
     void push()
-    { 
+    {
         table.push_back(new TSymbolTableLevel);
         precisionStack.push_back( PrecisionStackLevel() );
     }
@@ -297,7 +289,7 @@ public:
         return symbol;
     }
 
-    TSymbolTableLevel* getGlobalLevel() { assert(table.size() >= 3); return table[2]; }
+    TSymbolTableLevel* getGlobalLevel() { assert(table.size() >= 2); return table[1]; }
     void relateToOperator(const char* name, TOperator op) { table[0]->relateToOperator(name, op); }
     int getMaxSymbolId() { return uniqueId; }
     void dump(TInfoSink &infoSink) const;
@@ -329,7 +321,6 @@ public:
 
 protected:    
     int currentLevel() const { return static_cast<int>(table.size()) - 1; }
-    bool atDynamicBuiltInLevel() { return table.size() == 2; }
 
     std::vector<TSymbolTableLevel*> table;
     typedef std::map< TBasicType, TPrecision > PrecisionStackLevel;
index 59aa69f9be67d3807dd0958c0bd634f90bcc707e..730c1b52aca9167932a83b70d0e5c1d549ec79f9 100644 (file)
@@ -34,8 +34,18 @@ Shader::Shader(Context *context, GLuint handle) : mHandle(handle), mContext(cont
 
         if (result)
         {
-            mFragmentCompiler = ShConstructCompiler(EShLangFragment, EShSpecGLES2);
-            mVertexCompiler = ShConstructCompiler(EShLangVertex, EShSpecGLES2);
+            TBuiltInResource resources;
+            resources.maxVertexAttribs = MAX_VERTEX_ATTRIBS;
+            resources.maxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
+            resources.maxVaryingVectors = MAX_VARYING_VECTORS;
+            resources.maxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+            resources.maxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+            resources.maxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+            resources.maxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
+            resources.maxDrawBuffers = MAX_DRAW_BUFFERS;
+
+            mFragmentCompiler = ShConstructCompiler(EShLangFragment, EShSpecGLES2, &resources);
+            mVertexCompiler = ShConstructCompiler(EShLangVertex, EShSpecGLES2, &resources);
         }
     }
 
@@ -267,18 +277,7 @@ void Shader::compileToHLSL(void *compiler)
     delete[] mInfoLog;
     mInfoLog = NULL;
 
-    TBuiltInResource resources;
-
-    resources.maxVertexAttribs = MAX_VERTEX_ATTRIBS;
-    resources.maxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
-    resources.maxVaryingVectors = MAX_VARYING_VECTORS;
-    resources.maxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
-    resources.maxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
-    resources.maxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
-    resources.maxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
-    resources.maxDrawBuffers = MAX_DRAW_BUFFERS;
-
-    int result = ShCompile(compiler, &mSource, 1, EShOptNone, &resources, EDebugOpNone);
+    int result = ShCompile(compiler, &mSource, 1, EShOptNone, EDebugOpNone);
     const char *obj = ShGetObjectCode(compiler);
     const char *info = ShGetInfoLog(compiler);