Refactor GLSL version calculations for emulated functions.

src/compiler/translator/BuiltInFunctionEmulatorGLSL.cpp

@@ -8,8 +8,9 @@
 #include "compiler/translator/BuiltInFunctionEmulator.h"
 #include "compiler/translator/BuiltInFunctionEmulatorGLSL.h"
 #include "compiler/translator/SymbolTable.h"
+#include "compiler/translator/VersionGLSL.h"
 
-void InitBuiltInFunctionEmulatorForGLSL(BuiltInFunctionEmulator *emu, sh::GLenum shaderType)
+void InitBuiltInFunctionEmulatorForGLSLWorkarounds(BuiltInFunctionEmulator *emu, sh::GLenum shaderType)
 {
     // we use macros here instead of function definitions to work around more GLSL
     // compiler bugs, in particular on NVIDIA hardware on Mac OSX. Macros are
@@ -36,9 +37,12 @@ void InitBuiltInFunctionEmulatorForGLSL(BuiltInFunctionEmulator *emu, sh::GLenum
     emu->addEmulatedFunction(EOpReflect, float1, float1, "#define webgl_reflect_emu(I, N) ((I) - 2.0 * (N) * (I) * (N))");
 }
 
-// emulate built-in functions missing from OpenGL 4.1
-void InitBuiltInFunctionEmulatorForGLSL4_1(BuiltInFunctionEmulator *emu, sh::GLenum shaderType)
+// Emulate built-in functions missing from GLSL 1.30 and higher
+void InitBuiltInFunctionEmulatorForGLSLMissingFunctions(BuiltInFunctionEmulator *emu, sh::GLenum shaderType,
+                                                        int targetGLSLVersion)
 {
+    if (targetGLSLVersion == GLSL_VERSION_410)
+    {
         TType *float2 = new TType(EbtFloat, 2);
         TType *uint1 = new TType(EbtUInt);
 
@@ -104,4 +108,5 @@ void InitBuiltInFunctionEmulatorForGLSL4_1(BuiltInFunctionEmulator *emu, sh::GLe
             "    uint x = u & 0xffffu;\n"
             "    return vec2(webgl_f16tof32(x), webgl_f16tof32(y));\n"
             "}\n");
+    }
 }

src/compiler/translator/BuiltInFunctionEmulatorGLSL.h

@@ -14,11 +14,12 @@ class BuiltInFunctionEmulator;
 //
 // This is only a workaround for OpenGL driver bugs, and isn't needed in general.
 //
-void InitBuiltInFunctionEmulatorForGLSL(BuiltInFunctionEmulator *emu, sh::GLenum shaderType);
+void InitBuiltInFunctionEmulatorForGLSLWorkarounds(BuiltInFunctionEmulator *emu, sh::GLenum shaderType);
 
 //
-// This function is emulating built-in functions missing from OpenGL 4.1.
+// This function is emulating built-in functions missing from GLSL 1.30 and higher.
 //
-void InitBuiltInFunctionEmulatorForGLSL4_1(BuiltInFunctionEmulator *emu, sh::GLenum shaderType);
+void InitBuiltInFunctionEmulatorForGLSLMissingFunctions(BuiltInFunctionEmulator *emu, sh::GLenum shaderType,
+                                                        int targetGLSLVersion);
 
 #endif  // COMPILER_TRANSLATOR_BUILTINFUNCTIONEMULATORGLSL_H_

src/compiler/translator/TranslatorESSL.cpp

@@ -20,7 +20,9 @@ TranslatorESSL::TranslatorESSL(sh::GLenum type, ShShaderSpec spec)
 void TranslatorESSL::initBuiltInFunctionEmulator(BuiltInFunctionEmulator *emu, int compileOptions)
 {
     if (compileOptions & SH_EMULATE_BUILT_IN_FUNCTIONS)
-        InitBuiltInFunctionEmulatorForGLSL(emu, getShaderType());
+    {
+        InitBuiltInFunctionEmulatorForGLSLWorkarounds(emu, getShaderType());
+    }
 }
 
 void TranslatorESSL::translate(TIntermNode *root, int) {

src/compiler/translator/TranslatorGLSL.cpp

@@ -66,9 +66,12 @@ TranslatorGLSL::TranslatorGLSL(sh::GLenum type,
 void TranslatorGLSL::initBuiltInFunctionEmulator(BuiltInFunctionEmulator *emu, int compileOptions)
 {
     if (compileOptions & SH_EMULATE_BUILT_IN_FUNCTIONS)
-        InitBuiltInFunctionEmulatorForGLSL(emu, getShaderType());
-    if (getOutputType() == SH_GLSL_410_CORE_OUTPUT)
-        InitBuiltInFunctionEmulatorForGLSL4_1(emu, getShaderType());
+    {
+        InitBuiltInFunctionEmulatorForGLSLWorkarounds(emu, getShaderType());
+    }
+
+    int targetGLSLVersion = ShaderOutputTypeToGLSLVersion(getOutputType());
+    InitBuiltInFunctionEmulatorForGLSLMissingFunctions(emu, getShaderType(), targetGLSLVersion);
 }
 
 void TranslatorGLSL::translate(TIntermNode *root, int) {

src/compiler/translator/VersionGLSL.cpp

@@ -6,11 +6,17 @@
 
 #include "compiler/translator/VersionGLSL.h"
 
-static const int GLSL_VERSION_110 = 110;
-static const int GLSL_VERSION_120 = 120;
-static const int GLSL_VERSION_130 = 130;
-static const int GLSL_VERSION_410 = 410;
-static const int GLSL_VERSION_420 = 420;
+int ShaderOutputTypeToGLSLVersion(ShShaderOutput output)
+{
+    switch (output)
+    {
+      case SH_GLSL_130_OUTPUT:           return GLSL_VERSION_130;
+      case SH_GLSL_410_CORE_OUTPUT:      return GLSL_VERSION_410;
+      case SH_GLSL_420_CORE_OUTPUT:      return GLSL_VERSION_420;
+      case SH_GLSL_COMPATIBILITY_OUTPUT: return GLSL_VERSION_110;
+      default: UNREACHABLE();            return 0;
+    }
+}
 
 // We need to scan for the following:
 // 1. "invariant" keyword: This can occur in both - vertex and fragment shaders
@@ -34,32 +40,19 @@ TVersionGLSL::TVersionGLSL(sh::GLenum type,
                            ShShaderOutput output)
     : TIntermTraverser(true, false, false)
 {
-    if (output == SH_GLSL_130_OUTPUT)
-    {
-        mVersion = GLSL_VERSION_130;
-    }
-    else if (output == SH_GLSL_410_CORE_OUTPUT)
-    {
-        mVersion = GLSL_VERSION_410;
-    }
-    else if (output == SH_GLSL_420_CORE_OUTPUT)
-    {
-        mVersion = GLSL_VERSION_420;
-    }
-    else
-    {
-      ASSERT(output == SH_GLSL_COMPATIBILITY_OUTPUT);
+    mVersion = ShaderOutputTypeToGLSLVersion(output);
     if (pragma.stdgl.invariantAll)
-          mVersion = GLSL_VERSION_120;
-      else
-          mVersion = GLSL_VERSION_110;
+    {
+        ensureVersionIsAtLeast(GLSL_VERSION_120);
     }
 }
 
 void TVersionGLSL::visitSymbol(TIntermSymbol *node)
 {
     if (node->getSymbol() == "gl_PointCoord")
-        updateVersion(GLSL_VERSION_120);
+    {
+        ensureVersionIsAtLeast(GLSL_VERSION_120);
+    }
 }
 
 bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate *node)
@@ -77,12 +70,12 @@ bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate *node)
             const TIntermSequence &sequence = *(node->getSequence());
             if (sequence.front()->getAsTyped()->getType().isInvariant())
             {
-                updateVersion(GLSL_VERSION_120);
+                ensureVersionIsAtLeast(GLSL_VERSION_120);
             }
             break;
         }
       case EOpInvariantDeclaration:
-        updateVersion(GLSL_VERSION_120);
+        ensureVersionIsAtLeast(GLSL_VERSION_120);
         break;
       case EOpParameters:
         {
@@ -96,7 +89,7 @@ bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate *node)
                     TQualifier qualifier = param->getQualifier();
                     if ((qualifier == EvqOut) || (qualifier ==  EvqInOut))
                     {
-                        updateVersion(GLSL_VERSION_120);
+                        ensureVersionIsAtLeast(GLSL_VERSION_120);
                         break;
                     }
                 }
@@ -115,7 +108,7 @@ bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate *node)
                 TIntermTyped *typed = sequence.front()->getAsTyped();
                 if (typed && typed->isMatrix())
                 {
-                    updateVersion(GLSL_VERSION_120);
+                    ensureVersionIsAtLeast(GLSL_VERSION_120);
                 }
             }
             break;
