Expose GL built-in output variables in ShGetOutputVariables

src/compiler/translator/TranslatorGLSL.cpp

@@ -12,51 +12,6 @@
 #include "compiler/translator/OutputGLSL.h"
 #include "compiler/translator/VersionGLSL.h"
 
-namespace
-{
-
-// To search for what output variables are used in a fragment shader.
-// We handle gl_FragColor and gl_FragData at the moment.
-class TFragmentOutSearcher : public TIntermTraverser
-{
-  public:
-    TFragmentOutSearcher()
-        : TIntermTraverser(true, false, false),
-          mUsesGlFragColor(false),
-          mUsesGlFragData(false)
-    {
-    }
-
-    bool usesGlFragColor() const
-    {
-        return mUsesGlFragColor;
-    }
-
-    bool usesGlFragData() const
-    {
-        return mUsesGlFragData;
-    }
-
-  protected:
-    virtual void visitSymbol(TIntermSymbol *node) override
-    {
-        if (node->getSymbol() == "gl_FragColor")
-        {
-            mUsesGlFragColor = true;
-        }
-        else if (node->getSymbol() == "gl_FragData")
-        {
-            mUsesGlFragData = true;
-        }
-    }
-
-  private:
-    bool mUsesGlFragColor;
-    bool mUsesGlFragData;
-};
-
-}  // namespace anonymous
-
 TranslatorGLSL::TranslatorGLSL(sh::GLenum type,
                                ShShaderSpec spec,
                                ShShaderOutput output)
