Vulkan: Minimize gl_PerVertex members

src/libANGLE/VaryingPacking.cpp

@@ -124,10 +124,15 @@ void VaryingPacking::reset()
     mRegisterList.clear();
     mPackedVaryings.clear();
 
-    for (std::vector<std::string> inactiveVaryingMappedNames : mInactiveVaryingMappedNames)
+    for (std::vector<std::string> &inactiveVaryingMappedNames : mInactiveVaryingMappedNames)
     {
         inactiveVaryingMappedNames.clear();
     }
+
+    for (std::vector<std::string> &activeBuiltIns : mActiveOutputBuiltIns)
+    {
+        activeBuiltIns.clear();
+    }
 }
 
 void VaryingPacking::clearRegisterMap()
@@ -364,12 +369,12 @@ void VaryingPacking::packUserVarying(const ProgramVaryingRef &ref,
     VaryingInShaderRef backVarying(ref.backShaderStage, output);
 
     mPackedVaryings.emplace_back(std::move(frontVarying), std::move(backVarying), interpolation);
-    if (input)
+    if (input && !input->isBuiltIn())
     {
         (*uniqueFullNames)[ref.frontShaderStage].insert(
             mPackedVaryings.back().fullName(ref.frontShaderStage));
     }
-    if (output)
+    if (output && !output->isBuiltIn())
     {
         (*uniqueFullNames)[ref.backShaderStage].insert(
             mPackedVaryings.back().fullName(ref.backShaderStage));
@@ -454,22 +459,31 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
                                                 const bool isSeparableProgram)
 {
     VaryingUniqueFullNames uniqueFullNames;
-    mPackedVaryings.clear();
-    clearRegisterMap();
+
+    reset();
 
     for (const ProgramVaryingRef &ref : mergedVaryings)
     {
         const sh::ShaderVariable *input  = ref.frontShader;
         const sh::ShaderVariable *output = ref.backShader;
 
+        const bool isActiveBuiltInInput  = input && input->isBuiltIn() && input->active;
+        const bool isActiveBuiltInOutput = output && output->isBuiltIn() && output->active;
+
+        // Keep track of output builtins that are used by the shader, such as gl_Position,
+        // gl_PointSize etc.
+        if (isActiveBuiltInInput)
+        {
+            mActiveOutputBuiltIns[ref.frontShaderStage].push_back(input->name);
+        }
+
         // Only pack statically used varyings that have a matched input or output, plus special
         // builtins. Note that we pack all statically used user-defined varyings even if they are
         // not active. GLES specs are a bit vague on whether it's allowed to only pack active
         // varyings, though GLES 3.1 spec section 11.1.2.1 says that "device-dependent
         // optimizations" may be used to make vertex shader outputs fit.
-        if ((input && output && output->staticUse) ||
-            (input && input->isBuiltIn() && input->active) ||
-            (output && output->isBuiltIn() && output->active) ||
+        if ((input && output && output->staticUse) || isActiveBuiltInInput ||
+            isActiveBuiltInOutput ||
             (isSeparableProgram && ((input && input->active) || (output && output->active))))
         {
             const sh::ShaderVariable *varying = output ? output : input;
@@ -508,7 +522,10 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
         // program, in which case the input shader may not exist in this program.
         if (!input && !isSeparableProgram)
         {
+            if (!output->isBuiltIn())
+            {
                 mInactiveVaryingMappedNames[ref.backShaderStage].push_back(output->mappedName);
+            }
             continue;
         }
 
@@ -560,11 +577,13 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
             }
         }
 
-        if (input && uniqueFullNames[ref.frontShaderStage].count(input->name) == 0)
+        if (input && !input->isBuiltIn() &&
+            uniqueFullNames[ref.frontShaderStage].count(input->name) == 0)
         {
             mInactiveVaryingMappedNames[ref.frontShaderStage].push_back(input->mappedName);
         }
-        if (output && uniqueFullNames[ref.backShaderStage].count(output->name) == 0)
+        if (output && !output->isBuiltIn() &&
+            uniqueFullNames[ref.backShaderStage].count(output->name) == 0)
         {
             mInactiveVaryingMappedNames[ref.backShaderStage].push_back(output->mappedName);
         }

src/libANGLE/VaryingPacking.h

@@ -221,6 +221,11 @@ class VaryingPacking final : angle::NonCopyable
         return mInactiveVaryingMappedNames;
     }
 
+    const ShaderMap<std::vector<std::string>> &getActiveOutputBuiltIns() const
+    {
+        return mActiveOutputBuiltIns;
+    }
+
     void reset();
 
   private:
@@ -249,6 +254,7 @@ class VaryingPacking final : angle::NonCopyable
     std::vector<PackedVaryingRegister> mRegisterList;
     std::vector<PackedVarying> mPackedVaryings;
     ShaderMap<std::vector<std::string>> mInactiveVaryingMappedNames;
+    ShaderMap<std::vector<std::string>> mActiveOutputBuiltIns;
 
     PackMode mPackMode;
 };

src/libANGLE/renderer/glslang_wrapper_utils.h

@@ -86,7 +86,9 @@ struct ShaderInterfaceVariableInfo
     // mismatch between the shaders. For example, either the VS casts highp->mediump
     // or the FS casts mediump->highp.
     bool useRelaxedPrecision = false;
-    // Indicate if varying is input or output
+    // Indicate if varying is input or output, or both (in case of for example gl_Position in a
+    // geometry shader)
+    bool varyingIsInput  = false;
     bool varyingIsOutput = false;
     // For vertex attributes, this is the number of components / locations.  These are used by the
     // vertex attribute aliasing transformation only.
@@ -120,6 +122,7 @@ void GlslangGenTransformFeedbackEmulationOutputs(
 void GlslangAssignLocations(const GlslangSourceOptions &options,
                             const gl::ProgramExecutable &programExecutable,
                             const gl::ShaderType shaderType,
+                            const gl::ShaderType frontShaderType,
                             GlslangProgramInterfaceInfo *programInterfaceInfo,
                             gl::ShaderMap<ShaderInterfaceVariableInfoMap> *variableInfoMapOut);
 

src/libANGLE/renderer/metal/mtl_glslang_utils.mm

@@ -432,7 +432,8 @@ void GlslangGetShaderSource(const gl::ProgramState &programState,
             &xfbOnlyVariableMaps[gl::ShaderType::Vertex]);
 
         GlslangAssignLocations(options, programState.getExecutable(), gl::ShaderType::Vertex,
-                               &xfbOnlyInterfaceInfo, &xfbOnlyVariableMaps);
+                               gl::ShaderType::InvalidEnum, &xfbOnlyInterfaceInfo,
+                               &xfbOnlyVariableMaps);
         *xfbOnlyVSVariableInfoMapOut = std::move(xfbOnlyVariableMaps[gl::ShaderType::Vertex]);
     }
 }

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -227,6 +227,7 @@ std::unique_ptr<rx::LinkEvent> ProgramExecutableVk::load(gl::BinaryInputStream *
             info->xfbOffset               = stream->readInt<uint32_t>();
             info->xfbStride               = stream->readInt<uint32_t>();
             info->useRelaxedPrecision     = stream->readBool();
+            info->varyingIsInput          = stream->readBool();
             info->varyingIsOutput         = stream->readBool();
             info->attributeComponentCount = stream->readInt<uint8_t>();
             info->attributeLocationCount  = stream->readInt<uint8_t>();
@@ -254,6 +255,7 @@ void ProgramExecutableVk::save(gl::BinaryOutputStream *stream)
             stream->writeInt(it.second.xfbOffset);
             stream->writeInt(it.second.xfbStride);
             stream->writeBool(it.second.useRelaxedPrecision);
+            stream->writeBool(it.second.varyingIsInput);
             stream->writeBool(it.second.varyingIsOutput);
             stream->writeInt(it.second.attributeComponentCount);
             stream->writeInt(it.second.attributeLocationCount);
@@ -923,7 +925,7 @@ void ProgramExecutableVk::resolvePrecisionMismatch(const gl::ProgramMergedVaryin
                     // The output is lower precision than the input, adjust the input
                     info = &mVariableInfoMap[mergedVarying.backShaderStage]
                                             [mergedVarying.backShader->mappedName];
-                    info->varyingIsOutput     = false;
+                    info->varyingIsInput      = true;
                     info->useRelaxedPrecision = true;
                 }
             }

