Vulkan: Generalize FlipRotationSpecConst to SpecializationConstant

include/GLSLANG/ShaderLang.h

@@ -346,7 +346,7 @@ const ShCompileOptions SH_ADD_PRE_ROTATION = UINT64_C(1) << 56;
 const ShCompileOptions SH_FORCE_SHADER_PRECISION_HIGHP_TO_MEDIUMP = UINT64_C(1) << 57;
 
 // Allow compiler to use specialization constant to do pre-rotation and y flip.
-const ShCompileOptions SH_USE_ROTATION_SPECIALIZATION_CONSTANT = UINT64_C(1) << 58;
+const ShCompileOptions SH_USE_SPECIALIZATION_CONSTANT = UINT64_C(1) << 58;
 
 // Defines alternate strategies for implementing array index clamping.
 enum ShArrayIndexClampingStrategy

src/compiler.gni

@@ -220,8 +220,6 @@ angle_translator_sources = [
   "src/compiler/translator/tree_util/FindMain.h",
   "src/compiler/translator/tree_util/FindSymbolNode.cpp",
   "src/compiler/translator/tree_util/FindSymbolNode.h",
-  "src/compiler/translator/tree_util/FlipRotateSpecConst.cpp",
-  "src/compiler/translator/tree_util/FlipRotateSpecConst.h",
   "src/compiler/translator/tree_util/IntermNodePatternMatcher.cpp",
   "src/compiler/translator/tree_util/IntermNodePatternMatcher.h",
   "src/compiler/translator/tree_util/IntermNode_util.cpp",
@@ -243,6 +241,8 @@ angle_translator_sources = [
   "src/compiler/translator/tree_util/RunAtTheBeginningOfShader.h",
   "src/compiler/translator/tree_util/RunAtTheEndOfShader.cpp",
   "src/compiler/translator/tree_util/RunAtTheEndOfShader.h",
+  "src/compiler/translator/tree_util/SpecializationConstant.cpp",
+  "src/compiler/translator/tree_util/SpecializationConstant.h",
   "src/compiler/translator/tree_util/Visit.h",
   "src/compiler/translator/util.cpp",
   "src/compiler/translator/util.h",

src/compiler/translator/TranslatorMetal.cpp

@@ -143,9 +143,10 @@ bool TranslatorMetal::translate(TIntermBlock *root,
                                  getNameMap(), &getSymbolTable(), getShaderType(),
                                  getShaderVersion(), getOutputType(), false, true, compileOptions);
 
+    SpecConstMetal specConst(&getSymbolTable(), compileOptions);
     DriverUniformMetal driverUniforms;
-    if (!TranslatorVulkan::translateImpl(root, compileOptions, perfDiagnostics, &driverUniforms,
-                                         &outputGLSL))
+    if (!TranslatorVulkan::translateImpl(root, compileOptions, perfDiagnostics, &specConst,
+                                         &driverUniforms, &outputGLSL))
     {
         return false;
     }

src/compiler/translator/TranslatorMetal.h

@@ -17,10 +17,24 @@
 
 #include "compiler/translator/TranslatorVulkan.h"
 #include "compiler/translator/tree_util/DriverUniform.h"
+#include "compiler/translator/tree_util/SpecializationConstant.h"
 
 namespace sh
 {
 
+// TODO: http://anglebug.com/5339 Implement it using actual specialization constant. For now we are
+// redirecting to driver uniforms
+class SpecConstMetal : public SpecConst
+{
+  public:
+    SpecConstMetal(TSymbolTable *symbolTable, ShCompileOptions compileOptions)
+        : SpecConst(symbolTable, compileOptions)
+    {}
+    ~SpecConstMetal() override {}
+
+  private:
+};
+
 class DriverUniformMetal : public DriverUniform
 {
   public:

src/compiler/translator/TranslatorVulkan.h

@@ -18,6 +18,7 @@ namespace sh
 {
 
 class TOutputVulkanGLSL;
+class SpecConst;
 class DriverUniform;
 
 class TranslatorVulkan : public TCompiler
@@ -36,6 +37,7 @@ class TranslatorVulkan : public TCompiler
     ANGLE_NO_DISCARD bool translateImpl(TIntermBlock *root,
                                         ShCompileOptions compileOptions,
                                         PerformanceDiagnostics *perfDiagnostics,
+                                        SpecConst *specConst,
                                         DriverUniform *driverUniforms,
                                         TOutputVulkanGLSL *outputGLSL);
 

src/compiler/translator/tree_ops/RewriteDfdy.cpp

@@ -13,9 +13,9 @@
 #include "compiler/translator/SymbolTable.h"
 #include "compiler/translator/TranslatorVulkan.h"
 #include "compiler/translator/tree_util/DriverUniform.h"
-#include "compiler/translator/tree_util/FlipRotateSpecConst.h"
 #include "compiler/translator/tree_util/IntermNode_util.h"
 #include "compiler/translator/tree_util/IntermTraverse.h"
+#include "compiler/translator/tree_util/SpecializationConstant.h"
 
 namespace sh
 {
@@ -30,30 +30,30 @@ class Traverser : public TIntermTraverser
                                        ShCompileOptions compileOptions,
                                        TIntermNode *root,
                                        const TSymbolTable &symbolTable,
-                                       FlipRotateSpecConst *rotationSpecConst,
+                                       SpecConst *specConst,
                                        const DriverUniform *driverUniforms);
 
   private:
     Traverser(TSymbolTable *symbolTable,
               ShCompileOptions compileOptions,
-              FlipRotateSpecConst *rotationSpecConst,
+              SpecConst *specConst,
               const DriverUniform *driverUniforms);
     bool visitUnary(Visit visit, TIntermUnary *node) override;
 
     bool visitUnaryWithRotation(Visit visit, TIntermUnary *node);
     bool visitUnaryWithoutRotation(Visit visit, TIntermUnary *node);
 
-    FlipRotateSpecConst *mRotationSpecConst = nullptr;
-    const DriverUniform *mDriverUniforms    = nullptr;
-    bool mUsePreRotation                    = false;
+    SpecConst *mRotationSpecConst        = nullptr;
+    const DriverUniform *mDriverUniforms = nullptr;
+    bool mUsePreRotation                 = false;
 };
 
 Traverser::Traverser(TSymbolTable *symbolTable,
                      ShCompileOptions compileOptions,
-                     FlipRotateSpecConst *rotationSpecConst,
+                     SpecConst *specConst,
                      const DriverUniform *driverUniforms)
     : TIntermTraverser(true, false, false, symbolTable),
-      mRotationSpecConst(rotationSpecConst),
+      mRotationSpecConst(specConst),
       mDriverUniforms(driverUniforms),
       mUsePreRotation((compileOptions & SH_ADD_PRE_ROTATION) != 0)
 {}
@@ -63,11 +63,11 @@ bool Traverser::Apply(TCompiler *compiler,
                       ShCompileOptions compileOptions,
                       TIntermNode *root,
                       const TSymbolTable &symbolTable,
-                      FlipRotateSpecConst *rotationSpecConst,
+                      SpecConst *specConst,
                       const DriverUniform *driverUniforms)
 {
     TSymbolTable *pSymbolTable = const_cast<TSymbolTable *>(&symbolTable);
-    Traverser traverser(pSymbolTable, compileOptions, rotationSpecConst, driverUniforms);
+    Traverser traverser(pSymbolTable, compileOptions, specConst, driverUniforms);
     root->traverse(&traverser);
     return traverser.updateTree(compiler, root);
 }
@@ -217,15 +217,14 @@ bool RewriteDfdy(TCompiler *compiler,
                  TIntermNode *root,
                  const TSymbolTable &symbolTable,
                  int shaderVersion,
-                 FlipRotateSpecConst *rotationSpecConst,
+                 SpecConst *specConst,
                  const DriverUniform *driverUniforms)
 {
     // dFdy is only valid in GLSL 3.0 and later.
     if (shaderVersion < 300)
         return true;
 
-    return Traverser::Apply(compiler, compileOptions, root, symbolTable, rotationSpecConst,
-                            driverUniforms);
+    return Traverser::Apply(compiler, compileOptions, root, symbolTable, specConst, driverUniforms);
 }
 
 }  // namespace sh

src/compiler/translator/tree_ops/RewriteDfdy.h

@@ -26,7 +26,7 @@ class TIntermBinary;
 class TIntermTyped;
 class TSymbolTable;
 class TVariable;
-class FlipRotateSpecConst;
+class SpecConst;
 class DriverUniform;
 
 // If fragRotation = nullptr, no rotation will be applied.
@@ -35,7 +35,7 @@ ANGLE_NO_DISCARD bool RewriteDfdy(TCompiler *compiler,
                                   TIntermNode *root,
                                   const TSymbolTable &symbolTable,
                                   int shaderVersion,
-                                  FlipRotateSpecConst *rotationSpecConst,
+                                  SpecConst *specConst,
                                   const DriverUniform *driverUniforms);
 
 }  // namespace sh

src/compiler/translator/tree_ops/RewriteInterpolateAtOffset.cpp

@@ -13,9 +13,9 @@
 #include "compiler/translator/SymbolTable.h"
 #include "compiler/translator/TranslatorVulkan.h"
 #include "compiler/translator/tree_util/DriverUniform.h"
-#include "compiler/translator/tree_util/FlipRotateSpecConst.h"
 #include "compiler/translator/tree_util/IntermNode_util.h"
 #include "compiler/translator/tree_util/IntermTraverse.h"
+#include "compiler/translator/tree_util/SpecializationConstant.h"
 
 namespace sh
 {
@@ -31,33 +31,33 @@ class Traverser : public TIntermTraverser
                                        TIntermNode *root,
                                        const TSymbolTable &symbolTable,
                                        int ShaderVersion,
-                                       FlipRotateSpecConst *rotationSpecConst,
+                                       SpecConst *specConst,
                                        const DriverUniform *driverUniforms);
 
   private:
     Traverser(TSymbolTable *symbolTable,
               ShCompileOptions compileOptions,
               int shaderVersion,
-              FlipRotateSpecConst *rotationSpecConst,
+              SpecConst *specConst,
               const DriverUniform *driverUniforms);
     bool visitAggregate(Visit visit, TIntermAggregate *node) override;
 
     const TSymbolTable *symbolTable = nullptr;
     const int shaderVersion;
-    FlipRotateSpecConst *mRotationSpecConst = nullptr;
-    const DriverUniform *mDriverUniforms    = nullptr;
-    bool mUsePreRotation                    = false;
+    SpecConst *mRotationSpecConst        = nullptr;
+    const DriverUniform *mDriverUniforms = nullptr;
+    bool mUsePreRotation                 = false;
 };
 
 Traverser::Traverser(TSymbolTable *symbolTable,
                      ShCompileOptions compileOptions,
                      int shaderVersion,
-                     FlipRotateSpecConst *rotationSpecConst,
+                     SpecConst *specConst,
                      const DriverUniform *driverUniforms)
     : TIntermTraverser(true, false, false, symbolTable),
       symbolTable(symbolTable),
       shaderVersion(shaderVersion),
-      mRotationSpecConst(rotationSpecConst),
+      mRotationSpecConst(specConst),
       mDriverUniforms(driverUniforms),
       mUsePreRotation((compileOptions & SH_ADD_PRE_ROTATION) != 0)
 {}
@@ -68,12 +68,11 @@ bool Traverser::Apply(TCompiler *compiler,
                       TIntermNode *root,
                       const TSymbolTable &symbolTable,
                       int shaderVersion,
-                      FlipRotateSpecConst *rotationSpecConst,
+                      SpecConst *specConst,
                       const DriverUniform *driverUniforms)
 {
     TSymbolTable *pSymbolTable = const_cast<TSymbolTable *>(&symbolTable);
-    Traverser traverser(pSymbolTable, compileOptions, shaderVersion, rotationSpecConst,
-                        driverUniforms);
+    Traverser traverser(pSymbolTable, compileOptions, shaderVersion, specConst, driverUniforms);
     root->traverse(&traverser);
     return traverser.updateTree(compiler, root);
 }
@@ -144,7 +143,7 @@ bool RewriteInterpolateAtOffset(TCompiler *compiler,
                                 TIntermNode *root,
                                 const TSymbolTable &symbolTable,
                                 int shaderVersion,
-                                FlipRotateSpecConst *rotationSpecConst,
+                                SpecConst *specConst,
                                 const DriverUniform *driverUniforms)
 {
     // interpolateAtOffset is only valid in GLSL 3.0 and later.
@@ -153,8 +152,8 @@ bool RewriteInterpolateAtOffset(TCompiler *compiler,
         return true;
     }
 
-    return Traverser::Apply(compiler, compileOptions, root, symbolTable, shaderVersion,
-                            rotationSpecConst, driverUniforms);
+    return Traverser::Apply(compiler, compileOptions, root, symbolTable, shaderVersion, specConst,
+                            driverUniforms);
 }
 
 }  // namespace sh