@@ -111,14 +66,25 @@ void TranslatorGLSL::translate(TIntermNode *root, int) {
     // if it's core profile shaders and they are used.
     if (getShaderType() == GL_FRAGMENT_SHADER && IsGLSL130OrNewer(getOutputType()))
     {
-        TFragmentOutSearcher searcher;
-        root->traverse(&searcher);
-        ASSERT(!(searcher.usesGlFragData() && searcher.usesGlFragColor()));
-        if (searcher.usesGlFragColor())
+        bool usesGLFragColor = false;
+        bool usesGLFragData = false;
+        for (auto outputVar : outputVariables)
+        {
+            if (outputVar.name == "gl_FragColor")
+            {
+                usesGLFragColor = true;
+            }
+            else if (outputVar.name == "gl_FragData")
+            {
+                usesGLFragData = true;
+            }
+        }
+        ASSERT(!(usesGLFragColor && usesGLFragData));
+        if (usesGLFragColor)
         {
             sink << "out vec4 webgl_FragColor;\n";
         }
-        if (searcher.usesGlFragData())
+        if (usesGLFragData)
         {
             sink << "out vec4 webgl_FragData[gl_MaxDrawBuffers];\n";
         }

src/compiler/translator/VariableInfo.cpp

@@ -148,6 +148,9 @@ CollectVariables::CollectVariables(std::vector<sh::Attribute> *attribs,
       mPositionAdded(false),
       mPointSizeAdded(false),
       mLastFragDataAdded(false),
+      mFragColorAdded(false),
+      mFragDataAdded(false),
+      mFragDepthAdded(false),
       mHashFunction(hashFunction),
       mSymbolTable(symbolTable)
 {
@@ -366,6 +369,57 @@ void CollectVariables::visitSymbol(TIntermSymbol *symbol)
                 mLastFragDataAdded = true;
             }
             return;
+          case EvqFragColor:
+              if (!mFragColorAdded)
+              {
+                  Attribute info;
+                  const char kName[] = "gl_FragColor";
+                  info.name          = kName;
+                  info.mappedName    = kName;
+                  info.type          = GL_FLOAT_VEC4;
+                  info.arraySize     = 0;
+                  info.precision     = GL_MEDIUM_FLOAT;  // Defined by spec.
+                  info.staticUse = true;
+                  mOutputVariables->push_back(info);
+                  mFragColorAdded = true;
+              }
+              return;
+          case EvqFragData:
+              if (!mFragDataAdded)
+              {
+                  Attribute info;
+                  const char kName[] = "gl_FragData";
+                  info.name          = kName;
+                  info.mappedName    = kName;
+                  info.type          = GL_FLOAT_VEC4;
+                  info.arraySize = static_cast<const TVariable *>(
+                                       mSymbolTable.findBuiltIn("gl_MaxDrawBuffers", 100))
+                                       ->getConstPointer()
+                                       ->getIConst();
+                  info.precision = GL_MEDIUM_FLOAT;  // Defined by spec.
+                  info.staticUse = true;
+                  mOutputVariables->push_back(info);
+                  mFragDataAdded = true;
+              }
+              return;
+          case EvqFragDepth:
+              if (!mFragDepthAdded)
+              {
+                  Attribute info;
+                  const char kName[] = "gl_FragDepthEXT";
+                  info.name          = kName;
+                  info.mappedName    = kName;
+                  info.type          = GL_FLOAT;
+                  info.arraySize = 0;
+                  info.precision =
+                      GLVariablePrecision(static_cast<const TVariable *>(
+                                              mSymbolTable.findBuiltIn("gl_FragDepthEXT", 100))
+                                              ->getType());
+                  info.staticUse = true;
+                  mOutputVariables->push_back(info);
+                  mFragDepthAdded = true;
+              }
+              return;
           default:
             break;
         }

src/compiler/translator/VariableInfo.h

@@ -56,6 +56,9 @@ class CollectVariables : public TIntermTraverser
     bool mPositionAdded;
     bool mPointSizeAdded;
     bool mLastFragDataAdded;
+    bool mFragColorAdded;
+    bool mFragDataAdded;
+    bool mFragDepthAdded;
 
     ShHashFunction64 mHashFunction;
 

src/tests/compiler_tests/CollectVariables_test.cpp

@@ -94,6 +94,24 @@ class CollectVariablesTest : public testing::Test
         EXPECT_TRUE(foundNear && foundFar && foundDiff);
     }
 
+    // For use in tests for output varibles.
+    void validateOutputVariableForShader(const std::string &shaderString,
+                                         const char *varName,
+                                         const sh::Attribute **outResult)
+    {
+        const char *shaderStrings[] = {shaderString.c_str()};
+        ASSERT_TRUE(mTranslator->compile(shaderStrings, 1, SH_VARIABLES))
+            << mTranslator->getInfoSink().info.str();
+
+        const std::vector<sh::Attribute> &outputVariables = mTranslator->getOutputVariables();
+        ASSERT_LT(0u, outputVariables.size());
+        const sh::Attribute &outputVariable = outputVariables[0];
+        EXPECT_EQ(-1, outputVariable.location);
+        EXPECT_TRUE(outputVariable.staticUse);
+        EXPECT_EQ(varName, outputVariable.name);
+        *outResult = &outputVariable;
+    }
+
     GLenum mShaderType;
     TranslatorGLSL *mTranslator;
 };
@@ -448,3 +466,93 @@ TEST_F(CollectFragmentVariablesTest, DepthRange)
 
     validateDepthRangeShader(shaderString);
 }
