Implement gl_FragDepth for GLES SL 3.0

samples/shader_translator/shader_translator.cpp

@@ -165,6 +165,9 @@ int main(int argc, char *argv[])
                       case 'i': resources.OES_EGL_image_external = 1; break;
                       case 'd': resources.OES_standard_derivatives = 1; break;
                       case 'r': resources.ARB_texture_rectangle = 1; break;
+                      case 'g':
+                          resources.EXT_frag_depth = 1;
+                          break;
                       case 'l': resources.EXT_shader_texture_lod = 1; break;
                       case 'f': resources.EXT_shader_framebuffer_fetch = 1; break;
                       case 'n': resources.NV_shader_framebuffer_fetch = 1; break;
@@ -283,6 +286,7 @@ void usage()
         "       -x=i     : enable GL_OES_EGL_image_external\n"
         "       -x=d     : enable GL_OES_EGL_standard_derivatives\n"
         "       -x=r     : enable ARB_texture_rectangle\n"
+        "       -x=g     : enable EXT_frag_depth\n"
         "       -x=l     : enable EXT_shader_texture_lod\n"
         "       -x=f     : enable EXT_shader_framebuffer_fetch\n"
         "       -x=n     : enable NV_shader_framebuffer_fetch\n"

src/compiler/translator/BaseTypes.h