src/compiler/translator/tree_ops/RewriteInterpolateAtOffset.h

@@ -31,7 +31,7 @@ ANGLE_NO_DISCARD bool RewriteInterpolateAtOffset(TCompiler *compiler,
                                                  TIntermNode *root,
                                                  const TSymbolTable &symbolTable,
                                                  int shaderVersion,
-                                                 FlipRotateSpecConst *rotationSpecConst,
+                                                 SpecConst *specConst,
                                                  const DriverUniform *driverUniforms);
 
 }  // namespace sh

src/compiler/translator/tree_util/FlipRotateSpecConst.h → src/compiler/translator/tree_util/SpecializationConstant.h

@@ -3,12 +3,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
-// FlipRotationSpecConst.h: Add code to generate AST node for flip and rotation matrices and
-// vectors.
+// SpecializationConst.h: Add code to generate AST node for specialization constant.
 //
 
-#ifndef COMPILER_TRANSLATOR_TREEUTIL_FLIPROTATESPECCONST_H_
-#define COMPILER_TRANSLATOR_TREEUTIL_FLIPROTATESPECCONST_H_
+#ifndef COMPILER_TRANSLATOR_TREEUTIL_SPECIALIZATIONCONSTANT_H_
+#define COMPILER_TRANSLATOR_TREEUTIL_SPECIALIZATIONCONSTANT_H_
 
 #include "common/angleutils.h"
 #include "compiler/translator/Compiler.h"
