Revert "Vulkan: Move xfb position decl to translator in extension path"

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 250
+#define ANGLE_SH_VERSION 249
 
 enum ShShaderSpec
 {
@@ -348,13 +348,9 @@ const ShCompileOptions SH_FORCE_SHADER_PRECISION_HIGHP_TO_MEDIUMP = UINT64_C(1)
 // Allow compiler to use specialization constant to do pre-rotation and y flip.
 const ShCompileOptions SH_USE_SPECIALIZATION_CONSTANT = UINT64_C(1) << 58;
 
-// Ask compiler to generate Vulkan transform feedback emulation support code.
+// Ask compiler to generate transform feedback emulation support code.
 const ShCompileOptions SH_ADD_VULKAN_XFB_EMULATION_SUPPORT_CODE = UINT64_C(1) << 59;
 
-// Ask compiler to generate Vulkan transform feedback support code when using the
-// VK_EXT_transform_feedback extension.
-const ShCompileOptions SH_ADD_VULKAN_XFB_EXTENSION_SUPPORT_CODE = UINT64_C(1) << 60;
-
 // Defines alternate strategies for implementing array index clamping.
 enum ShArrayIndexClampingStrategy
 {
@@ -877,15 +873,12 @@ extern const char kAtomicCountersBlockName[];
 // Line raster emulation varying
 extern const char kLineRasterEmulationPosition[];
 
-// Transform feedback emulation support
+// Transform feedback emulation helper function
 extern const char kXfbEmulationGetOffsetsFunctionName[];
 extern const char kXfbEmulationBufferBlockName[];
 extern const char kXfbEmulationBufferName[];
 extern const char kXfbEmulationBufferFieldName[];
 
-// Transform feedback extension support
-extern const char kXfbExtensionPositionOutName[];
-
 }  // namespace vk
 
 namespace mtl

src/compiler/translator/ShaderLang.cpp

@@ -800,8 +800,6 @@ const char kXfbEmulationBufferBlockName[]        = "ANGLEXfbBuffer";
 const char kXfbEmulationBufferName[]             = "ANGLEXfb";
 const char kXfbEmulationBufferFieldName[]        = "xfbOut";
 
-const char kXfbExtensionPositionOutName[] = "ANGLEXfbPosition";
-
 }  // namespace vk
 
 }  // namespace sh

src/compiler/translator/TranslatorVulkan.cpp

@@ -479,48 +479,6 @@ ANGLE_NO_DISCARD bool AddXfbEmulationSupport(TCompiler *compiler,
     return compiler->validateAST(root);
 }
 