@@ -290,18 +290,18 @@ inline bool SupportsPrecision(TBasicType type)
 //
 enum TQualifier
 {
-    EvqTemporary,     // For temporaries (within a function), read/write
-    EvqGlobal,        // For globals read/write
-    EvqConst,         // User defined constants and non-output parameters in functions
-    EvqAttribute,     // Readonly
-    EvqVaryingIn,     // readonly, fragment shaders only
-    EvqVaryingOut,    // vertex shaders only  read/write
-    EvqUniform,       // Readonly, vertex and fragment
-
-    EvqVertexIn,      // Vertex shader input
-    EvqFragmentOut,   // Fragment shader output
-    EvqVertexOut,     // Vertex shader output
-    EvqFragmentIn,    // Fragment shader input
+    EvqTemporary,   // For temporaries (within a function), read/write
+    EvqGlobal,      // For globals read/write
+    EvqConst,       // User defined constants and non-output parameters in functions
+    EvqAttribute,   // Readonly
+    EvqVaryingIn,   // readonly, fragment shaders only
+    EvqVaryingOut,  // vertex shaders only  read/write
+    EvqUniform,     // Readonly, vertex and fragment
+
+    EvqVertexIn,     // Vertex shader input
+    EvqFragmentOut,  // Fragment shader output
+    EvqVertexOut,    // Vertex shader output
+    EvqFragmentIn,   // Fragment shader input
 
     // parameters
     EvqIn,
@@ -324,21 +324,22 @@ enum TQualifier
     // built-ins written by fragment shader
     EvqFragColor,
     EvqFragData,
-    EvqFragDepth,
+    EvqFragDepthEXT,  // gl_FragDepthEXT for ESSL100, EXT_frag_depth.
+    EvqFragDepth,     // gl_FragDepth for ESSL300.
 
     // built-ins written by the shader_framebuffer_fetch extension(s)
     EvqLastFragColor,
     EvqLastFragData,
 
     // GLSL ES 3.0 vertex output and fragment input
-    EvqSmooth,        // Incomplete qualifier, smooth is the default
-    EvqFlat,          // Incomplete qualifier
+    EvqSmooth,  // Incomplete qualifier, smooth is the default
+    EvqFlat,    // Incomplete qualifier
     EvqSmoothOut = EvqSmooth,
-    EvqFlatOut = EvqFlat,
-    EvqCentroidOut,   // Implies smooth
+    EvqFlatOut   = EvqFlat,
+    EvqCentroidOut,  // Implies smooth
     EvqSmoothIn,
     EvqFlatIn,
-    EvqCentroidIn,    // Implies smooth
+    EvqCentroidIn,  // Implies smooth
 
     // end of list
     EvqLast
@@ -388,7 +389,7 @@ struct TLayoutQualifier
 inline const char* getQualifierString(TQualifier q)
 {
     switch(q)
-    {
+    { // clang-format off
     case EvqTemporary:      return "Temporary";      break;
     case EvqGlobal:         return "Global";         break;
     case EvqConst:          return "const";          break;
@@ -412,6 +413,7 @@ inline const char* getQualifierString(TQualifier q)
     case EvqPointCoord:     return "PointCoord";     break;
     case EvqFragColor:      return "FragColor";      break;
     case EvqFragData:       return "FragData";       break;
+    case EvqFragDepthEXT:   return "FragDepth";      break;
     case EvqFragDepth:      return "FragDepth";      break;
     case EvqLastFragColor:  return "LastFragColor";  break;
     case EvqLastFragData:   return "LastFragData";   break;
@@ -422,7 +424,7 @@ inline const char* getQualifierString(TQualifier q)
     case EvqFlatIn:         return "flat in";        break;
     case EvqCentroidIn:     return "centroid in";    break;
     default: UNREACHABLE(); return "unknown qualifier";
-    }
+    } // clang-format on
 }
 
 inline const char* getMatrixPackingString(TLayoutMatrixPacking mpq)

src/compiler/translator/Initialize.cpp

@@ -504,10 +504,18 @@ void IdentifyBuiltIns(sh::GLenum type, ShShaderSpec spec,
 
             if (resources.EXT_frag_depth)
             {
-                symbolTable.insert(ESSL1_BUILTINS, "GL_EXT_frag_depth", new TVariable(NewPoolTString("gl_FragDepthEXT"),
-                    TType(EbtFloat, resources.FragmentPrecisionHigh ? EbpHigh : EbpMedium, EvqFragDepth, 1)));
+                symbolTable.insert(
+                    ESSL1_BUILTINS, "GL_EXT_frag_depth",
+                    new TVariable(
+                        NewPoolTString("gl_FragDepthEXT"),
+                        TType(EbtFloat, resources.FragmentPrecisionHigh ? EbpHigh : EbpMedium,
+                              EvqFragDepthEXT, 1)));
             }
 
+            symbolTable.insert(ESSL3_BUILTINS,
+                               new TVariable(NewPoolTString("gl_FragDepth"),
+                                             TType(EbtFloat, EbpHigh, EvqFragDepth, 1)));
+
             if (resources.EXT_shader_framebuffer_fetch || resources.NV_shader_framebuffer_fetch)
             {
                 TType lastFragData(EbtFloat, EbpMedium, EvqLastFragData, 4, 1, true);

src/compiler/translator/OutputHLSL.cpp

@@ -1386,7 +1386,7 @@ void OutputHLSL::visitSymbol(TIntermSymbol *node)
             mUsesInstanceID = true;
             out << name;
         }
-        else if (name == "gl_FragDepthEXT")
+        else if (name == "gl_FragDepthEXT" || name == "gl_FragDepth")
         {
             mUsesFragDepth = true;
             out << "gl_Depth";

src/compiler/translator/VariableInfo.cpp

@@ -150,6 +150,7 @@ CollectVariables::CollectVariables(std::vector<sh::Attribute> *attribs,
       mLastFragDataAdded(false),
       mFragColorAdded(false),
       mFragDataAdded(false),
+      mFragDepthEXTAdded(false),
       mFragDepthAdded(false),
       mHashFunction(hashFunction),
       mSymbolTable(symbolTable)
@@ -402,8 +403,8 @@ void CollectVariables::visitSymbol(TIntermSymbol *symbol)
                   mFragDataAdded = true;
               }
               return;
-          case EvqFragDepth:
-              if (!mFragDepthAdded)
+          case EvqFragDepthEXT:
+              if (!mFragDepthEXTAdded)
               {
                   Attribute info;
                   const char kName[] = "gl_FragDepthEXT";
@@ -417,9 +418,25 @@ void CollectVariables::visitSymbol(TIntermSymbol *symbol)
                                               ->getType());
                   info.staticUse = true;
                   mOutputVariables->push_back(info);
+                  mFragDepthEXTAdded = true;
+              }
+              return;
+          case EvqFragDepth:
+              if (!mFragDepthAdded)
+              {
+                  Attribute info;
+                  const char kName[] = "gl_FragDepth";
+                  info.name          = kName;
+                  info.mappedName    = kName;
+                  info.type          = GL_FLOAT;
+                  info.arraySize     = 0;
+                  info.precision     = GL_HIGH_FLOAT;
+                  info.staticUse = true;
+                  mOutputVariables->push_back(info);
                   mFragDepthAdded = true;
               }
               return;
+
           default:
             break;
         }

src/compiler/translator/VariableInfo.h

@@ -58,6 +58,7 @@ class CollectVariables : public TIntermTraverser
     bool mLastFragDataAdded;
     bool mFragColorAdded;
     bool mFragDataAdded;
+    bool mFragDepthEXTAdded;
     bool mFragDepthAdded;
 
     ShHashFunction64 mHashFunction;

src/tests/angle_unittests.gypi

@@ -39,6 +39,7 @@
             '<(angle_path)/src/tests/compiler_tests/ConstantFolding_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/DebugShaderPrecision_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/ExpressionLimit_test.cpp',
+            '<(angle_path)/src/tests/compiler_tests/FragDepth_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/MalformedShader_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/NV_draw_buffers_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/Pack_Unpack_test.cpp',

src/tests/compiler_tests/CollectVariables_test.cpp

@@ -556,3 +556,26 @@ TEST_F(CollectFragmentVariablesTest, OutputVarESSL1FragDepthHighp)
     EXPECT_GLENUM_EQ(GL_FLOAT, outputVariable->type);
     EXPECT_GLENUM_EQ(GL_HIGH_FLOAT, outputVariable->precision);
 }
+
+// Test that gl_FragData built-in usage in ESSL3 fragment shader is reflected in the output
+// variables list. Also test that the precision is highp.
+TEST_F(CollectFragmentVariablesTest, OutputVarESSL3FragDepthHighp)
+{
+    const std::string &fragDepthHighShader =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "void main() {\n"
+        "   gl_FragDepth = 0.7;"
+        "}\n";
+
+    ShBuiltInResources resources = mTranslator->getResources();
+    resources.EXT_frag_depth = 1;
+    initTranslator(resources);
+
+    const sh::Attribute *outputVariable = nullptr;
+    validateOutputVariableForShader(fragDepthHighShader, "gl_FragDepth", &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);
+}