@@ -21,12 +20,16 @@ class TVariable;
 namespace sh
 {
 
-class FlipRotateSpecConst
+class SpecConst
 {
   public:
-    FlipRotateSpecConst();
-    ~FlipRotateSpecConst();
+    SpecConst(TSymbolTable *symbolTable, ShCompileOptions compileOptions);
+    virtual ~SpecConst();
 
+    // Line rasterizaton emulation
+    TIntermSymbol *getLineRasterEmulation();
+
+    // Flip/rotation
     TIntermTyped *getMultiplierXForDFdx();
     TIntermTyped *getMultiplierYForDFdx();
     TIntermTyped *getMultiplierXForDFdy();
@@ -36,24 +39,28 @@ class FlipRotateSpecConst
     TIntermTyped *getFlipXY();
     TIntermTyped *getNegFlipXY();
     TIntermTyped *getFlipY();
-    TIntermTyped *getNegFlipY();
     TIntermTyped *getFragRotationMultiplyFlipXY();
+
+    // Half render area
     TIntermBinary *getHalfRenderArea();
-    TIntermTyped *getHalfRenderAreaRotationMatrix();
 
-    void generateSymbol(TSymbolTable *symbolTable);
     void outputLayoutString(TInfoSinkBase &sink) const;
     SpecConstUsageBits getSpecConstUsageBits() const { return mUsageBits; }
 
   private:
+    TIntermSymbol *getFlipRotation();
+    TIntermTyped *getNegFlipY();
     TIntermSymbol *getDrawableWidth();
     TIntermSymbol *getDrawableHeight();
+    TIntermTyped *getHalfRenderAreaRotationMatrix();
 
+    // If unsupported, this should be set to null.
     TSymbolTable *mSymbolTable;
-    TIntermSymbol *mSpecConstSymbol;
+    ShCompileOptions mCompileOptions;
+
     // Bit is set if YFlip or Rotation has been used
     SpecConstUsageBits mUsageBits;
 };
 }  // namespace sh
 
-#endif  // COMPILER_TRANSLATOR_TREEUTIL_FLIPROTATESPECCONST_H_
+#endif  // COMPILER_TRANSLATOR_TREEUTIL_SPECIALIZATIONCONSTANT_H_

src/libANGLE/renderer/vulkan/ShaderVk.cpp

@@ -75,7 +75,7 @@ std::shared_ptr<WaitableCompileEvent> ShaderVk::compile(const gl::Context *conte
     // Let compiler use specialized constant for pre-rotation.
     if (!contextVk->getFeatures().forceDriverUniformOverSpecConst.enabled)
     {
-        compileOptions |= SH_USE_ROTATION_SPECIALIZATION_CONSTANT;
+        compileOptions |= SH_USE_SPECIALIZATION_CONSTANT;
     }
 
     if (contextVk->getFeatures().enablePreRotateSurfaces.enabled ||