Revert "Vulkan: Generate gl_Position pre-rotation in SPIR-V"

src/compiler/translator/TranslatorVulkan.cpp

@@ -305,6 +305,39 @@ ANGLE_NO_DISCARD bool AppendVertexShaderDepthCorrectionToMain(TCompiler *compile
     return RunAtTheEndOfShader(compiler, root, assignment, symbolTable);
 }
 
+// This operation performs Android pre-rotation and y-flip.  For Android (and potentially other
+// platforms), the device may rotate, such that the orientation of the application is rotated
+// relative to the native orientation of the device.  This is corrected in part by multiplying
+// gl_Position by a mat2.
+// The equations reduce to an expression:
+//
+//     gl_Position.xy = gl_Position.xy * preRotation
+ANGLE_NO_DISCARD bool AppendPreRotation(TCompiler *compiler,
+                                        TIntermBlock *root,
+                                        TSymbolTable *symbolTable,
+                                        SpecConst *specConst,
+                                        const DriverUniform *driverUniforms)
+{
+    TIntermTyped *preRotationRef = specConst->getPreRotationMatrix();
+    if (!preRotationRef)
+    {
+        preRotationRef = driverUniforms->getPreRotationMatrixRef();
+    }
+    TIntermSymbol *glPos         = new TIntermSymbol(BuiltInVariable::gl_Position());
+    TVector<int> swizzleOffsetXY = {0, 1};
+    TIntermSwizzle *glPosXY      = new TIntermSwizzle(glPos, swizzleOffsetXY);
+
+    // Create the expression "(gl_Position.xy * preRotation)"
+    TIntermBinary *zRotated = new TIntermBinary(EOpMatrixTimesVector, preRotationRef, glPosXY);
+
+    // Create the assignment "gl_Position.xy = (gl_Position.xy * preRotation)"
+    TIntermBinary *assignment =
+        new TIntermBinary(TOperator::EOpAssign, glPosXY->deepCopy(), zRotated);
+
+    // Append the assignment as a statement at the end of the shader.
+    return RunAtTheEndOfShader(compiler, root, assignment, symbolTable);
+}
+
 ANGLE_NO_DISCARD bool AppendTransformFeedbackOutputToMain(TCompiler *compiler,
                                                           TIntermBlock *root,
                                                           TSymbolTable *symbolTable)
@@ -1123,6 +1156,11 @@ bool TranslatorVulkan::translateImpl(TIntermBlock *root,
             {
                 return false;
             }
+            if ((compileOptions & SH_ADD_PRE_ROTATION) != 0 &&
+                !AppendPreRotation(this, root, &getSymbolTable(), specConst, driverUniforms))
+            {
+                return false;
+            }
             break;
         }
 

src/compiler/translator/tree_util/DriverUniform.cpp

@@ -36,6 +36,7 @@ constexpr const char kNumSamples[]             = "numSamples";
 constexpr const char kHalfRenderArea[] = "halfRenderArea";
 constexpr const char kFlipXY[]         = "flipXY";
 constexpr const char kNegFlipXY[]      = "negFlipXY";
+constexpr const char kPreRotation[]    = "preRotation";
 constexpr const char kFragRotation[]   = "fragRotation";
 }  // anonymous namespace
 