+
+// Test that gl_FragColor built-in usage in ESSL1 fragment shader is reflected in the output
+// variables list.
+TEST_F(CollectFragmentVariablesTest, OutputVarESSL1FragColor)
+{
+    const std::string &fragColorShader =
+        "precision mediump float;\n"
+        "void main() {\n"
+        "   gl_FragColor = vec4(1.0);\n"
+        "}\n";
+
+    const sh::Attribute *outputVariable = nullptr;
+    validateOutputVariableForShader(fragColorShader, "gl_FragColor", &outputVariable);
+    ASSERT_NE(outputVariable, nullptr);
+    EXPECT_EQ(0u, outputVariable->arraySize);
+    EXPECT_GLENUM_EQ(GL_FLOAT_VEC4, outputVariable->type);
+    EXPECT_GLENUM_EQ(GL_MEDIUM_FLOAT, outputVariable->precision);
+}
+
+// Test that gl_FragData built-in usage in ESSL1 fragment shader is reflected in the output
+// variables list.
+TEST_F(CollectFragmentVariablesTest, OutputVarESSL1FragData)
+{
+    const std::string &fragDataShader =
+        "#extension GL_EXT_draw_buffers : require\n"
+        "precision mediump float;\n"
+        "void main() {\n"
+        "   gl_FragData[0] = vec4(1.0);\n"
+        "   gl_FragData[1] = vec4(0.5);\n"
+        "}\n";
+
+    ShBuiltInResources resources       = mTranslator->getResources();
+    resources.EXT_draw_buffers         = 1;
+    const unsigned int kMaxDrawBuffers = 3u;
+    resources.MaxDrawBuffers = kMaxDrawBuffers;
+    initTranslator(resources);
+
+    const sh::Attribute *outputVariable = nullptr;
+    validateOutputVariableForShader(fragDataShader, "gl_FragData", &outputVariable);
+    ASSERT_NE(outputVariable, nullptr);
+    EXPECT_EQ(kMaxDrawBuffers, outputVariable->arraySize);
+    EXPECT_GLENUM_EQ(GL_FLOAT_VEC4, outputVariable->type);
+    EXPECT_GLENUM_EQ(GL_MEDIUM_FLOAT, outputVariable->precision);
+}
+
+// Test that gl_FragDataEXT built-in usage in ESSL1 fragment shader is reflected in the output
+// variables list. Also test that the precision is mediump.
+TEST_F(CollectFragmentVariablesTest, OutputVarESSL1FragDepthMediump)
+{
+    const std::string &fragDepthShader =
+        "#extension GL_EXT_frag_depth : require\n"
+        "precision mediump float;\n"
+        "void main() {\n"
+        "   gl_FragDepthEXT = 0.7;"
+        "}\n";
+
+    ShBuiltInResources resources = mTranslator->getResources();
+    resources.EXT_frag_depth = 1;
+    initTranslator(resources);
+
+    const sh::Attribute *outputVariable = nullptr;
+    validateOutputVariableForShader(fragDepthShader, "gl_FragDepthEXT", &outputVariable);
+    ASSERT_NE(outputVariable, nullptr);
+    EXPECT_EQ(0u, outputVariable->arraySize);
+    EXPECT_GLENUM_EQ(GL_FLOAT, outputVariable->type);
+    EXPECT_GLENUM_EQ(GL_MEDIUM_FLOAT, outputVariable->precision);
+}
+
+// Test that gl_FragDataEXT built-in usage in ESSL1 fragment shader is reflected in the output
+// variables list. Also test that the precision is highp if user requests it.
+TEST_F(CollectFragmentVariablesTest, OutputVarESSL1FragDepthHighp)
+{
+    const std::string &fragDepthHighShader =
+        "#extension GL_EXT_frag_depth : require\n"
+        "void main() {\n"
+        "   gl_FragDepthEXT = 0.7;"
+        "}\n";
+
+    ShBuiltInResources resources    = mTranslator->getResources();
+    resources.EXT_frag_depth        = 1;
+    resources.FragmentPrecisionHigh = 1;
+    initTranslator(resources);
+
+    const sh::Attribute *outputVariable = nullptr;
+    validateOutputVariableForShader(fragDepthHighShader, "gl_FragDepthEXT", &outputVariable);
+    ASSERT_NE(outputVariable, nullptr);
+    EXPECT_EQ(0u, outputVariable->arraySize);
+    EXPECT_GLENUM_EQ(GL_FLOAT, outputVariable->type);
+    EXPECT_GLENUM_EQ(GL_HIGH_FLOAT, outputVariable->precision);
+}