@@ -127,7 +120,7 @@ bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate *node)
     return visitChildren;
 }
 
-void TVersionGLSL::updateVersion(int version)
+void TVersionGLSL::ensureVersionIsAtLeast(int version)
 {
     mVersion = std::max(version, mVersion);
 }

src/compiler/translator/VersionGLSL.h

@@ -11,6 +11,14 @@
 
 #include "compiler/translator/Pragma.h"
 
+static const int GLSL_VERSION_110 = 110;
+static const int GLSL_VERSION_120 = 120;
+static const int GLSL_VERSION_130 = 130;
+static const int GLSL_VERSION_410 = 410;
+static const int GLSL_VERSION_420 = 420;
+
+int ShaderOutputTypeToGLSLVersion(ShShaderOutput output);
+
 // Traverses the intermediate tree to return the minimum GLSL version
 // required to legally access all built-in features used in the shader.
 // GLSL 1.1 which is mandated by OpenGL 2.0 provides:
@@ -39,15 +47,14 @@ class TVersionGLSL : public TIntermTraverser
     //   - matrix/matrix constructors
     //   - array "out" parameters
     //   Else 110 is returned.
-    int getVersion() { return mVersion; }
+    int getVersion() const { return mVersion; }
 
     virtual void visitSymbol(TIntermSymbol *);
     virtual bool visitAggregate(Visit, TIntermAggregate *);
 
-  protected:
-    void updateVersion(int version);
-
   private:
+    void ensureVersionIsAtLeast(int version);
+
     int mVersion;
 };