Update hades

app/libraries/shader-compiler

@@ -1 +1 @@
-Subproject commit b42d6eb5c016ba185a050545654ac2ed3536c469
+Subproject commit 58ae23f7dbd87eaf40f90ba90e4d8aa2c29d363c

app/src/main/cpp/skyline/gpu/shader_manager.cpp

@@ -32,7 +32,10 @@ namespace skyline::gpu {
             .support_float16 = traits.supportsFloat16,
             .support_int64 = traits.supportsInt64,
             .needs_demote_reorder = false,
-            .support_snorm_render_buffer = true
+            .support_snorm_render_buffer = true,
+            .support_viewport_index_layer = gpu.traits.supportsShaderViewportIndexLayer,
+            .min_ssbo_alignment = traits.minimumStorageBufferAlignment,
+            .support_geometry_passthrough = false
         };
 
         constexpr u32 TegraX1WarpSize{32}; //!< The amount of threads in a warp on the Tegra X1
@@ -63,10 +66,13 @@ namespace skyline::gpu {
             .support_int64_atomics = traits.supportsAtomicInt64,
             .support_derivative_control = true,
             .support_geometry_shader_passthrough = false,
+            .support_native_ndc = false,
             .warp_size_potentially_larger_than_guest = TegraX1WarpSize < traits.subgroupSize,
             .lower_left_origin_mode = false,
             .need_declared_frag_colors = false,
-            .has_broken_spirv_position_input = traits.quirks.brokenSpirvPositionInput
+            .has_broken_spirv_position_input = traits.quirks.brokenSpirvPositionInput,
+            .has_broken_spirv_subgroup_mask_vector_extract_dynamic = traits.quirks.brokenSubgroupMaskExtractDynamic,
+            .has_broken_spirv_subgroup_shuffle = traits.quirks.brokenSubgroupShuffle,
         };
 
         Shader::Settings::values = {
@@ -299,6 +305,12 @@ namespace skyline::gpu {
         return Shader::Maxwell::MergeDualVertexPrograms(vertexA, vertexB, env);
     }
 
+    Shader::IR::Program ShaderManager::GenerateGeometryPassthroughShader(Shader::IR::Program &layerSource, Shader::OutputTopology topology) {
+        std::scoped_lock lock{poolMutex};
+
+        return Shader::Maxwell::GenerateGeometryPassthrough(instructionPool, blockPool, hostTranslateInfo, layerSource, topology);
+    }
+
     Shader::IR::Program ShaderManager::ParseComputeShader(span<u8> binary, u32 baseOffset,
                                                           u32 textureConstantBufferIndex,
                                                           u32 localMemorySize, u32 sharedMemorySize,
@@ -311,7 +323,6 @@ namespace skyline::gpu {
         return  Shader::Maxwell::TranslateProgram(instructionPool, blockPool, environment, cfg, hostTranslateInfo);
     }
 
-
     vk::ShaderModule ShaderManager::CompileShader(const Shader::RuntimeInfo &runtimeInfo, Shader::IR::Program &program, Shader::Backend::Bindings &bindings) {
         std::scoped_lock lock{poolMutex};
 

app/src/main/cpp/skyline/gpu/shader_manager.h

@@ -46,6 +46,11 @@ namespace skyline::gpu {
          */
         Shader::IR::Program CombineVertexShaders(Shader::IR::Program &vertexA, Shader::IR::Program &vertexB, span<u8> vertexBBinary);
 
+        /**
+         * @brief Generates a passthrough geometry shader to write gl_Layer on devices that don't support VK_EXT_shader_viewport_index_layer
+         */
+        Shader::IR::Program GenerateGeometryPassthroughShader(Shader::IR::Program &layerSource, Shader::OutputTopology topology);
+
         Shader::IR::Program ParseComputeShader(span<u8> binary, u32 baseOffset, u32 textureConstantBufferIndex, u32 localMemorySize, u32 sharedMemorySize, std::array<u32, 3> workgroupDimensions, const ConstantBufferRead &constantBufferRead, const GetTextureType &getTextureType);
 
         vk::ShaderModule CompileShader(const Shader::RuntimeInfo &runtimeInfo, Shader::IR::Program &program, Shader::Backend::Bindings &bindings);

app/src/main/cpp/skyline/gpu/trait_manager.cpp

@@ -240,6 +240,10 @@ namespace skyline::gpu {
                 if (deviceProperties.driverVersion >= VK_MAKE_VERSION(512, 615, 0) && deviceProperties.driverVersion <= VK_MAKE_VERSION(512, 615, 512))
                     brokenMultithreadedPipelineCompilation = true;
 
+                if (deviceProperties.driverVersion < VK_MAKE_VERSION(512, 672, 0))
+                    brokenSubgroupMaskExtractDynamic = true;
+
+                brokenSubgroupShuffle = true;
                 maxGlobalPriority = vk::QueueGlobalPriorityEXT::eHigh;
                 break;
             }

app/src/main/cpp/skyline/gpu/trait_manager.h

@@ -70,6 +70,8 @@ namespace skyline::gpu {
             bool brokenSpirvPositionInput{}; //!< [Adreno Proprietary] A bug that causes the shader compiler to fail on shaders with vertex position inputs not contained within a struct
             bool brokenComputeShaders{}; //!< [ARM Proprietary] A bug that causes compute shaders in some games to crash the GPU
             bool brokenMultithreadedPipelineCompilation{}; //!< [Qualcomm Proprietary] A bug that causes the shader compiler to crash when compiling pipelines on multiple threads simultaneously
+            bool brokenSubgroupMaskExtractDynamic{};  //!< [Qualcomm Proprietary] A bug that causes shaders using OpVectorExtractDynamic on the subgroup mask builtins to fail to compile
+            bool brokenSubgroupShuffle{}; //!< [Qualcomm Proprietary] A bug that causes shaders using OpSubgroupShuffle to do all sorts of weird things
 
             u32 maxSubpassCount{std::numeric_limits<u32>::max()}; //!< The maximum amount of subpasses within a renderpass, this is limited to 64 on older Adreno proprietary drivers
             vk::QueueGlobalPriorityEXT maxGlobalPriority{vk::QueueGlobalPriorityEXT::eMedium}; //!< The highest allowed global priority of the queue, drivers will not allow higher priorities to be set on queues