src/tests/compiler_tests/FragDepth_test.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// FragDepth_test.cpp:
+//   Test for GLES SL 3.0 gl_FragDepth variable implementation.
+//
+
+#include "angle_gl.h"
+#include "gtest/gtest.h"
+#include "GLSLANG/ShaderLang.h"
+
+namespace
+{
+const char ESSLVersion100[] = "#version 100\n";
+const char ESSLVersion300[] = "#version 300 es\n";
+const char EXTFDPragma[]    = "#extension GL_EXT_frag_depth : require\n";
+}  // namespace
+
+class FragDepthTest : public testing::TestWithParam<int>
+{
+  protected:
+    void SetUp() override
+    {
+        ShInitBuiltInResources(&mResources);
+        mCompiler                 = nullptr;
+        mResources.EXT_frag_depth = GetParam();
+    }
+
+    void TearDown() override { DestroyCompiler(); }
+    void DestroyCompiler()
+    {
+        if (mCompiler)
+        {
+            ShDestruct(mCompiler);
+            mCompiler = nullptr;
+        }
+    }
+
+    void InitializeCompiler()
+    {
+        DestroyCompiler();
+        mCompiler =
+            ShConstructCompiler(GL_FRAGMENT_SHADER, SH_GLES3_SPEC, SH_GLSL_OUTPUT, &mResources);
+        ASSERT_TRUE(mCompiler != nullptr) << "Compiler could not be constructed.";
+    }
+
+    testing::AssertionResult TestShaderCompile(const char *version,
+                                               const char *pragma,
+                                               const char *shader)
+    {
+        const char *shaderStrings[] = {version, pragma, shader};
+        bool success = ShCompile(mCompiler, shaderStrings, 3, 0);
+        if (success)
+        {
+            return ::testing::AssertionSuccess() << "Compilation success";
+        }
+        return ::testing::AssertionFailure() << ShGetInfoLog(mCompiler);
+    }
+
+  protected:
+    ShBuiltInResources mResources;
+    ShHandle mCompiler;
+};
+
+// The GLES SL 3.0 built-in variable gl_FragDepth fails to compile with GLES SL 1.0.
+TEST_P(FragDepthTest, CompileFailsESSL100)
+{
+    static const char shaderString[] =
+        "precision mediump float;\n"
+        "void main() { \n"
+        "    gl_FragDepth = 1.0;\n"
+        "}\n";
+
+    InitializeCompiler();
+    EXPECT_FALSE(TestShaderCompile(ESSLVersion100, "", shaderString));
+    EXPECT_FALSE(TestShaderCompile("", "", shaderString));
+    EXPECT_FALSE(TestShaderCompile("", EXTFDPragma, shaderString));
+}
+
+// The GLES SL 3.0 built-in variable gl_FragDepth compiles with GLES SL 3.0.
+TEST_P(FragDepthTest, CompileSucceedsESSL300)
+{
+    static const char shaderString[] =
+        "precision mediump float;\n"
+        "void main() { \n"
+        "    gl_FragDepth = 1.0;\n"
+        "}\n";
+    InitializeCompiler();
+    EXPECT_TRUE(TestShaderCompile(ESSLVersion300, "", shaderString));
+}
+
+// Using #extension GL_EXT_frag_depth in GLSL ES 3.0 shader fails to compile.
+TEST_P(FragDepthTest, ExtensionFDFailsESSL300)
+{
+    static const char shaderString[] =
+        "precision mediump float;\n"
+        "out vec4 fragColor;\n"
+        "void main() { \n"
+        "    fragColor = vec4(1.0);\n"
+        "}\n";
+    InitializeCompiler();
+    if (mResources.EXT_frag_depth == 1)
+    {
+        // TODO(kkinnunen): this should fail. Extensions need to have similar level system to
+        // SymbolTable.  The biggest task is to implement version-aware preprocessor, so that the
+        // extension defines can be defined depending on the version that the preprocessor saw or
+        // did not see.
+        EXPECT_TRUE(TestShaderCompile(ESSLVersion300, EXTFDPragma, shaderString));
+    }
+    else
+    {
+        EXPECT_FALSE(TestShaderCompile(ESSLVersion300, EXTFDPragma, shaderString));
+    }
+}
+
+// The tests should pass regardless whether the EXT_frag_depth is on or not.
+INSTANTIATE_TEST_CASE_P(FragDepthTests, FragDepthTest, testing::Values(0, 1));

src/tests/compiler_tests/compiler_tests.gypi

@@ -11,6 +11,7 @@
         'ConstantFolding_test.cpp',
         'DebugShaderPrecision_test.cpp',
         'ExpressionLimit_test.cpp',
+        'FragDepth_test.cpp',
         'MalformedShader_test.cpp',
         'NV_draw_buffers_test.cpp',
         'Pack_Unpack_test.cpp',