Vulkan: Remove inactive shader inputs in the translator

src/compiler/translator/TranslatorVulkan.cpp

@@ -733,7 +733,8 @@ bool TranslatorVulkan::translateImpl(TIntermBlock *root,
     // inactive samplers is not yet supported.  Note also that currently, CollectVariables marks
     // every field of an active uniform that's of struct type as active, i.e. no extracted sampler
     // is inactive.
-    if (!RemoveInactiveInterfaceVariables(this, root, getUniforms(), getInterfaceBlocks()))
+    if (!RemoveInactiveInterfaceVariables(this, root, getAttributes(), getInputVaryings(),
+                                          getUniforms(), getInterfaceBlocks()))
     {
         return false;
     }

src/compiler/translator/tree_ops/RemoveInactiveInterfaceVariables.cpp

@@ -24,20 +24,30 @@ class RemoveInactiveInterfaceVariablesTraverser : public TIntermTraverser
 {
   public:
     RemoveInactiveInterfaceVariablesTraverser(
+        const std::vector<sh::ShaderVariable> &attributes,
+        const std::vector<sh::ShaderVariable> &inputVaryings,
         const std::vector<sh::ShaderVariable> &uniforms,
         const std::vector<sh::InterfaceBlock> &interfaceBlocks);
 
     bool visitDeclaration(Visit visit, TIntermDeclaration *node) override;
 
   private:
+    const std::vector<sh::ShaderVariable> &mAttributes;
+    const std::vector<sh::ShaderVariable> &mInputVaryings;
     const std::vector<sh::ShaderVariable> &mUniforms;
     const std::vector<sh::InterfaceBlock> &mInterfaceBlocks;
 };
 
 RemoveInactiveInterfaceVariablesTraverser::RemoveInactiveInterfaceVariablesTraverser(
+    const std::vector<sh::ShaderVariable> &attributes,
+    const std::vector<sh::ShaderVariable> &inputVaryings,
     const std::vector<sh::ShaderVariable> &uniforms,
     const std::vector<sh::InterfaceBlock> &interfaceBlocks)
-    : TIntermTraverser(true, false, false), mUniforms(uniforms), mInterfaceBlocks(interfaceBlocks)
+    : TIntermTraverser(true, false, false),
+      mAttributes(attributes),
+      mInputVaryings(inputVaryings),
+      mUniforms(uniforms),
+      mInterfaceBlocks(interfaceBlocks)
 {}
 
 template <typename Variable>
@@ -71,22 +81,32 @@ bool RemoveInactiveInterfaceVariablesTraverser::visitDeclaration(Visit visit,
 
     const TType &type = declarator->getType();
 
-    // Only remove uniform and interface block declarations.
+    // Remove all shader interface variables except outputs, i.e. uniforms, interface blocks and
+    // inputs.
     //
-    // Note: Don't remove varyings.  Imagine a situation where the VS doesn't write to a varying
-    // but the FS reads from it.  This is allowed, though the value of the varying is undefined.
-    // If the varying is removed here, the situation is changed to VS not declaring the varying,
-    // but the FS reading from it, which is not allowed.
-    bool removeDeclaration = false;
+    // Imagine a situation where the VS doesn't write to a varying but the FS reads from it.  This
+    // is allowed, though the value of the varying is undefined.  If the varying is removed here,
+    // the situation is changed to VS not declaring the varying, but the FS reading from it, which
+    // is not allowed.  That's why inactive shader outputs are not removed.
+    bool removeDeclaration     = false;
+    const TQualifier qualifier = type.getQualifier();
 
     if (type.isInterfaceBlock())
     {
         removeDeclaration = !IsVariableActive(mInterfaceBlocks, type.getInterfaceBlock()->name());
     }
-    else if (type.getQualifier() == EvqUniform)
+    else if (qualifier == EvqUniform)
     {
         removeDeclaration = !IsVariableActive(mUniforms, asSymbol->getName());
     }
+    else if (qualifier == EvqAttribute || qualifier == EvqVertexIn)
+    {
+        removeDeclaration = !IsVariableActive(mAttributes, asSymbol->getName());
+    }
+    else if (IsShaderIn(qualifier))
+    {
+        removeDeclaration = !IsVariableActive(mInputVaryings, asSymbol->getName());
+    }
 
     if (removeDeclaration)
     {
@@ -101,10 +121,13 @@ bool RemoveInactiveInterfaceVariablesTraverser::visitDeclaration(Visit visit,
 
 bool RemoveInactiveInterfaceVariables(TCompiler *compiler,
                                       TIntermBlock *root,
+                                      const std::vector<sh::ShaderVariable> &attributes,
+                                      const std::vector<sh::ShaderVariable> &inputVaryings,
                                       const std::vector<sh::ShaderVariable> &uniforms,
                                       const std::vector<sh::InterfaceBlock> &interfaceBlocks)
 {
-    RemoveInactiveInterfaceVariablesTraverser traverser(uniforms, interfaceBlocks);
+    RemoveInactiveInterfaceVariablesTraverser traverser(attributes, inputVaryings, uniforms,
+                                                        interfaceBlocks);
     root->traverse(&traverser);
     return traverser.updateTree(compiler, root);
 }

src/compiler/translator/tree_ops/RemoveInactiveInterfaceVariables.h

@@ -29,6 +29,8 @@ class TSymbolTable;
 ANGLE_NO_DISCARD bool RemoveInactiveInterfaceVariables(
     TCompiler *compiler,
     TIntermBlock *root,
+    const std::vector<sh::ShaderVariable> &attributes,
+    const std::vector<sh::ShaderVariable> &inputVaryings,
     const std::vector<sh::ShaderVariable> &uniforms,
     const std::vector<sh::InterfaceBlock> &interfaceBlocks);
 

src/libANGLE/renderer/glslang_wrapper_utils.cpp

@@ -53,7 +53,6 @@ constexpr char kXfbOutMarkerBegin[]                = "@@ XFB-OUT";
 constexpr char kMarkerEnd[]                        = " @@";
 constexpr char kParamsBegin                        = '(';
 constexpr char kParamsEnd                          = ')';
-constexpr char kInactiveVariableSubstitution[]     = "// ";
 constexpr uint32_t kANGLEPositionLocationOffset    = 1;
 constexpr uint32_t kXfbANGLEPositionLocationOffset = 2;
 
@@ -998,27 +997,6 @@ void CleanupUnusedEntities(bool useOldRewriteStructSamplers,
                            const gl::ProgramLinkedResources &resources,
                            gl::ShaderMap<IntermediateShaderSource> *shaderSources)
 {
-    IntermediateShaderSource &vertexSource = (*shaderSources)[gl::ShaderType::Vertex];
-    if (!vertexSource.empty())
-    {
-        gl::Shader *glVertexShader = programState.getAttachedShader(gl::ShaderType::Vertex);
-        ASSERT(glVertexShader != nullptr);
-
-        // The attributes in the programState could have been filled with active attributes only
-        // depending on the shader version. If there is inactive attributes left, we have to remove
-        // their @@ QUALIFIER and @@ LAYOUT markers.
-        for (const sh::ShaderVariable &attribute : glVertexShader->getAllAttributes())
-        {
-            if (attribute.active)
-            {
-                continue;
-            }
-
-            vertexSource.eraseLayoutAndQualifierSpecifiers(attribute.name,
-                                                           kInactiveVariableSubstitution);
-        }
-    }
-
     // Remove all the markers for unused varyings.
     for (const std::string &varyingName : resources.varyingPacking.getInactiveVaryingNames())
     {