Vulkan: Let shader use rotation specialized constant

include/GLSLANG/ShaderLang.h

@@ -26,7 +26,7 @@
 
 // Version number for shader translation API.
 // It is incremented every time the API changes.
-#define ANGLE_SH_VERSION 239
+#define ANGLE_SH_VERSION 240
 
 enum ShShaderSpec
 {
@@ -341,6 +341,9 @@ const ShCompileOptions SH_EARLY_FRAGMENT_TESTS_OPTIMIZATION = UINT64_C(1) << 55;
 // Allow compiler to insert Android pre-rotation code.
 const ShCompileOptions SH_ADD_PRE_ROTATION = UINT64_C(1) << 56;
 
+// Allow compiler to use specialization constant to do pre-rotation and y flip.
+const ShCompileOptions SH_USE_ROTATION_SPECIALIZATION_CONSTANT = UINT64_C(1) << 57;
+
 // Defines alternate strategies for implementing array index clamping.
 enum ShArrayIndexClampingStrategy
 {
@@ -780,6 +783,21 @@ enum class SpecializationConstantId : uint32_t
     EnumCount   = InvalidEnum,
 };
 
+enum class SurfaceRotation : uint32_t
+{
+    Identity,
+    Rotated90Degrees,
+    Rotated180Degrees,
+    Rotated270Degrees,
+    FlippedIdentity,
+    FlippedRotated90Degrees,
+    FlippedRotated180Degrees,
+    FlippedRotated270Degrees,
+
+    InvalidEnum,
+    EnumCount = InvalidEnum,
+};
+
 // Interface block name containing the aggregate default uniforms
 extern const char kDefaultUniformsNameVS[];
 extern const char kDefaultUniformsNameTCS[];

src/compiler.gni

@@ -216,6 +216,8 @@ 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",

src/compiler/translator/TranslatorMetal.cpp

@@ -64,7 +64,7 @@ TIntermBinary *CreateDriverUniformRef(const TVariable *driverUniforms, const cha
 ANGLE_NO_DISCARD bool AppendVertexShaderPositionYCorrectionToMain(TCompiler *compiler,
                                                                   TIntermBlock *root,
                                                                   TSymbolTable *symbolTable,
-                                                                  TIntermSwizzle *negFlipY)
+                                                                  TIntermTyped *negFlipY)
 {
     // Create a symbol reference to "gl_Position"
     const TVariable *position  = BuiltInVariable::gl_Position();
@@ -151,7 +151,7 @@ bool TranslatorMetal::translate(TIntermBlock *root,
 
     if (getShaderType() == GL_VERTEX_SHADER)
     {
-        auto negFlipY = getDriverUniformNegFlipYRef(driverUniforms);
+        TIntermTyped *negFlipY = GetDriverUniformNegFlipYRef(driverUniforms);
 
         // Append gl_Position.y correction to main
         if (!AppendVertexShaderPositionYCorrectionToMain(this, root, &getSymbolTable(), negFlipY))

src/compiler/translator/TranslatorVulkan.h

@@ -24,15 +24,20 @@ class TranslatorVulkan : public TCompiler
   public:
     TranslatorVulkan(sh::GLenum type, ShShaderSpec spec);
 
+    static TIntermTyped *GetDriverUniformFlipXYRef(const TVariable *driverUniforms);
+    static TIntermTyped *GetDriverUniformNegFlipYRef(const TVariable *driverUniforms);
+    static TIntermTyped *GetDriverUniformFragRotationMatrixRef(const TVariable *driverUniforms);
+    static TIntermTyped *GetDriverUniformPreRotationMatrixRef(const TVariable *driverUniforms);
+
   protected:
     ANGLE_NO_DISCARD bool translate(TIntermBlock *root,
                                     ShCompileOptions compileOptions,
                                     PerformanceDiagnostics *perfDiagnostics) override;
     bool shouldFlattenPragmaStdglInvariantAll() override;
 
-    TIntermSwizzle *getDriverUniformNegFlipYRef(const TVariable *driverUniforms) const;
     TIntermBinary *getDriverUniformDepthRangeReservedFieldRef(
         const TVariable *driverUniforms) const;
+
     // Subclass can call this method to transform the AST before writing the final output.
     // See TranslatorMetal.cpp.
     ANGLE_NO_DISCARD bool translateImpl(TIntermBlock *root,

src/compiler/translator/tree_ops/RewriteDfdy.cpp

@@ -11,6 +11,8 @@
 #include "common/angleutils.h"
 #include "compiler/translator/StaticType.h"
 #include "compiler/translator/SymbolTable.h"
+#include "compiler/translator/TranslatorVulkan.h"
+#include "compiler/translator/tree_util/FlipRotateSpecConst.h"
 #include "compiler/translator/tree_util/IntermNode_util.h"
 #include "compiler/translator/tree_util/IntermTraverse.h"
 
@@ -24,44 +26,54 @@ class Traverser : public TIntermTraverser
 {
   public:
     ANGLE_NO_DISCARD static bool Apply(TCompiler *compiler,
+                                       ShCompileOptions compileOptions,
                                        TIntermNode *root,
                                        const TSymbolTable &symbolTable,
-                                       TIntermBinary *flipXY,
-                                       TIntermTyped *fragRotation);
+                                       FlipRotateSpecConst *rotationSpecConst,
+                                       const TVariable *driverUniforms);
 
   private:
-    Traverser(TIntermBinary *flipXY, TIntermTyped *fragRotation, TSymbolTable *symbolTable);
+    Traverser(TSymbolTable *symbolTable,
+              ShCompileOptions compileOptions,
+              FlipRotateSpecConst *rotationSpecConst,
+              const TVariable *driverUniforms);
     bool visitUnary(Visit visit, TIntermUnary *node) override;
 
     bool visitUnaryWithRotation(Visit visit, TIntermUnary *node);
     bool visitUnaryWithoutRotation(Visit visit, TIntermUnary *node);
 
-    TIntermBinary *mFlipXY      = nullptr;
-    TIntermTyped *mFragRotation = nullptr;
+    FlipRotateSpecConst *mRotationSpecConst = nullptr;
+    const TVariable *mDriverUniforms        = nullptr;
+    bool mUsePreRotation                    = false;
 };
 
-Traverser::Traverser(TIntermBinary *flipXY, TIntermTyped *fragRotation, TSymbolTable *symbolTable)
+Traverser::Traverser(TSymbolTable *symbolTable,
+                     ShCompileOptions compileOptions,
+                     FlipRotateSpecConst *rotationSpecConst,
+                     const TVariable *driverUniforms)
     : TIntermTraverser(true, false, false, symbolTable),
-      mFlipXY(flipXY),
-      mFragRotation(fragRotation)
+      mRotationSpecConst(rotationSpecConst),
+      mDriverUniforms(driverUniforms),
+      mUsePreRotation(compileOptions & SH_ADD_PRE_ROTATION)
 {}
 
 // static
 bool Traverser::Apply(TCompiler *compiler,
+                      ShCompileOptions compileOptions,
                       TIntermNode *root,
                       const TSymbolTable &symbolTable,
-                      TIntermBinary *flipXY,
-                      TIntermTyped *fragRotation)
+                      FlipRotateSpecConst *rotationSpecConst,
+                      const TVariable *driverUniforms)
 {
     TSymbolTable *pSymbolTable = const_cast<TSymbolTable *>(&symbolTable);
-    Traverser traverser(flipXY, fragRotation, pSymbolTable);
+    Traverser traverser(pSymbolTable, compileOptions, rotationSpecConst, driverUniforms);
     root->traverse(&traverser);
     return traverser.updateTree(compiler, root);
 }
 
 bool Traverser::visitUnary(Visit visit, TIntermUnary *node)
 {
-    if (mFragRotation)
+    if (mUsePreRotation)
     {
         return visitUnaryWithRotation(visit, node);
     }
@@ -102,36 +114,52 @@ bool Traverser::visitUnaryWithRotation(Visit visit, TIntermUnary *node)
     //
     //   correctedDfdx(operand) = dFdy(operand) * mFlipXY.y
     //   correctedDfdy(operand) = dFdx(operand) * mFlipXY.x
-    //
-    // TODO(ianelliott): Look at the performance of this approach and potentially optimize it
-    // http://anglebug.com/4678
 
-    // Get a vec2 with the correct half of ANGLEUniforms.fragRotation
-    TIntermBinary *halfRotationMat = nullptr;
+    TIntermTyped *multiplierX;
+    TIntermTyped *multiplierY;
     if (node->getOp() == EOpDFdx)
     {
-        halfRotationMat =
-            new TIntermBinary(EOpIndexDirect, mFragRotation->deepCopy(), CreateIndexNode(0));
+        multiplierX = mRotationSpecConst->getMultiplierXForDFdx();
+        multiplierY = mRotationSpecConst->getMultiplierYForDFdx();
     }
     else
     {
-        halfRotationMat =
-            new TIntermBinary(EOpIndexDirect, mFragRotation->deepCopy(), CreateIndexNode(1));
+        multiplierX = mRotationSpecConst->getMultiplierXForDFdy();
+        multiplierY = mRotationSpecConst->getMultiplierYForDFdy();
     }
 
-    // Multiply halfRotationMat by ANGLEUniforms.flipXY and store in a temporary variable
-    TIntermBinary *rotatedFlipXY = new TIntermBinary(EOpMul, mFlipXY->deepCopy(), halfRotationMat);
-    const TType *vec2Type        = StaticType::GetBasic<EbtFloat, 2>();
-    TIntermSymbol *tmpRotFlipXY  = new TIntermSymbol(CreateTempVariable(mSymbolTable, vec2Type));
-    TIntermSequence *tmpDecl     = new TIntermSequence;
-    tmpDecl->push_back(CreateTempInitDeclarationNode(&tmpRotFlipXY->variable(), rotatedFlipXY));
-    insertStatementsInParentBlock(*tmpDecl);
-
-    // Get the .x and .y swizzles to use as multipliers
-    TVector<int> swizzleOffsetX = {0};
-    TVector<int> swizzleOffsetY = {1};
-    TIntermSwizzle *multiplierX = new TIntermSwizzle(tmpRotFlipXY, swizzleOffsetX);
-    TIntermSwizzle *multiplierY = new TIntermSwizzle(tmpRotFlipXY->deepCopy(), swizzleOffsetY);
+    if (!multiplierX)
+    {
+        ASSERT(!multiplierY);
+        TIntermTyped *flipXY = TranslatorVulkan::GetDriverUniformFlipXYRef(mDriverUniforms);
+        TIntermTyped *fragRotation =
+            TranslatorVulkan::GetDriverUniformFragRotationMatrixRef(mDriverUniforms);
+
+        // Get a vec2 with the correct half of ANGLEUniforms.fragRotation
+        TIntermBinary *halfRotationMat = nullptr;
+        if (node->getOp() == EOpDFdx)
+        {
+            halfRotationMat = new TIntermBinary(EOpIndexDirect, fragRotation, CreateIndexNode(0));
+        }
+        else
+        {
+            halfRotationMat = new TIntermBinary(EOpIndexDirect, fragRotation, CreateIndexNode(1));
+        }
+
+        // Multiply halfRotationMat by ANGLEUniforms.flipXY and store in a temporary variable
+        TIntermBinary *rotatedFlipXY = new TIntermBinary(EOpMul, flipXY, halfRotationMat);
+        const TType *vec2Type        = StaticType::GetBasic<EbtFloat, 2>();
+        TIntermSymbol *tmpRotFlipXY = new TIntermSymbol(CreateTempVariable(mSymbolTable, vec2Type));
+        TIntermSequence *tmpDecl    = new TIntermSequence;
+        tmpDecl->push_back(CreateTempInitDeclarationNode(&tmpRotFlipXY->variable(), rotatedFlipXY));
+        insertStatementsInParentBlock(*tmpDecl);
+
+        // Get the .x and .y swizzles to use as multipliers
+        TVector<int> swizzleOffsetX = {0};
+        TVector<int> swizzleOffsetY = {1};
+        multiplierX                 = new TIntermSwizzle(tmpRotFlipXY, swizzleOffsetX);
+        multiplierY                 = new TIntermSwizzle(tmpRotFlipXY->deepCopy(), swizzleOffsetY);
+    }
 
     // Get the results of dFdx(operand) and dFdy(operand), and multiply them by the swizzles
     TIntermTyped *operand = node->getOperand();
@@ -166,8 +194,13 @@ bool Traverser::visitUnaryWithoutRotation(Visit visit, TIntermUnary *node)
     size_t objectSize    = node->getType().getObjectSize();
     TOperator multiplyOp = (objectSize == 1) ? EOpMul : EOpVectorTimesScalar;
 
-    TIntermBinary *flipY =
-        new TIntermBinary(EOpIndexDirect, mFlipXY->deepCopy(), CreateIndexNode(1));
+    TIntermTyped *flipY = mRotationSpecConst->getFlipY();
+    if (!flipY)
+    {
+        TIntermTyped *flipXY = TranslatorVulkan::GetDriverUniformFlipXYRef(mDriverUniforms);
+        flipY                = new TIntermBinary(EOpIndexDirect, flipXY, CreateIndexNode(1));
+    }
+
     // Correct dFdy()'s value:
     // (dFdy() * mFlipXY.y)
     TIntermBinary *correctedDfdy = new TIntermBinary(multiplyOp, newDfdy, flipY);
@@ -177,21 +210,22 @@ bool Traverser::visitUnaryWithoutRotation(Visit visit, TIntermUnary *node)
 
     return true;
 }
-
 }  // anonymous namespace
 
 bool RewriteDfdy(TCompiler *compiler,
+                 ShCompileOptions compileOptions,
                  TIntermNode *root,
                  const TSymbolTable &symbolTable,
                  int shaderVersion,
-                 TIntermBinary *flipXY,
-                 TIntermTyped *fragRotation)
+                 FlipRotateSpecConst *rotationSpecConst,
+                 const TVariable *driverUniforms)
 {
     // dFdy is only valid in GLSL 3.0 and later.
     if (shaderVersion < 300)
         return true;
 
-    return Traverser::Apply(compiler, root, symbolTable, flipXY, fragRotation);
+    return Traverser::Apply(compiler, compileOptions, root, symbolTable, rotationSpecConst,
+                            driverUniforms);
 }
 
 }  // namespace sh