src/libANGLE/renderer/vulkan/ProgramPipelineVk.cpp

@@ -67,6 +67,7 @@ angle::Result ProgramPipelineVk::link(const gl::Context *glContext,
 
     // Now that the program pipeline has all of the programs attached, the various descriptor
     // set/binding locations need to be re-assigned to their correct values.
+    gl::ShaderType frontShaderType = gl::ShaderType::InvalidEnum;
     for (const gl::ShaderType shaderType : glPipeline->getExecutable().getLinkedShaderStages())
     {
         gl::Program *glProgram =
@@ -82,8 +83,9 @@ angle::Result ProgramPipelineVk::link(const gl::Context *glContext,
                 programProgramInterfaceInfo.locationsUsedForXfbExtension;
 
             GlslangAssignLocations(options, glProgram->getState().getExecutable(), shaderType,
-                                   &glslangProgramInterfaceInfo,
+                                   frontShaderType, &glslangProgramInterfaceInfo,
                                    &mExecutable.getShaderInterfaceVariableInfoMap());
+            frontShaderType = shaderType;
         }
     }
 

src/tests/deqp_support/deqp_gles31_test_expectations.txt

@@ -189,8 +189,6 @@
 // Geometry shader support:
 3580 VULKAN : dEQP-GLES31.functional.shaders.linkage.es31.geometry.varying.types.float_struct = SKIP
 5404 VULKAN : dEQP-GLES31.functional.geometry_shading.query.primitives_generated* = SKIP
-5405 VULKAN : dEQP-GLES31.functional.geometry_shading.basic.output_* = FAIL
-5405 VULKAN : dEQP-GLES31.functional.geometry_shading.instanced.invocation_output_vary_by_* = FAIL
 5406 VULKAN : dEQP-GLES31.functional.geometry_shading.input.*adjacency* = SKIP
 5407 VULKAN : dEQP-GLES31.functional.geometry_shading.layered.* = SKIP
 5407 VULKAN : dEQP-GLES31.functional.geometry_shading.instanced.invocation_per_layer* = SKIP