-ANGLE_NO_DISCARD bool AddXfbExtensionSupport(TCompiler *compiler,
-                                             TIntermBlock *root,
-                                             TSymbolTable *symbolTable,
-                                             const DriverUniform *driverUniforms)
-{
-    // Generate the following output varying declaration used to capture transform feedback output
-    // from gl_Position, as it can't be captured directly due to changes that are applied to it for
-    // clip-space correction and pre-rotation.
-    //
-    //     out vec4 ANGLEXfbPosition;
-
-    const TType *vec4Type = nullptr;
-
-    switch (compiler->getShaderType())
-    {
-        case GL_VERTEX_SHADER:
-            vec4Type = StaticType::Get<EbtFloat, EbpHigh, EvqVertexOut, 4, 1>();
-            break;
-        case GL_TESS_EVALUATION_SHADER_EXT:
-            vec4Type = StaticType::Get<EbtFloat, EbpHigh, EvqTessEvaluationOut, 4, 1>();
-            break;
-        case GL_GEOMETRY_SHADER_EXT:
-            vec4Type = StaticType::Get<EbtFloat, EbpHigh, EvqGeometryOut, 4, 1>();
-            break;
-        default:
-            UNREACHABLE();
-    }
-
-    TVariable *varyingVar =
-        new TVariable(symbolTable, ImmutableString(vk::kXfbExtensionPositionOutName), vec4Type,
-                      SymbolType::AngleInternal);
-
-    TIntermDeclaration *varyingDecl = new TIntermDeclaration();
-    varyingDecl->appendDeclarator(new TIntermSymbol(varyingVar));
-
-    // Insert the varying declaration before the first function.
-    const size_t firstFunctionIndex = FindFirstFunctionDefinitionIndex(root);
-    root->insertChildNodes(firstFunctionIndex, {varyingDecl});
-
-    return compiler->validateAST(root);
-}
-
 ANGLE_NO_DISCARD bool InsertFragCoordCorrection(TCompiler *compiler,
                                                 ShCompileOptions compileOptions,
                                                 TIntermBlock *root,
@@ -925,14 +883,8 @@ bool TranslatorVulkan::translateImpl(TIntermBlock *root,
 
     if (gl::ShaderTypeSupportsTransformFeedback(packedShaderType))
     {
-        if (compileOptions & SH_ADD_VULKAN_XFB_EXTENSION_SUPPORT_CODE)
-        {
-            // Add support code for transform feedback extension.
-            if (!AddXfbExtensionSupport(this, root, &getSymbolTable(), driverUniforms))
-            {
-                return false;
-            }
-        }
+        // Add a macro to declare transform feedback buffers.
+        sink << "@@ XFB-DECL @@\n\n";
 
         // Append a macro for transform feedback substitution prior to modifying depth.
         if (!AppendTransformFeedbackOutputToMain(this, root, &getSymbolTable()))

src/libANGLE/renderer/glslang_wrapper_utils.cpp

@@ -59,7 +59,9 @@ namespace rx
 {
 namespace
 {
-constexpr char kXfbOutMarker[] = "@@ XFB-OUT @@;";
+constexpr char kXfbDeclMarker[]    = "@@ XFB-DECL @@";
+constexpr char kXfbOutMarker[]     = "@@ XFB-OUT @@;";
+constexpr char kXfbBuiltInPrefix[] = "xfbANGLE";
 
 template <size_t N>
 constexpr size_t ConstStrLen(const char (&)[N])
@@ -298,22 +300,30 @@ ShaderInterfaceVariableInfo *SetXfbInfo(ShaderInterfaceVariableInfoMap *infoMap,
 }
 
 std::string SubstituteTransformFeedbackMarkers(const std::string &originalSource,
+                                               const std::string &xfbDecl,
                                                const std::string &xfbOut)
 {
-    const size_t xfbOutMarkerStart = originalSource.find(kXfbOutMarker);
+    const size_t xfbDeclMarkerStart = originalSource.find(kXfbDeclMarker);
+    const size_t xfbDeclMarkerEnd   = xfbDeclMarkerStart + ConstStrLen(kXfbDeclMarker);
+
+    const size_t xfbOutMarkerStart = originalSource.find(kXfbOutMarker, xfbDeclMarkerStart);
     const size_t xfbOutMarkerEnd   = xfbOutMarkerStart + ConstStrLen(kXfbOutMarker);
 
     // The shader is the following form:
     //
     // ..part1..
-    // @@ XFB-OUT @@;
+    // @@ XFB-DECL @@
     // ..part2..
+    // @@ XFB-OUT @@;
+    // ..part3..
     //
-    // Construct the string by concatenating these three pieces, replacing the marker with the given
-    // value.
+    // Construct the string by concatenating these five pieces, replacing the markers with the given
+    // values.
     std::string result;
 
-    result.append(&originalSource[0], &originalSource[xfbOutMarkerStart]);
+    result.append(&originalSource[0], &originalSource[xfbDeclMarkerStart]);
+    result.append(xfbDecl);
+    result.append(&originalSource[xfbDeclMarkerEnd], &originalSource[xfbOutMarkerStart]);
     result.append(xfbOut);
     result.append(&originalSource[xfbOutMarkerEnd], &originalSource[originalSource.size()]);
 
@@ -395,50 +405,6 @@ void AssignTransformFeedbackEmulationBindings(gl::ShaderType shaderType,
     }
 }
 
-void AssignTransformFeedbackExtensionLocations(gl::ShaderType shaderType,
-                                               const gl::ProgramState &programState,
-                                               bool isTransformFeedbackStage,
-                                               GlslangProgramInterfaceInfo *programInterfaceInfo,
-                                               ShaderInterfaceVariableInfoMap *variableInfoMapOut)
-{
-    // The only varying that requires additional resources is gl_Position, as it's indirectly
-    // captured through ANGLEXfbPosition.
-
-    const std::vector<gl::TransformFeedbackVarying> &tfVaryings =
-        programState.getLinkedTransformFeedbackVaryings();
-
-    bool capturesPosition = false;
-
-    if (isTransformFeedbackStage)
-    {
-        for (uint32_t varyingIndex = 0; varyingIndex < tfVaryings.size(); ++varyingIndex)
-        {
-            const gl::TransformFeedbackVarying &tfVarying = tfVaryings[varyingIndex];
-            const std::string &tfVaryingName              = tfVarying.mappedName;
-
-            if (tfVaryingName == "gl_Position")
-            {
-                ASSERT(tfVarying.isBuiltIn());
-                capturesPosition = true;
-                break;
-            }
-        }
-    }
-
-    if (capturesPosition)
-    {
-        AddLocationInfo(variableInfoMapOut, shaderType, sh::vk::kXfbExtensionPositionOutName,
-                        programInterfaceInfo->locationsUsedForXfbExtension, 0, 0, 0);
-        ++programInterfaceInfo->locationsUsedForXfbExtension;
-    }
-    else
-    {
-        // Make sure this varying is removed from the other stages, or if position is not captured
-        // at all.
-        variableInfoMapOut->add(shaderType, sh::vk::kXfbExtensionPositionOutName);
-    }
-}
-
 void GenerateTransformFeedbackEmulationOutputs(const GlslangSourceOptions &options,
                                                gl::ShaderType shaderType,
                                                const gl::ProgramState &programState,
@@ -495,7 +461,7 @@ void GenerateTransformFeedbackEmulationOutputs(const GlslangSourceOptions &optio
     }
     xfbOut << "}\n";
 
-    *vertexShader = SubstituteTransformFeedbackMarkers(*vertexShader, xfbOut.str());
+    *vertexShader = SubstituteTransformFeedbackMarkers(*vertexShader, "", xfbOut.str());
 }
 
 bool IsFirstRegisterOfVarying(const gl::PackedVaryingRegister &varyingReg, bool allowFields)
@@ -531,11 +497,14 @@ bool IsFirstRegisterOfVarying(const gl::PackedVaryingRegister &varyingReg, bool
 // Calculates XFB layout qualifier arguments for each tranform feedback varying.  Stores calculated
 // values for the SPIR-V transformation.
 void GenerateTransformFeedbackExtensionOutputs(const gl::ProgramState &programState,
-                                               std::string *xfbShaderSource)
+                                               const gl::VaryingPacking &varyingPacking,
+                                               std::string *xfbShaderSource,
+                                               uint32_t *locationsUsedForXfbExtensionOut)
 {
     const std::vector<gl::TransformFeedbackVarying> &tfVaryings =
         programState.getLinkedTransformFeedbackVaryings();
 
+    std::string xfbDecl;
     std::string xfbOut;
 
     for (uint32_t varyingIndex = 0; varyingIndex < tfVaryings.size(); ++varyingIndex)
@@ -547,14 +516,25 @@ void GenerateTransformFeedbackExtensionOutputs(const gl::ProgramState &programSt
         {
             ASSERT(tfVarying.isBuiltIn());
 
-            // Add initialization code for the position varying.
-            xfbOut = sh::vk::kXfbExtensionPositionOutName;
-            xfbOut += " = " + tfVaryingName + ";\n";
-            break;
+            // For gl_Position, create a copy of the builtin so xfb qualifiers could be added to
+            // that instead.  gl_Position is modified by the shader (to account for Vulkan depth
+            // clip space and prerotation), so it cannot be captured directly.
+            //
+            // The rest of the builtins are captured by decorating gl_PerVertex directly.
+            uint32_t xfbVaryingLocation =
+                varyingPacking.getMaxSemanticIndex() + ++(*locationsUsedForXfbExtensionOut);
+
+            std::string xfbVaryingName = kXfbBuiltInPrefix + tfVaryingName;
+
+            // Add declaration and initialization code for the new varying.
+            std::string varyingType = gl::GetGLSLTypeString(tfVarying.type);
+            xfbDecl += "layout(location = " + Str(xfbVaryingLocation) + ") out " + varyingType +
+                       " " + xfbVaryingName + ";\n";
+            xfbOut += xfbVaryingName + " = " + tfVaryingName + ";\n";
         }
     }
 
-    *xfbShaderSource = SubstituteTransformFeedbackMarkers(*xfbShaderSource, xfbOut);
+    *xfbShaderSource = SubstituteTransformFeedbackMarkers(*xfbShaderSource, xfbDecl, xfbOut);
 }
 
 void AssignAttributeLocations(const gl::ProgramExecutable &programExecutable,
@@ -739,6 +719,7 @@ void AssignVaryingLocations(const GlslangSourceOptions &options,
 // values for the SPIR-V transformation.
 void AssignTransformFeedbackExtensionQualifiers(const gl::ProgramExecutable &programExecutable,
                                                 const gl::VaryingPacking &varyingPacking,
+                                                uint32_t locationsUsedForXfbExtension,
                                                 const gl::ShaderType shaderType,
                                                 ShaderInterfaceVariableInfoMap *variableInfoMapOut)
 {
@@ -748,9 +729,12 @@ void AssignTransformFeedbackExtensionQualifiers(const gl::ProgramExecutable &pro
     const bool isInterleaved =
         programExecutable.getTransformFeedbackBufferMode() == GL_INTERLEAVED_ATTRIBS;
 
-    uint32_t currentOffset = 0;
-    uint32_t currentStride = 0;
-    uint32_t bufferIndex   = 0;
+    std::string xfbDecl;
+    std::string xfbOut;
+    uint32_t currentOffset          = 0;
+    uint32_t currentStride          = 0;
+    uint32_t bufferIndex            = 0;
+    uint32_t currentBuiltinLocation = 0;
 
     for (uint32_t varyingIndex = 0; varyingIndex < tfVaryings.size(); ++varyingIndex)
     {
@@ -777,8 +761,15 @@ void AssignTransformFeedbackExtensionQualifiers(const gl::ProgramExecutable &pro
         {
             if (tfVarying.name == "gl_Position")
             {
-                SetXfbInfo(variableInfoMapOut, shaderType, sh::vk::kXfbExtensionPositionOutName, -1,
-                           bufferIndex, currentOffset, currentStride);
+                uint32_t xfbVaryingLocation = currentBuiltinLocation++;
+                std::string xfbVaryingName  = kXfbBuiltInPrefix + tfVarying.mappedName;
+
+                ASSERT(xfbVaryingLocation < locationsUsedForXfbExtension);
+
+                AddLocationInfo(variableInfoMapOut, shaderType, xfbVaryingName, xfbVaryingLocation,
+                                ShaderInterfaceVariableInfo::kInvalid, 0, 0);
+                SetXfbInfo(variableInfoMapOut, shaderType, xfbVaryingName, -1, bufferIndex,
+                           currentOffset, currentStride);
             }
             else
             {
@@ -4397,15 +4388,6 @@ void GlslangAssignLocations(const GlslangSourceOptions &options,
         const gl::VaryingPacking &inputPacking  = varyingPacking.getInputPacking(shaderType);
         const gl::VaryingPacking &outputPacking = varyingPacking.getOutputPacking(shaderType);
 
-        // Assign location to varyings generated for transform feedback capture
-        if (options.supportsTransformFeedbackExtension &&
-            gl::ShaderTypeSupportsTransformFeedback(shaderType))
-        {
-            AssignTransformFeedbackExtensionLocations(shaderType, programState,
-                                                      isTransformFeedbackStage,
-                                                      programInterfaceInfo, variableInfoMapOut);
-        }
-
         // Assign varying locations.
         if (shaderType != gl::ShaderType::Vertex)
         {
@@ -4418,13 +4400,13 @@ void GlslangAssignLocations(const GlslangSourceOptions &options,
                                    programInterfaceInfo, variableInfoMapOut);
         }
 
-        // Assign qualifiers to all varyings captured by transform feedback
         if (!programExecutable.getLinkedTransformFeedbackVaryings().empty() &&
             options.supportsTransformFeedbackExtension &&
             (shaderType == programExecutable.getLinkedTransformFeedbackStage()))
         {
-            AssignTransformFeedbackExtensionQualifiers(programExecutable, outputPacking, shaderType,
-                                                       variableInfoMapOut);
+            AssignTransformFeedbackExtensionQualifiers(
+                programExecutable, outputPacking,
+                programInterfaceInfo->locationsUsedForXfbExtension, shaderType, variableInfoMapOut);
         }
     }
 
@@ -4465,7 +4447,9 @@ void GlslangGetShaderSource(const GlslangSourceOptions &options,
         {
             if (options.supportsTransformFeedbackExtension)
             {
-                GenerateTransformFeedbackExtensionOutputs(programState, xfbSource);
+                GenerateTransformFeedbackExtensionOutputs(
+                    programState, resources.varyingPacking.getOutputPacking(xfbStage), xfbSource,
+                    &programInterfaceInfo->locationsUsedForXfbExtension);
             }
             else if (options.emulateTransformFeedback)
             {
@@ -4476,25 +4460,25 @@ void GlslangGetShaderSource(const GlslangSourceOptions &options,
             }
             else
             {
-                *xfbSource = SubstituteTransformFeedbackMarkers(*xfbSource, "");
+                *xfbSource = SubstituteTransformFeedbackMarkers(*xfbSource, "", "");
             }
         }
         else
         {
-            *xfbSource = SubstituteTransformFeedbackMarkers(*xfbSource, "");
+            *xfbSource = SubstituteTransformFeedbackMarkers(*xfbSource, "", "");
         }
     }
 
     std::string *tessEvalSources = &(*shaderSourcesOut)[gl::ShaderType::TessEvaluation];
     if (xfbStage > gl::ShaderType::TessEvaluation && !tessEvalSources->empty())
     {
-        *tessEvalSources = SubstituteTransformFeedbackMarkers(*tessEvalSources, "");
+        *tessEvalSources = SubstituteTransformFeedbackMarkers(*tessEvalSources, "", "");
     }
 
     std::string *vertexSource = &(*shaderSourcesOut)[gl::ShaderType::Vertex];
     if (xfbStage > gl::ShaderType::Vertex && !vertexSource->empty())
     {
-        *vertexSource = SubstituteTransformFeedbackMarkers(*vertexSource, "");
+        *vertexSource = SubstituteTransformFeedbackMarkers(*vertexSource, "", "");
     }
 
     gl::ShaderType frontShaderType = gl::ShaderType::InvalidEnum;

src/libANGLE/renderer/vulkan/ShaderVk.cpp

@@ -87,11 +87,7 @@ std::shared_ptr<WaitableCompileEvent> ShaderVk::compile(const gl::Context *conte
         compileOptions |= SH_ADD_PRE_ROTATION;
     }
 
-    if (contextVk->getFeatures().supportsTransformFeedbackExtension.enabled)
-    {
-        compileOptions |= SH_ADD_VULKAN_XFB_EXTENSION_SUPPORT_CODE;
-    }
-    else if (contextVk->getFeatures().emulateTransformFeedback.enabled)
+    if (contextVk->getFeatures().emulateTransformFeedback.enabled)
     {
         compileOptions |= SH_ADD_VULKAN_XFB_EMULATION_SUPPORT_CODE;
     }