src/compiler/translator/tree_ops/RewriteDfdy.h

@@ -14,23 +14,28 @@
 #define COMPILER_TRANSLATOR_TREEOPS_FLIP_DFDY_H_
 
 #include "common/angleutils.h"
+#include "compiler/translator/Compiler.h"
 
 namespace sh
 {
 
 class TCompiler;
 class TIntermNode;
+class TIntermSymbol;
 class TIntermBinary;
 class TIntermTyped;
 class TSymbolTable;
+class TVariable;
+class FlipRotateSpecConst;
 
 // If fragRotation = nullptr, no rotation will be applied.
 ANGLE_NO_DISCARD bool RewriteDfdy(TCompiler *compiler,
+                                  ShCompileOptions compileOptions,
                                   TIntermNode *root,
                                   const TSymbolTable &symbolTable,
                                   int shaderVersion,
-                                  TIntermBinary *flipXY,
-                                  TIntermTyped *fragRotation);
+                                  FlipRotateSpecConst *rotationSpecConst,
+                                  const TVariable *driverUniforms);
 
 }  // namespace sh
 

src/compiler/translator/tree_util/FlipRotateSpecConst.h

+//
+// Copyright 2020 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.
+//
+// FlipRotationSpecConst.h: Add code to generate AST node for flip and rotation matrices and
+// vectors.
+//
+
+#ifndef COMPILER_TRANSLATOR_TREEUTIL_FLIPROTATESPECCONST_H_
+#define COMPILER_TRANSLATOR_TREEUTIL_FLIPROTATESPECCONST_H_
+
+#include "common/angleutils.h"
+#include "compiler/translator/SymbolTable.h"
+
+class TIntermTyped;
+class TIntermSymbol;
+class TVariable;
+
+namespace sh
+{
+
+class FlipRotateSpecConst
+{
+  public:
+    FlipRotateSpecConst();
+    ~FlipRotateSpecConst();
+
+    TIntermTyped *getMultiplierXForDFdx();
+    TIntermTyped *getMultiplierYForDFdx();
+    TIntermTyped *getMultiplierXForDFdy();
+    TIntermTyped *getMultiplierYForDFdy();
+    TIntermTyped *getPreRotationMatrix();
+    TIntermTyped *getFragRotationMatrix();
+    TIntermTyped *getFlipXY();
+    TIntermTyped *getNegFlipXY();
+    TIntermTyped *getFlipY();
+    TIntermTyped *getNegFlipY();
+
+    void generateSymbol(TSymbolTable *symbolTable);
+    void outputLayoutString(TInfoSinkBase &sink) const;
+
+  private:
+    TIntermSymbol *mSpecConstSymbol;
+    // True if mSpecConstSymbol has been used
+    bool mReferenced;
+};
+}  // namespace sh
+
+#endif  // COMPILER_TRANSLATOR_TREEUTIL_FLIPROTATESPECCONST_H_

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -3127,13 +3127,23 @@ void ContextVk::updateSurfaceRotationDrawFramebuffer(const gl::State &glState)
     mCurrentRotationDrawFramebuffer =
         DetermineSurfaceRotation(drawFramebuffer, mCurrentWindowSurface);
 