@@ -217,9 +218,10 @@ TFieldList *DriverUniformExtended::createUniformFields(TSymbolTable *symbolTable
 {
     TFieldList *driverFieldList = DriverUniform::createUniformFields(symbolTable);
 
-    constexpr size_t kNumGraphicsDriverUniformsExt = 4;
+    constexpr size_t kNumGraphicsDriverUniformsExt = 5;
     constexpr std::array<const char *, kNumGraphicsDriverUniformsExt>
-        kGraphicsDriverUniformNamesExt = {{kHalfRenderArea, kFlipXY, kNegFlipXY, kFragRotation}};
+        kGraphicsDriverUniformNamesExt = {
+            {kHalfRenderArea, kFlipXY, kNegFlipXY, kPreRotation, kFragRotation}};
 
     const std::array<TType *, kNumGraphicsDriverUniformsExt> kDriverUniformTypesExt = {{
         new TType(EbtFloat, 2),
@@ -227,6 +229,7 @@ TFieldList *DriverUniformExtended::createUniformFields(TSymbolTable *symbolTable
         new TType(EbtFloat, 2),
         // NOTE: There's a vec2 gap here that can be used in the future
         new TType(EbtFloat, 2, 2),
+        new TType(EbtFloat, 2, 2),
     }};
 
     for (size_t uniformIndex = 0; uniformIndex < kNumGraphicsDriverUniformsExt; ++uniformIndex)
@@ -265,6 +268,11 @@ TIntermBinary *DriverUniformExtended::getFragRotationMatrixRef() const
     return createDriverUniformRef(kFragRotation);
 }
 
+TIntermBinary *DriverUniformExtended::getPreRotationMatrixRef() const
+{
+    return createDriverUniformRef(kPreRotation);
+}
+
 TIntermBinary *DriverUniformExtended::getHalfRenderAreaRef() const
 {
     return createDriverUniformRef(kHalfRenderArea);

src/compiler/translator/tree_util/DriverUniform.h

@@ -44,6 +44,7 @@ class DriverUniform
     virtual TIntermBinary *getFlipXYRef() const { return nullptr; }
     virtual TIntermBinary *getNegFlipXYRef() const { return nullptr; }
     virtual TIntermBinary *getFragRotationMatrixRef() const { return nullptr; }
+    virtual TIntermBinary *getPreRotationMatrixRef() const { return nullptr; }
     virtual TIntermBinary *getHalfRenderAreaRef() const { return nullptr; }
     virtual TIntermSwizzle *getNegFlipYRef() const { return nullptr; }
 
@@ -64,6 +65,7 @@ class DriverUniformExtended : public DriverUniform
     TIntermBinary *getFlipXYRef() const override;
     TIntermBinary *getNegFlipXYRef() const override;
     TIntermBinary *getFragRotationMatrixRef() const override;
+    TIntermBinary *getPreRotationMatrixRef() const override;
     TIntermBinary *getHalfRenderAreaRef() const override;
     TIntermSwizzle *getNegFlipYRef() const override;
 

src/compiler/translator/tree_util/SpecializationConstant.cpp

@@ -35,6 +35,16 @@ using Mat2x2 = std::array<float, 4>;
 using Mat2x2EnumMap =
     angle::PackedEnumMap<vk::SurfaceRotation, Mat2x2, angle::EnumSize<vk::SurfaceRotation>()>;
 
+constexpr Mat2x2EnumMap kPreRotationMatrices = {
+    {{vk::SurfaceRotation::Identity, {{1.0f, 0.0f, 0.0f, 1.0f}}},
+     {vk::SurfaceRotation::Rotated90Degrees, {{0.0f, -1.0f, 1.0f, 0.0f}}},
+     {vk::SurfaceRotation::Rotated180Degrees, {{-1.0f, 0.0f, 0.0f, -1.0f}}},
+     {vk::SurfaceRotation::Rotated270Degrees, {{0.0f, 1.0f, -1.0f, 0.0f}}},
+     {vk::SurfaceRotation::FlippedIdentity, {{1.0f, 0.0f, 0.0f, 1.0f}}},
+     {vk::SurfaceRotation::FlippedRotated90Degrees, {{0.0f, -1.0f, 1.0f, 0.0f}}},
+     {vk::SurfaceRotation::FlippedRotated180Degrees, {{-1.0f, 0.0f, 0.0f, -1.0f}}},
+     {vk::SurfaceRotation::FlippedRotated270Degrees, {{0.0f, 1.0f, -1.0f, 0.0f}}}}};
+
 constexpr Mat2x2EnumMap kFragRotationMatrices = {
     {{vk::SurfaceRotation::Identity, {{1.0f, 0.0f, 0.0f, 1.0f}}},
      {vk::SurfaceRotation::Rotated90Degrees, {{0.0f, 1.0f, 1.0f, 0.0f}}},
@@ -228,13 +238,7 @@ TIntermTyped *CreateFloatArrayWithRotationIndex(const Vec2EnumMap &valuesEnumMap
 
 SpecConst::SpecConst(TSymbolTable *symbolTable, ShCompileOptions compileOptions)
     : mSymbolTable(symbolTable), mCompileOptions(compileOptions)
-{
-    // Mark SpecConstUsage::Rotation unconditionally.  gl_Position is always rotated.
-    if ((mCompileOptions & SH_USE_SPECIALIZATION_CONSTANT) != 0)
-    {
-        mUsageBits.set(vk::SpecConstUsage::Rotation);
-    }
-}
+{}
 
 SpecConst::~SpecConst() {}
 
@@ -333,6 +337,16 @@ TIntermTyped *SpecConst::getMultiplierYForDFdy()
     return CreateFloatArrayWithRotationIndex(kRotatedFlipXYForDFdy, 1, 1, getFlipRotation());
 }
 
+TIntermTyped *SpecConst::getPreRotationMatrix()
+{
+    if (!(mCompileOptions & SH_USE_SPECIALIZATION_CONSTANT))
+    {
+        return nullptr;
+    }
+    mUsageBits.set(vk::SpecConstUsage::Rotation);
+    return GenerateMat2x2ArrayWithIndex(kPreRotationMatrices, getFlipRotation());
+}
+
 TIntermTyped *SpecConst::getFragRotationMatrix()
 {
     if (!(mCompileOptions & SH_USE_SPECIALIZATION_CONSTANT))

src/compiler/translator/tree_util/SpecializationConstant.h

@@ -34,6 +34,7 @@ class SpecConst
     TIntermTyped *getMultiplierYForDFdx();
     TIntermTyped *getMultiplierXForDFdy();
     TIntermTyped *getMultiplierYForDFdy();
+    TIntermTyped *getPreRotationMatrix();
     TIntermTyped *getFragRotationMatrix();
     TIntermTyped *getFlipXY();
     TIntermTyped *getNegFlipXY();

src/libANGLE/renderer/glslang_wrapper_utils.h

@@ -12,7 +12,6 @@
 #include <functional>
 
 #include "libANGLE/renderer/ProgramImpl.h"
-#include "libANGLE/renderer/renderer_utils.h"
 
 namespace rx
 {
@@ -57,7 +56,6 @@ struct GlslangSourceOptions
 struct GlslangSpirvOptions
 {
     gl::ShaderType shaderType                 = gl::ShaderType::InvalidEnum;
-    SurfaceRotation preRotation               = SurfaceRotation::Identity;
     bool removeEarlyFragmentTestsOptimization = false;
     bool removeDebugInfo                      = false;
     bool isTransformFeedbackStage             = false;

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -95,6 +95,9 @@ struct GraphicsDriverUniformsExtended
     std::array<float, 2> negFlipXY;
     std::array<int32_t, 2> padding;
 
+    // Used to pre-rotate gl_Position for swapchain images on Android (a mat2, which is padded to
+    // the size of two vec4's).
+    std::array<float, 8> preRotation;
     // Used to pre-rotate gl_FragCoord for swapchain images on Android (a mat2, which is padded to
     // the size of two vec4's).
     std::array<float, 8> fragRotation;
@@ -188,15 +191,34 @@ bool IsRenderPassStartedAndUsesImage(const vk::CommandBufferHelper &renderPassCo
 }
 
 // When an Android surface is rotated differently than the device's native orientation, ANGLE must
-// rotate gl_Position in the last pre-rasterization shader and gl_FragCoord in the fragment shader.
-// Rotation of gl_Position is done in SPIR-V.  The following are the rotation matrices for the
-// fragment shader.
+// rotate gl_Position in the vertex shader and gl_FragCoord in the fragment shader.  The following
+// are the rotation matrices used.
 //
 // Note: these are mat2's that are appropriately padded (4 floats per row).
 using PreRotationMatrixValues = std::array<float, 8>;
 constexpr angle::PackedEnumMap<rx::SurfaceRotation,
                                PreRotationMatrixValues,
                                angle::EnumSize<rx::SurfaceRotation>()>
+    kPreRotationMatrices = {
+        {{rx::SurfaceRotation::Identity, {{1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f}}},
+         {rx::SurfaceRotation::Rotated90Degrees,
+          {{0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f}}},
+         {rx::SurfaceRotation::Rotated180Degrees,
+          {{-1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}},
+         {rx::SurfaceRotation::Rotated270Degrees,
+          {{0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f}}},
+         {rx::SurfaceRotation::FlippedIdentity,
+          {{1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}},
+         {rx::SurfaceRotation::FlippedRotated90Degrees,
+          {{0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f}}},
+         {rx::SurfaceRotation::FlippedRotated180Degrees,
+          {{-1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f}}},
+         {rx::SurfaceRotation::FlippedRotated270Degrees,
+          {{0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f}}}}};
+
+constexpr angle::PackedEnumMap<rx::SurfaceRotation,
+                               PreRotationMatrixValues,
+                               angle::EnumSize<rx::SurfaceRotation>()>
     kFragRotationMatrices = {
         {{rx::SurfaceRotation::Identity, {{1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f}}},
          {rx::SurfaceRotation::Rotated90Degrees,
@@ -3823,6 +3845,9 @@ angle::Result ContextVk::handleDirtyGraphicsDriverUniforms(const gl::Context *co
         driverUniformsExt->halfRenderArea = {halfRenderAreaWidth, halfRenderAreaHeight};
         driverUniformsExt->flipXY         = {flipX, flipY};
         driverUniformsExt->negFlipXY      = {flipX, -flipY};
+        memcpy(&driverUniformsExt->preRotation,
+               &kPreRotationMatrices[mCurrentRotationDrawFramebuffer],
+               sizeof(PreRotationMatrixValues));
         memcpy(&driverUniformsExt->fragRotation,
                &kFragRotationMatrices[mCurrentRotationDrawFramebuffer],
                sizeof(PreRotationMatrixValues));

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -28,15 +28,12 @@ bool ValidateTransformedSpirV(ContextVk *contextVk,
                               const ShaderInterfaceVariableInfoMap &variableInfoMap,
                               const gl::ShaderMap<SpirvBlob> &spirvBlobs)
 {
-    const gl::ShaderType lastPreFragmentStage = gl::GetLastPreFragmentStage(linkedShaderStages);
-
     for (gl::ShaderType shaderType : linkedShaderStages)
     {
         GlslangSpirvOptions options;
         options.shaderType               = shaderType;
-        options.preRotation              = SurfaceRotation::FlippedRotated90Degrees;
         options.removeDebugInfo          = true;
-        options.isTransformFeedbackStage = shaderType == lastPreFragmentStage;
+        options.isTransformFeedbackStage = shaderType == gl::ShaderType::Vertex;
 
         SpirvBlob transformed;
         if (GlslangWrapperVk::TransformSpirV(contextVk, options, variableInfoMap,
@@ -120,7 +117,6 @@ ProgramInfo::~ProgramInfo() = default;
 
 angle::Result ProgramInfo::initProgram(ContextVk *contextVk,
                                        const gl::ShaderType shaderType,
-                                       bool isLastPreFragmentStage,
                                        const ShaderInfo &shaderInfo,
                                        ProgramTransformOptions optionBits,
                                        const ShaderInterfaceVariableInfoMap &variableInfoMap)
@@ -135,12 +131,7 @@ angle::Result ProgramInfo::initProgram(ContextVk *contextVk,
     options.removeEarlyFragmentTestsOptimization =
         shaderType == gl::ShaderType::Fragment && optionBits.removeEarlyFragmentTestsOptimization;
     options.removeDebugInfo          = !contextVk->getRenderer()->getEnableValidationLayers();
-    options.isTransformFeedbackStage = isLastPreFragmentStage;
-
-    if (isLastPreFragmentStage)
-    {
-        options.preRotation = static_cast<SurfaceRotation>(optionBits.surfaceRotation);
-    }
+    options.isTransformFeedbackStage = shaderType == gl::ShaderType::Vertex;
 
     ANGLE_TRY(GlslangWrapperVk::TransformSpirV(contextVk, options, variableInfoMap,
                                                originalSpirvBlob, &transformedSpirvBlob));
@@ -698,18 +689,14 @@ angle::Result ProgramExecutableVk::getGraphicsPipeline(
     mTransformOptions.surfaceRotation           = ToUnderlying(desc.getSurfaceRotation());
 
     // This must be called after mTransformOptions have been set.
-    ProgramInfo &programInfo                  = getGraphicsProgramInfo(mTransformOptions);
-    const gl::ShaderBitSet linkedShaderStages = glExecutable->getLinkedShaderStages();
-    const gl::ShaderType lastPreFragmentStage = gl::GetLastPreFragmentStage(linkedShaderStages);
-
-    for (const gl::ShaderType shaderType : linkedShaderStages)
+    ProgramInfo &programInfo = getGraphicsProgramInfo(mTransformOptions);
+    for (const gl::ShaderType shaderType : glExecutable->getLinkedShaderStages())
     {
         ProgramVk *programVk = getShaderProgram(glState, shaderType);
         if (programVk)
         {
-            ANGLE_TRY(programVk->initGraphicsShaderProgram(
-                contextVk, shaderType, shaderType == lastPreFragmentStage, mTransformOptions,
-                &programInfo, mVariableInfoMap));
+            ANGLE_TRY(programVk->initGraphicsShaderProgram(contextVk, shaderType, mTransformOptions,
+                                                           &programInfo, mVariableInfoMap));
         }
     }
 

src/libANGLE/renderer/vulkan/ProgramExecutableVk.h

@@ -67,7 +67,6 @@ class ProgramInfo final : angle::NonCopyable
 
     angle::Result initProgram(ContextVk *contextVk,
                               const gl::ShaderType shaderType,
-                              bool isLastPreFragmentStage,
                               const ShaderInfo &shaderInfo,
                               ProgramTransformOptions optionBits,
                               const ShaderInterfaceVariableInfoMap &variableInfoMap);

src/libANGLE/renderer/vulkan/ProgramVk.h

@@ -148,13 +148,11 @@ class ProgramVk : public ProgramImpl
     ANGLE_INLINE angle::Result initGraphicsShaderProgram(
         ContextVk *contextVk,
         const gl::ShaderType shaderType,
-        bool isLastPreFragmentStage,
         ProgramTransformOptions optionBits,
         ProgramInfo *programInfo,
         const ShaderInterfaceVariableInfoMap &variableInfoMap)
     {
-        return initProgram(contextVk, shaderType, isLastPreFragmentStage, optionBits, programInfo,
-                           variableInfoMap);
+        return initProgram(contextVk, shaderType, optionBits, programInfo, variableInfoMap);
     }
 
     ANGLE_INLINE angle::Result initComputeProgram(
@@ -163,7 +161,7 @@ class ProgramVk : public ProgramImpl
         const ShaderInterfaceVariableInfoMap &variableInfoMap)
     {
         ProgramTransformOptions optionBits = {};
-        return initProgram(contextVk, gl::ShaderType::Compute, false, optionBits, programInfo,
+        return initProgram(contextVk, gl::ShaderType::Compute, optionBits, programInfo,
                            variableInfoMap);
     }
 
@@ -196,7 +194,6 @@ class ProgramVk : public ProgramImpl
 
     ANGLE_INLINE angle::Result initProgram(ContextVk *contextVk,
                                            const gl::ShaderType shaderType,
-                                           bool isLastPreFragmentStage,
                                            ProgramTransformOptions optionBits,
                                            ProgramInfo *programInfo,
                                            const ShaderInterfaceVariableInfoMap &variableInfoMap)
@@ -207,8 +204,8 @@ class ProgramVk : public ProgramImpl
         // specialization constants.
         if (!programInfo->valid(shaderType))
         {
-            ANGLE_TRY(programInfo->initProgram(contextVk, shaderType, isLastPreFragmentStage,
-                                               mOriginalShaderInfo, optionBits, variableInfoMap));
+            ANGLE_TRY(programInfo->initProgram(contextVk, shaderType, mOriginalShaderInfo,
+                                               optionBits, variableInfoMap));
         }
         ASSERT(programInfo->valid(shaderType));
 

src/tests/egl_tests/EGLPreRotationTest.cpp

@@ -109,11 +109,11 @@ class EGLPreRotationSurfaceTest : public ANGLETestWithParam<EGLPreRotationSurfac
         std::vector<const char *> disabledFeatures;
         if (::testing::get<1>(GetParam()))
         {
-            enabledFeatures.push_back("enablePreRotateSurfaces");
+            enabledFeatures.push_back("enable_pre_rotation_surfaces");
         }
         else
         {
-            disabledFeatures.push_back("enablePreRotateSurfaces");
+            disabledFeatures.push_back("enable_pre_rotation_surfaces");
         }
         enabledFeatures.push_back(nullptr);
         disabledFeatures.push_back(nullptr);

src/tests/gl_tests/GeometryShaderTest.cpp

@@ -1348,6 +1348,9 @@ TEST_P(GeometryShaderTest, Prerotation)
 {
     ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_geometry_shader"));
 
+    // http://anglebug.com/5478
+    ANGLE_SKIP_TEST_IF(IsVulkan());
+
     constexpr char kVS[] = R"(#version 310 es
 void main()
 {