-    if (mCurrentRotationDrawFramebuffer != mGraphicsPipelineDesc->getSurfaceRotation())
+    // DetermineSurfaceRotation() does not encode yflip information. Shader code uses
+    // SurfaceRotation specialization constant to determine yflip as well. We add yflip information
+    // to the SurfaceRotation here so the shader does yflip properly.
+    SurfaceRotation rotationAndFlip = mCurrentRotationDrawFramebuffer;
+    if (isViewportFlipEnabledForDrawFBO())
+    {
+        ASSERT(ToUnderlying(rotationAndFlip) < ToUnderlying(SurfaceRotation::FlippedIdentity));
+        rotationAndFlip = static_cast<SurfaceRotation>(
+            ToUnderlying(SurfaceRotation::FlippedIdentity) + ToUnderlying(rotationAndFlip));
+    }
+
+    if (rotationAndFlip != mGraphicsPipelineDesc->getSurfaceRotation())
     {
         // surface rotation are specialization constants, which affects program compilation. When
         // rotation changes, we need to update GraphicsPipelineDesc so that the correct pipeline
         // program object will be retrieved.
-        mGraphicsPipelineDesc->updateSurfaceRotation(&mGraphicsPipelineTransition,
-                                                     mCurrentRotationDrawFramebuffer);
+        mGraphicsPipelineDesc->updateSurfaceRotation(&mGraphicsPipelineTransition, rotationAndFlip);
     }
 }
 

src/libANGLE/renderer/vulkan/ShaderVk.cpp

@@ -72,6 +72,9 @@ std::shared_ptr<WaitableCompileEvent> ShaderVk::compile(const gl::Context *conte
     // context state does not allow it
     compileOptions |= SH_EARLY_FRAGMENT_TESTS_OPTIMIZATION;
 
+    // Let compiler use specialized constant for pre-rotation.
+    compileOptions |= SH_USE_ROTATION_SPECIALIZATION_CONSTANT;
+
     if (contextVk->getFeatures().enablePreRotateSurfaces.enabled ||
         contextVk->getFeatures().emulatedPrerotation90.enabled ||
         contextVk->getFeatures().emulatedPrerotation180.enabled ||

src/tests/deqp_support/deqp_gles2_test_expectations.txt

@@ -359,6 +359,12 @@
 4344 VULKAN ANDROID : dEQP-GLES2.functional.fragment_ops.random.62 = FAIL
 4344 VULKAN ANDROID : dEQP-GLES2.functional.fragment_ops.random.78 = FAIL
 
+// Failing on the Pixel2.
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES2.functional.shaders.indexing.tmp_array.float_const_write_dynamic_read_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES2.functional.shaders.indexing.tmp_array.vec2_const_write_dynamic_read_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES2.functional.shaders.indexing.tmp_array.vec3_const_write_dynamic_read_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES2.functional.shaders.indexing.tmp_array.vec4_const_write_dynamic_read_vertex = FAIL
+
 // These tests also fail on AMD windows driver as it is not allowed to use emulation due to errors.
 3243 VULKAN WIN AMD : dEQP-GLES2.functional.shaders.texture_functions.vertex.texturecubelod = FAIL
 3243 VULKAN WIN AMD : dEQP-GLES2.functional.texture.mipmap.cube.basic.linear_nearest = FAIL

src/tests/deqp_support/deqp_gles31_test_expectations.txt

@@ -292,3 +292,7 @@
 // Vulkan Android failures with these formats
 5277 VULKAN ANDROID : dEQP-GLES31.functional.copy_image.non_compressed.viewclass_32_bits.rgba8_snorm_rgb10_a2* = FAIL
 5277 VULKAN ANDROID : dEQP-GLES31.functional.copy_image.non_compressed.viewclass_32_bits.rgba8_snorm_rgb9_e5* = FAIL
+
+// Skip on Pixel2 to reduce the bots test time so that it won't timeout
+172936025 VULKAN PIXEL2ORXL : dEQP-GLES31.functional.copy_image.mixed.viewclass_128_bits_mixed.*.* = SKIP
+172936025 VULKAN PIXEL2ORXL : dEQP-GLES31.functional.copy_image.compressed.viewclass_astc*.*.* = SKIP

src/tests/deqp_support/deqp_gles3_test_expectations.txt

@@ -642,6 +642,13 @@
 // 161540999 PIXEL2ORXL VULKAN : dEQP-GLES3.functional.fragment_ops.random.35 = FAIL
 4344 VULKAN ANDROID : dEQP-GLES3.functional.fragment_ops.random.73 = FAIL
 
+// Failing on the Pixel2.
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES3.functional.shaders.large_constant_arrays.indexing.float_128_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES3.functional.shaders.large_constant_arrays.indexing.float_64_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES3.functional.shaders.large_constant_arrays.indexing.vec4_128_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES3.functional.shaders.large_constant_arrays.indexing.vec4_16_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES3.functional.shaders.large_constant_arrays.indexing.vec4_32_vertex = FAIL
+172932466 VULKAN PIXEL2ORXL : dEQP-GLES3.functional.shaders.large_constant_arrays.indexing.vec4_64_vertex = FAIL
 
 // Fails only with SwiftShader: