Fix crash in SettingsViewModel when Vulkan isn't available (#4985)

* fix crash when Vulkan isn't available

* add VulkanRenderer.GetPhysicalDevices() overload that provides its own Vk API object and logs on failure

* adjustments per AcK77

distribution/macos/updater.sh

@@ -25,14 +25,14 @@ error_handler() {
     exit 1
 }
 
-trap 'error_handler ${LINENO}' ERR
-
 # Wait for Ryujinx to exit
 # NOTE: in case no fds are open, lsof could be returning with a process still living.
 # We wait 1s and assume the process stopped after that
 lsof -p $APP_PID +r 1 &>/dev/null
 sleep 1
 
+trap 'error_handler ${LINENO}' ERR
+
 # Now replace and reopen.
 rm -rf "$INSTALL_DIRECTORY"
 mv "$NEW_APP_DIRECTORY" "$INSTALL_DIRECTORY"

src/Ryujinx.Ava/UI/ViewModels/SettingsViewModel.cs

@@ -311,7 +311,7 @@ namespace Ryujinx.Ava.UI.ViewModels
         {
             _gpuIds = new List<string>();
             List<string> names = new();
-            var devices = VulkanRenderer.GetPhysicalDevices(Vk.GetApi());
+            var devices = VulkanRenderer.GetPhysicalDevices();
 
             if (devices.Length == 0)
             {

src/Ryujinx.Graphics.GAL/ResourceLayout.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Collections.ObjectModel;
+
+namespace Ryujinx.Graphics.GAL
+{
+    public enum ResourceType : byte
+    {
+        UniformBuffer,
+        StorageBuffer,
+        Texture,
+        Sampler,
+        TextureAndSampler,
+        Image,
+        BufferTexture,
+        BufferImage
+    }
+
+    public enum ResourceAccess : byte
+    {
+        None = 0,
+        Read = 1,
+        Write = 2,
+        ReadWrite = Read | Write
+    }
+
+    [Flags]
+    public enum ResourceStages : byte
+    {
+        None = 0,
+        Compute = 1 << 0,
+        Vertex = 1 << 1,
+        TessellationControl = 1 << 2,
+        TessellationEvaluation = 1 << 3,
+        Geometry = 1 << 4,
+        Fragment = 1 << 5
+    }
+
+    public readonly struct ResourceDescriptor : IEquatable<ResourceDescriptor>
+    {
+        public int Binding { get; }
+        public int Count { get; }
+        public ResourceType Type { get; }
+        public ResourceStages Stages { get; }
+
+        public ResourceDescriptor(int binding, int count, ResourceType type, ResourceStages stages)
+        {
+            Binding = binding;
+            Count = count;
+            Type = type;
+            Stages = stages;
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Binding, Count, Type, Stages);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is ResourceDescriptor other && Equals(other);
+        }
+
+        public bool Equals(ResourceDescriptor other)
+        {
+            return Binding == other.Binding && Count == other.Count && Type == other.Type && Stages == other.Stages;
+        }
+    }
+
+    public readonly struct ResourceUsage : IEquatable<ResourceUsage>
+    {
+        public int Binding { get; }
+        public ResourceType Type { get; }
+        public ResourceStages Stages { get; }
+        public ResourceAccess Access { get; }
+
+        public ResourceUsage(int binding, ResourceType type, ResourceStages stages, ResourceAccess access)
+        {
+            Binding = binding;
+            Type = type;
+            Stages = stages;
+            Access = access;
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Binding, Type, Stages, Access);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is ResourceUsage other && Equals(other);
+        }
+
+        public bool Equals(ResourceUsage other)
+        {
+            return Binding == other.Binding && Type == other.Type && Stages == other.Stages && Access == other.Access;
+        }
+    }
+
+    public readonly struct ResourceDescriptorCollection
+    {
+        public ReadOnlyCollection<ResourceDescriptor> Descriptors { get; }
+
+        public ResourceDescriptorCollection(ReadOnlyCollection<ResourceDescriptor> descriptors)
+        {
+            Descriptors = descriptors;
+        }
+
+        public override int GetHashCode()
+        {
+            HashCode hasher = new HashCode();
+
+            if (Descriptors != null)
+            {
+                foreach (var descriptor in Descriptors)
+                {
+                    hasher.Add(descriptor);
+                }
+            }
+
+            return hasher.ToHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is ResourceDescriptorCollection other && Equals(other);
+        }
+
+        public bool Equals(ResourceDescriptorCollection other)
+        {
+            if ((Descriptors == null) != (other.Descriptors == null))
+            {
+                return false;
+            }
+
+            if (Descriptors != null)
+            {
+                if (Descriptors.Count != other.Descriptors.Count)
+                {
+                    return false;
+                }
+
+                for (int index = 0; index < Descriptors.Count; index++)
+                {
+                    if (!Descriptors[index].Equals(other.Descriptors[index]))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+    }
+
+    public readonly struct ResourceUsageCollection
+    {
+        public ReadOnlyCollection<ResourceUsage> Usages { get; }
+
+        public ResourceUsageCollection(ReadOnlyCollection<ResourceUsage> usages)
+        {
+            Usages = usages;
+        }
+    }
+
+    public readonly struct ResourceLayout
+    {
+        public ReadOnlyCollection<ResourceDescriptorCollection> Sets { get; }
+        public ReadOnlyCollection<ResourceUsageCollection> SetUsages { get; }
+
+        public ResourceLayout(
+            ReadOnlyCollection<ResourceDescriptorCollection> sets,
+            ReadOnlyCollection<ResourceUsageCollection> setUsages)
+        {
+            Sets = sets;
+            SetUsages = setUsages;
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/ShaderBindings.cs

@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-
-namespace Ryujinx.Graphics.GAL
-{
-    public readonly struct ShaderBindings
-    {
-        public IReadOnlyCollection<int> UniformBufferBindings { get; }
-        public IReadOnlyCollection<int> StorageBufferBindings { get; }
-        public IReadOnlyCollection<int> TextureBindings { get; }
-        public IReadOnlyCollection<int> ImageBindings { get; }
-
-        public ShaderBindings(
-            IReadOnlyCollection<int> uniformBufferBindings,
-            IReadOnlyCollection<int> storageBufferBindings,
-            IReadOnlyCollection<int> textureBindings,
-            IReadOnlyCollection<int> imageBindings)
-        {
-            UniformBufferBindings = uniformBufferBindings;
-            StorageBufferBindings = storageBufferBindings;
-            TextureBindings = textureBindings;
-            ImageBindings = imageBindings;
-        }
-    }
-}

src/Ryujinx.Graphics.GAL/ShaderInfo.cs

@@ -3,19 +3,22 @@ namespace Ryujinx.Graphics.GAL
     public struct ShaderInfo
     {
         public int FragmentOutputMap { get; }
+        public ResourceLayout ResourceLayout { get; }
         public ProgramPipelineState? State { get; }
         public bool FromCache { get; set; }
 
-        public ShaderInfo(int fragmentOutputMap, ProgramPipelineState state, bool fromCache = false)
+        public ShaderInfo(int fragmentOutputMap, ResourceLayout resourceLayout, ProgramPipelineState state, bool fromCache = false)
         {
             FragmentOutputMap = fragmentOutputMap;
+            ResourceLayout = resourceLayout;
             State = state;
             FromCache = fromCache;
         }
 
-        public ShaderInfo(int fragmentOutputMap, bool fromCache = false)
+        public ShaderInfo(int fragmentOutputMap, ResourceLayout resourceLayout, bool fromCache = false)
         {
             FragmentOutputMap = fragmentOutputMap;
+            ResourceLayout = resourceLayout;
             State = null;
             FromCache = fromCache;
         }

src/Ryujinx.Graphics.GAL/ShaderSource.cs

@@ -7,24 +7,22 @@ namespace Ryujinx.Graphics.GAL
     {
         public string Code { get; }
         public byte[] BinaryCode { get; }
-        public ShaderBindings Bindings { get; }
         public ShaderStage Stage { get; }
         public TargetLanguage Language { get; }
 
-        public ShaderSource(string code, byte[] binaryCode, ShaderBindings bindings, ShaderStage stage, TargetLanguage language)
+        public ShaderSource(string code, byte[] binaryCode, ShaderStage stage, TargetLanguage language)
         {
             Code = code;
             BinaryCode = binaryCode;
-            Bindings = bindings;
             Stage = stage;
             Language = language;
         }
 
-        public ShaderSource(string code, ShaderBindings bindings, ShaderStage stage, TargetLanguage language) : this(code, null, bindings, stage, language)
+        public ShaderSource(string code, ShaderStage stage, TargetLanguage language) : this(code, null, stage, language)
         {
         }
 
-        public ShaderSource(byte[] binaryCode, ShaderBindings bindings, ShaderStage stage, TargetLanguage language) : this(null, binaryCode, bindings, stage, language)
+        public ShaderSource(byte[] binaryCode, ShaderStage stage, TargetLanguage language) : this(null, binaryCode, stage, language)
         {
         }
     }

src/Ryujinx.Graphics.Gpu/Constants.cs

@@ -40,22 +40,6 @@ namespace Ryujinx.Graphics.Gpu
         /// </summary>
         public const int TotalTransformFeedbackBuffers = 4;
 
-        /// <summary>
-        /// Maximum number of textures on a single shader stage.
-        /// </summary>
-        /// <remarks>
-        /// The maximum number of textures is API limited, the hardware supports an unlimited amount.
-        /// </remarks>
-        public const int TotalTextures = 32;
-
-        /// <summary>
-        /// Maximum number of images on a single shader stage.
-        /// </summary>
-        /// <remarks>
-        /// The maximum number of images is API limited, the hardware supports an unlimited amount.
-        /// </remarks>
-        public const int TotalImages = 8;
-
         /// <summary>
         /// Maximum number of render target color buffers.
         /// </summary>
@@ -100,5 +84,15 @@ namespace Ryujinx.Graphics.Gpu
         /// Expected byte alignment for storage buffers
         /// </summary>
         public const int StorageAlignment = 16;
+
+        /// <summary>
+        /// Number of the uniform buffer reserved by the driver to store the storage buffer base addresses.
+        /// </summary>
+        public const int DriverReservedUniformBuffer = 0;
+
+        /// <summary>
+        /// Maximum size that an storage buffer is assumed to have when the correct size is unknown.
+        /// </summary>
+        public const ulong MaxUnknownStorageSize = 0x100000;
     }
 }

src/Ryujinx.Graphics.Gpu/Engine/Compute/ComputeClass.cs

@@ -162,7 +162,19 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
 
                 SbDescriptor sbDescriptor = _channel.MemoryManager.Physical.Read<SbDescriptor>(sbDescAddress);
 
-                _channel.BufferManager.SetComputeStorageBuffer(sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size, sb.Flags);
+                uint size;
+                if (sb.SbCbSlot == Constants.DriverReservedUniformBuffer)
+                {
+                    // Only trust the SbDescriptor size if it comes from slot 0.
+                    size = (uint)sbDescriptor.Size;
+                }
+                else
+                {
+                    // TODO: Use full mapped size and somehow speed up buffer sync.
+                    size = (uint)_channel.MemoryManager.GetMappedSize(sbDescriptor.PackAddress(), Constants.MaxUnknownStorageSize);
+                }
+
+                _channel.BufferManager.SetComputeStorageBuffer(sb.Slot, sbDescriptor.PackAddress(), size, sb.Flags);
             }
 
             if ((_channel.BufferManager.HasUnalignedStorageBuffers) != hasUnaligned)

src/Ryujinx.Graphics.Gpu/Engine/Threed/StateUpdater.cs

@@ -23,8 +23,6 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         public const int PrimitiveRestartStateIndex = 12;
         public const int RenderTargetStateIndex = 27;
 
-        private const ulong MaxUnknownStorageSize = 0x100000;
-
         private readonly GpuContext _context;
         private readonly GpuChannel _channel;
         private readonly DeviceStateWithShadow<ThreedClassState> _state;
@@ -359,7 +357,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     SbDescriptor sbDescriptor = _channel.MemoryManager.Physical.Read<SbDescriptor>(sbDescAddress);
 
                     uint size;
-                    if (sb.SbCbSlot == 0)
+                    if (sb.SbCbSlot == Constants.DriverReservedUniformBuffer)
                     {
                         // Only trust the SbDescriptor size if it comes from slot 0.
                         size = (uint)sbDescriptor.Size;
@@ -367,7 +365,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     else
                     {
                         // TODO: Use full mapped size and somehow speed up buffer sync.
-                        size = (uint)_channel.MemoryManager.GetMappedSize(sbDescriptor.PackAddress(), MaxUnknownStorageSize);
+                        size = (uint)_channel.MemoryManager.GetMappedSize(sbDescriptor.PackAddress(), Constants.MaxUnknownStorageSize);
                     }
 
                     _channel.BufferManager.SetGraphicsStorageBuffer(stage, sb.Slot, sbDescriptor.PackAddress(), size, sb.Flags);

src/Ryujinx.Graphics.Gpu/Shader/DiskCache/DiskCacheHostStorage.cs

@@ -22,7 +22,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         private const ushort FileFormatVersionMajor = 1;
         private const ushort FileFormatVersionMinor = 2;
         private const uint FileFormatVersionPacked = ((uint)FileFormatVersionMajor << 16) | FileFormatVersionMinor;
-        private const uint CodeGenVersion = 4578;
+        private const uint CodeGenVersion = 4646;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";
@@ -368,12 +368,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
 
                         if (hostCode != null)
                         {
-                            bool hasFragmentShader = shaders.Length > 5 && shaders[5] != null;
-                            int fragmentOutputMap = hasFragmentShader ? shaders[5].Info.FragmentOutputMap : -1;
-
-                            ShaderInfo shaderInfo = specState.PipelineState.HasValue
-                                ? new ShaderInfo(fragmentOutputMap, specState.PipelineState.Value, fromCache: true)
-                                : new ShaderInfo(fragmentOutputMap, fromCache: true);
+                            ShaderInfo shaderInfo = ShaderInfoBuilder.BuildForCache(context, shaders, specState.PipelineState);
 
                             IProgram hostProgram;
 
@@ -385,6 +380,8 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
                             }
                             else
                             {
+                                bool hasFragmentShader = shaders.Length > 5 && shaders[5] != null;
+
                                 hostProgram = context.Renderer.LoadProgramBinary(hostCode, hasFragmentShader, shaderInfo);
                             }
 

src/Ryujinx.Graphics.Gpu/Shader/DiskCache/ParallelDiskCacheLoader.cs

@@ -491,23 +491,16 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
             {
                 ShaderSource[] shaderSources = new ShaderSource[compilation.TranslatedStages.Length];
 
-                int fragmentOutputMap = -1;
+                ShaderInfoBuilder shaderInfoBuilder = new ShaderInfoBuilder(_context);
 
                 for (int index = 0; index < compilation.TranslatedStages.Length; index++)
                 {
                     ShaderProgram shader = compilation.TranslatedStages[index];
                     shaderSources[index] = CreateShaderSource(shader);
-
-                    if (shader.Info.Stage == ShaderStage.Fragment)
-                    {
-                        fragmentOutputMap = shader.Info.FragmentOutputMap;
-                    }
+                    shaderInfoBuilder.AddStageInfo(shader.Info);
                 }
 
-                ShaderInfo shaderInfo = compilation.SpecializationState.PipelineState.HasValue
-                    ? new ShaderInfo(fragmentOutputMap, compilation.SpecializationState.PipelineState.Value, fromCache: true)
-                    : new ShaderInfo(fragmentOutputMap, fromCache: true);
-
+                ShaderInfo shaderInfo = shaderInfoBuilder.Build(compilation.SpecializationState.PipelineState, fromCache: true);
                 IProgram hostProgram = _context.Renderer.CreateProgram(shaderSources, shaderInfo);
                 CachedShaderProgram program = new CachedShaderProgram(hostProgram, compilation.SpecializationState, compilation.Shaders);
 

src/Ryujinx.Graphics.Gpu/Shader/DiskCache/ShaderBinarySerializer.cs

@@ -42,25 +42,10 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
                 int binaryCodeLength = reader.ReadInt32();
                 byte[] binaryCode = reader.ReadBytes(binaryCodeLength);
 
-                output.Add(new ShaderSource(binaryCode, GetBindings(stages, stage), stage, TargetLanguage.Spirv));
+                output.Add(new ShaderSource(binaryCode, stage, TargetLanguage.Spirv));
             }
 
             return output.ToArray();
         }
-
-        private static ShaderBindings GetBindings(CachedShaderStage[] stages, ShaderStage stage)
-        {
-            for (int i = 0; i < stages.Length; i++)
-            {
-                CachedShaderStage currentStage = stages[i];
-
-                if (currentStage?.Info != null && currentStage.Info.Stage == stage)
-                {
-                    return ShaderCache.GetBindings(currentStage.Info);
-                }
-            }
-
-            return new ShaderBindings(Array.Empty<int>(), Array.Empty<int>(), Array.Empty<int>(), Array.Empty<int>());
-        }
     }
 }

src/Ryujinx.Graphics.Gpu/Shader/GpuAccessorBase.cs

@@ -4,6 +4,7 @@ using Ryujinx.Graphics.Gpu.Engine.Threed;
 using Ryujinx.Graphics.Gpu.Image;
 using Ryujinx.Graphics.Shader;
 using Ryujinx.Graphics.Shader.Translation;
+using System;
 
 namespace Ryujinx.Graphics.Gpu.Shader
 {
@@ -16,6 +17,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
         private readonly ResourceCounts _resourceCounts;
         private readonly int _stageIndex;
 
+        private readonly int[] _constantBufferBindings;
+
         /// <summary>
         /// Creates a new GPU accessor.
         /// </summary>
@@ -25,6 +28,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
             _context = context;
             _resourceCounts = resourceCounts;
             _stageIndex = stageIndex;
+
+            if (context.Capabilities.Api != TargetApi.Vulkan)
+            {
+                _constantBufferBindings = new int[Constants.TotalGpUniformBuffers];
+                _constantBufferBindings.AsSpan().Fill(-1);
+            }
         }
 
         public int QueryBindingConstantBuffer(int index)
@@ -36,7 +45,15 @@ namespace Ryujinx.Graphics.Gpu.Shader
             }
             else
             {
-                return _resourceCounts.UniformBuffersCount++;
+                int binding = _constantBufferBindings[index];
+
+                if (binding < 0)
+                {
+                    binding = _resourceCounts.UniformBuffersCount++;
+                    _constantBufferBindings[index] = binding;
+                }
+
+                return binding;
             }
         }
 
@@ -93,16 +110,16 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 Logger.Error?.Print(LogClass.Gpu, $"{resourceName} index {index} exceeds per stage limit of {maxPerStage}.");
             }
 
-            return GetStageIndex() * (int)maxPerStage + index;
+            return GetStageIndex(_stageIndex) * (int)maxPerStage + index;
         }
 
-        private int GetStageIndex()
+        public static int GetStageIndex(int stageIndex)
         {
             // This is just a simple remapping to ensure that most frequently used shader stages
             // have the lowest binding numbers.
             // This is useful because if we need to run on a system with a low limit on the bindings,
             // then we can still get most games working as the most common shaders will have low binding numbers.
-            return _stageIndex switch
+            return stageIndex switch
             {
                 4 => 1, // Fragment
                 3 => 2, // Geometry

src/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs

@@ -219,12 +219,11 @@ namespace Ryujinx.Graphics.Gpu.Shader
             GpuAccessor gpuAccessor = new GpuAccessor(_context, channel, gpuAccessorState);
 
             TranslatorContext translatorContext = DecodeComputeShader(gpuAccessor, _context.Capabilities.Api, gpuVa);
-
             TranslatedShader translatedShader = TranslateShader(_dumper, channel, translatorContext, cachedGuestCode);
 
             ShaderSource[] shaderSourcesArray = new ShaderSource[] { CreateShaderSource(translatedShader.Program) };
-
-            IProgram hostProgram = _context.Renderer.CreateProgram(shaderSourcesArray, new ShaderInfo(-1));
+            ShaderInfo info = ShaderInfoBuilder.BuildForCompute(_context, translatedShader.Program.Info);
+            IProgram hostProgram = _context.Renderer.CreateProgram(shaderSourcesArray, info);
 
             cpShader = new CachedShaderProgram(hostProgram, specState, translatedShader.Shader);
 
@@ -363,6 +362,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             TranslatorContext previousStage = null;
 
+            ShaderInfoBuilder infoBuilder = new ShaderInfoBuilder(_context);
+
             for (int stageIndex = 0; stageIndex < Constants.ShaderStages; stageIndex++)
             {
                 TranslatorContext currentStage = translatorContexts[stageIndex + 1];
@@ -398,6 +399,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                     if (program != null)
                     {
                         shaderSources.Add(CreateShaderSource(program));
+                        infoBuilder.AddStageInfo(program.Info);
                     }
 
                     previousStage = currentStage;
@@ -414,8 +416,9 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             ShaderSource[] shaderSourcesArray = shaderSources.ToArray();
 
-            int fragmentOutputMap = shaders[5]?.Info.FragmentOutputMap ?? -1;
-            IProgram hostProgram = _context.Renderer.CreateProgram(shaderSourcesArray, new ShaderInfo(fragmentOutputMap, pipeline));
+            ShaderInfo info = infoBuilder.Build(pipeline);
+
+            IProgram hostProgram = _context.Renderer.CreateProgram(shaderSourcesArray, info);
 
             gpShaders = new CachedShaderProgram(hostProgram, specState, shaders);
 
@@ -466,7 +469,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <returns>Shader source</returns>
         public static ShaderSource CreateShaderSource(ShaderProgram program)
         {
-            return new ShaderSource(program.Code, program.BinaryCode, GetBindings(program.Info), program.Info.Stage, program.Language);
+            return new ShaderSource(program.Code, program.BinaryCode, program.Info.Stage, program.Language);
         }
 
         /// <summary>
@@ -717,25 +720,6 @@ namespace Ryujinx.Graphics.Gpu.Shader
             };
         }
 
-        /// <summary>
-        /// Gets information about the bindings used by a shader program.
-        /// </summary>
-        /// <param name="info">Shader program information to get the information from</param>
-        /// <returns>Shader bindings</returns>
-        public static ShaderBindings GetBindings(ShaderProgramInfo info)
-        {
-            var uniformBufferBindings = info.CBuffers.Select(x => x.Binding).ToArray();
-            var storageBufferBindings = info.SBuffers.Select(x => x.Binding).ToArray();
-            var textureBindings = info.Textures.Select(x => x.Binding).ToArray();
-            var imageBindings = info.Images.Select(x => x.Binding).ToArray();
-
-            return new ShaderBindings(
-                uniformBufferBindings,
-                storageBufferBindings,
-                textureBindings,
-                imageBindings);
-        }
-
         /// <summary>
         /// Creates shader translation options with the requested graphics API and flags.
         /// The shader language is choosen based on the current configuration and graphics API.

src/Ryujinx.Graphics.Gpu/Shader/ShaderInfoBuilder.cs

@@ -0,0 +1,260 @@
+using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Shader;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.Gpu.Shader
+{
+    /// <summary>
+    /// Shader info structure builder.
+    /// </summary>
+    class ShaderInfoBuilder
+    {
+        private const int TotalSets = 4;
+
+        private const int UniformSetIndex = 0;
+        private const int StorageSetIndex = 1;
+        private const int TextureSetIndex = 2;
+        private const int ImageSetIndex = 3;
+
+        private const ResourceStages SupportBufferStags =
+            ResourceStages.Compute |
+            ResourceStages.Vertex |
+            ResourceStages.Fragment;
+
+        private readonly GpuContext _context;
+
+        private int _fragmentOutputMap;
+
+        private readonly List<ResourceDescriptor>[] _resourceDescriptors;
+        private readonly List<ResourceUsage>[] _resourceUsages;
+
+        /// <summary>
+        /// Creates a new shader info builder.
+        /// </summary>
+        /// <param name="context">GPU context that owns the shaders that will be added to the builder</param>
+        public ShaderInfoBuilder(GpuContext context)
+        {
+            _context = context;
+
+            _fragmentOutputMap = -1;
+
+            _resourceDescriptors = new List<ResourceDescriptor>[TotalSets];
+            _resourceUsages = new List<ResourceUsage>[TotalSets];
+
+            for (int index = 0; index < TotalSets; index++)
+            {
+                _resourceDescriptors[index] = new();
+                _resourceUsages[index] = new();
+            }
+
+            AddDescriptor(SupportBufferStags, ResourceType.UniformBuffer, UniformSetIndex, 0, 1);
+        }
+
+        /// <summary>
+        /// Adds information from a given shader stage.
+        /// </summary>
+        /// <param name="info">Shader stage information</param>
+        public void AddStageInfo(ShaderProgramInfo info)
+        {
+            if (info.Stage == ShaderStage.Fragment)
+            {
+                _fragmentOutputMap = info.FragmentOutputMap;
+            }
+
+            int stageIndex = GpuAccessorBase.GetStageIndex(info.Stage switch
+            {
+                ShaderStage.TessellationControl => 1,
+                ShaderStage.TessellationEvaluation => 2,
+                ShaderStage.Geometry => 3,
+                ShaderStage.Fragment => 4,
+                _ => 0
+            });
+
+            ResourceStages stages = info.Stage switch
+            {
+                ShaderStage.Compute => ResourceStages.Compute,
+                ShaderStage.Vertex => ResourceStages.Vertex,
+                ShaderStage.TessellationControl => ResourceStages.TessellationControl,
+                ShaderStage.TessellationEvaluation => ResourceStages.TessellationEvaluation,
+                ShaderStage.Geometry => ResourceStages.Geometry,
+                ShaderStage.Fragment => ResourceStages.Fragment,
+                _ => ResourceStages.None
+            };
+
+            int uniformsPerStage = (int)_context.Capabilities.MaximumUniformBuffersPerStage;
+            int storagesPerStage = (int)_context.Capabilities.MaximumStorageBuffersPerStage;
+            int texturesPerStage = (int)_context.Capabilities.MaximumTexturesPerStage;
+            int imagesPerStage = (int)_context.Capabilities.MaximumImagesPerStage;
+
+            int uniformBinding = 1 + stageIndex * uniformsPerStage;
+            int storageBinding = stageIndex * storagesPerStage;
+            int textureBinding = stageIndex * texturesPerStage * 2;
+            int imageBinding = stageIndex * imagesPerStage * 2;
+
+            AddDescriptor(stages, ResourceType.UniformBuffer, UniformSetIndex, uniformBinding, uniformsPerStage);
+            AddArrayDescriptor(stages, ResourceType.StorageBuffer, StorageSetIndex, storageBinding, storagesPerStage);
+            AddDualDescriptor(stages, ResourceType.TextureAndSampler, ResourceType.BufferTexture, TextureSetIndex, textureBinding, texturesPerStage);
+            AddDualDescriptor(stages, ResourceType.Image, ResourceType.BufferImage, ImageSetIndex, imageBinding, imagesPerStage);
+
+            AddUsage(info.CBuffers, stages, UniformSetIndex, isStorage: false);
+            AddUsage(info.SBuffers, stages, StorageSetIndex, isStorage: true);
+            AddUsage(info.Textures, stages, TextureSetIndex, isImage: false);
+            AddUsage(info.Images, stages, ImageSetIndex, isImage: true);
+        }
+
+        /// <summary>
+        /// Adds a resource descriptor to the list of descriptors.
+        /// </summary>
+        /// <param name="stages">Shader stages where the resource is used</param>
+        /// <param name="type">Type of the resource</param>
+        /// <param name="setIndex">Descriptor set number where the resource will be bound</param>
+        /// <param name="binding">Binding number where the resource will be bound</param>
+        /// <param name="count">Number of resources bound at the binding location</param>
+        private void AddDescriptor(ResourceStages stages, ResourceType type, int setIndex, int binding, int count)
+        {
+            for (int index = 0; index < count; index++)
+            {
+                _resourceDescriptors[setIndex].Add(new ResourceDescriptor(binding + index, 1, type, stages));
+            }
+        }
+
+        /// <summary>
+        /// Adds two interleaved groups of resources to the list of descriptors.
+        /// </summary>
+        /// <param name="stages">Shader stages where the resource is used</param>
+        /// <param name="type">Type of the first interleaved resource</param>
+        /// <param name="type2">Type of the second interleaved resource</param>
+        /// <param name="setIndex">Descriptor set number where the resource will be bound</param>
+        /// <param name="binding">Binding number where the resource will be bound</param>
+        /// <param name="count">Number of resources bound at the binding location</param>
+        private void AddDualDescriptor(ResourceStages stages, ResourceType type, ResourceType type2, int setIndex, int binding, int count)
+        {
+            AddDescriptor(stages, type, setIndex, binding, count);
+            AddDescriptor(stages, type2, setIndex, binding + count, count);
+        }
+
+        /// <summary>
+        /// Adds an array resource to the list of descriptors.
+        /// </summary>
+        /// <param name="stages">Shader stages where the resource is used</param>
+        /// <param name="type">Type of the resource</param>
+        /// <param name="setIndex">Descriptor set number where the resource will be bound</param>
+        /// <param name="binding">Binding number where the resource will be bound</param>
+        /// <param name="count">Number of resources bound at the binding location</param>
+        private void AddArrayDescriptor(ResourceStages stages, ResourceType type, int setIndex, int binding, int count)
+        {
+            _resourceDescriptors[setIndex].Add(new ResourceDescriptor(binding, count, type, stages));
+        }
+
+        /// <summary>
+        /// Adds buffer usage information to the list of usages.
+        /// </summary>
+        /// <param name="buffers">Buffers to be added</param>
+        /// <param name="stages">Stages where the buffers are used</param>
+        /// <param name="setIndex">Descriptor set index where the buffers will be bound</param>
+        /// <param name="isStorage">True for storage buffers, false for uniform buffers</param>
+        private void AddUsage(IEnumerable<BufferDescriptor> buffers, ResourceStages stages, int setIndex, bool isStorage)
+        {
+            foreach (BufferDescriptor buffer in buffers)
+            {
+                _resourceUsages[setIndex].Add(new ResourceUsage(
+                    buffer.Binding,
+                    isStorage ? ResourceType.StorageBuffer : ResourceType.UniformBuffer,
+                    stages,
+                    buffer.Flags.HasFlag(BufferUsageFlags.Write) ? ResourceAccess.ReadWrite : ResourceAccess.Read));
+            }
+        }
+
+        /// <summary>
+        /// Adds texture usage information to the list of usages.
+        /// </summary>
+        /// <param name="textures">Textures to be added</param>
+        /// <param name="stages">Stages where the textures are used</param>
+        /// <param name="setIndex">Descriptor set index where the textures will be bound</param>
+        /// <param name="isImage">True for images, false for textures</param>
+        private void AddUsage(IEnumerable<TextureDescriptor> textures, ResourceStages stages, int setIndex, bool isImage)
+        {
+            foreach (TextureDescriptor texture in textures)
+            {
+                bool isBuffer = (texture.Type & SamplerType.Mask) == SamplerType.TextureBuffer;
+
+                ResourceType type = isBuffer
+                    ? (isImage ? ResourceType.BufferImage : ResourceType.BufferTexture)
+                    : (isImage ? ResourceType.Image : ResourceType.TextureAndSampler);
+
+                _resourceUsages[setIndex].Add(new ResourceUsage(
+                    texture.Binding,
+                    type,
+                    stages,
+                    texture.Flags.HasFlag(TextureUsageFlags.ImageStore) ? ResourceAccess.ReadWrite : ResourceAccess.Read));
+            }
+        }
+
+        /// <summary>
+        /// Creates a new shader information structure from the added information.
+        /// </summary>
+        /// <param name="pipeline">Optional pipeline state for background shader compilation</param>
+        /// <param name="fromCache">Indicates if the shader comes from a disk cache</param>
+        /// <returns>Shader information</returns>
+        public ShaderInfo Build(ProgramPipelineState? pipeline, bool fromCache = false)
+        {
+            var descriptors = new ResourceDescriptorCollection[TotalSets];
+            var usages = new ResourceUsageCollection[TotalSets];
+
+            for (int index = 0; index < TotalSets; index++)
+            {
+                descriptors[index] = new ResourceDescriptorCollection(_resourceDescriptors[index].ToArray().AsReadOnly());
+                usages[index] = new ResourceUsageCollection(_resourceUsages[index].ToArray().AsReadOnly());
+            }
+
+            ResourceLayout resourceLayout = new ResourceLayout(descriptors.AsReadOnly(), usages.AsReadOnly());
+
+            if (pipeline.HasValue)
+            {
+                return new ShaderInfo(_fragmentOutputMap, resourceLayout, pipeline.Value, fromCache);
+            }
+            else
+            {
+                return new ShaderInfo(_fragmentOutputMap, resourceLayout, fromCache);
+            }
+        }
+
+        /// <summary>
+        /// Builds shader information for shaders from the disk cache.
+        /// </summary>
+        /// <param name="context">GPU context that owns the shaders</param>
+        /// <param name="programs">Shaders from the disk cache</param>
+        /// <param name="pipeline">Optional pipeline for background compilation</param>
+        /// <returns>Shader information</returns>
+        public static ShaderInfo BuildForCache(GpuContext context, IEnumerable<CachedShaderStage> programs, ProgramPipelineState? pipeline)
+        {
+            ShaderInfoBuilder builder = new ShaderInfoBuilder(context);
+
+            foreach (CachedShaderStage program in programs)
+            {
+                if (program?.Info != null)
+                {
+                    builder.AddStageInfo(program.Info);
+                }
+            }
+
+            return builder.Build(pipeline, fromCache: true);
+        }
+
+        /// <summary>
+        /// Builds shader information for a compute shader.
+        /// </summary>
+        /// <param name="context">GPU context that owns the shader</param>
+        /// <param name="info">Compute shader information</param>
+        /// <param name="fromCache">True if the compute shader comes from a disk cache, false otherwise</param>
+        /// <returns>Shader information</returns>
+        public static ShaderInfo BuildForCompute(GpuContext context, ShaderProgramInfo info, bool fromCache = false)
+        {
+            ShaderInfoBuilder builder = new ShaderInfoBuilder(context);
+
+            builder.AddStageInfo(info);
+
+            return builder.Build(null, fromCache);
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs

@@ -3,6 +3,7 @@ using Ryujinx.Graphics.Shader.StructuredIr;
 using Ryujinx.Graphics.Shader.Translation;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Numerics;
 
@@ -102,13 +103,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
                 context.AppendLine();
             }
 
-            var cBufferDescriptors = context.Config.GetConstantBufferDescriptors();
-            if (cBufferDescriptors.Length != 0)
-            {
-                DeclareUniforms(context, cBufferDescriptors);
-
-                context.AppendLine();
-            }
+            DeclareConstantBuffers(context, context.Config.Properties.ConstantBuffers.Values);
 
             var sBufferDescriptors = context.Config.GetStorageBufferDescriptors();
             if (sBufferDescriptors.Length != 0)
@@ -265,18 +260,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
                         scaleElements++; // Also includes render target scale, for gl_FragCoord.
                     }
 
-                    DeclareSupportUniformBlock(context, context.Config.Stage, scaleElements);
-
                     if (context.Config.UsedFeatures.HasFlag(FeatureFlags.IntegerSampling) && scaleElements != 0)
                     {
                         AppendHelperFunction(context, $"Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/TexelFetchScale_{stage}.glsl");
                         context.AppendLine();
                     }
                 }
-                else if (isFragment || context.Config.Stage == ShaderStage.Vertex)
-                {
-                    DeclareSupportUniformBlock(context, context.Config.Stage, 0);
-                }
             }
 
             if ((info.HelperFunctionsMask & HelperFunctionsMask.AtomicMinMaxS32Shared) != 0)
@@ -389,36 +378,38 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
             };
         }
 
-        private static void DeclareUniforms(CodeGenContext context, BufferDescriptor[] descriptors)
+        private static void DeclareConstantBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers)
         {
-            string ubSize = "[" + NumberFormatter.FormatInt(Constants.ConstantBufferSize / 16) + "]";
-
-            if (context.Config.UsedFeatures.HasFlag(FeatureFlags.CbIndexing))
+            foreach (BufferDefinition buffer in buffers)
             {
-                string ubName = OperandManager.GetShaderStagePrefix(context.Config.Stage);
-
-                ubName += "_" + DefaultNames.UniformNamePrefix;
-
-                string blockName = $"{ubName}_{DefaultNames.BlockSuffix}";
-
-                context.AppendLine($"layout (binding = {context.Config.FirstConstantBufferBinding}, std140) uniform {blockName}");
-                context.EnterScope();
-                context.AppendLine("vec4 " + DefaultNames.DataName + ubSize + ";");
-                context.LeaveScope($" {ubName}[{NumberFormatter.FormatInt(descriptors.Max(x => x.Slot) + 1)}];");
-            }
-            else
-            {
-                foreach (var descriptor in descriptors)
+                string layout = buffer.Layout switch
                 {
-                    string ubName = OperandManager.GetShaderStagePrefix(context.Config.Stage);
+                    BufferLayout.Std140 => "std140",
+                    _ => "std430"
+                };
 
-                    ubName += "_" + DefaultNames.UniformNamePrefix + descriptor.Slot;
+                context.AppendLine($"layout (binding = {buffer.Binding}, {layout}) uniform _{buffer.Name}");
+                context.EnterScope();
 
-                    context.AppendLine($"layout (binding = {descriptor.Binding}, std140) uniform {ubName}");
-                    context.EnterScope();
-                    context.AppendLine("vec4 " + OperandManager.GetUbName(context.Config.Stage, descriptor.Slot, false) + ubSize + ";");
-                    context.LeaveScope(";");
+                foreach (StructureField field in buffer.Type.Fields)
+                {
+                    if (field.Type.HasFlag(AggregateType.Array))
+                    {
+                        string typeName = GetVarTypeName(context, field.Type & ~AggregateType.Array);
+                        string arraySize = field.ArrayLength.ToString(CultureInfo.InvariantCulture);
+
+                        context.AppendLine($"{typeName} {field.Name}[{arraySize}];");
+                    }
+                    else
+                    {
+                        string typeName = GetVarTypeName(context, field.Type);
+
+                        context.AppendLine($"{typeName} {field.Name};");
+                    }
                 }
+
+                context.LeaveScope($" {buffer.Name};");
+                context.AppendLine();
             }
         }
 
@@ -759,39 +750,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
             context.AppendLine($"layout (location = {location}) patch out vec4 {name};");
         }
 
-        private static void DeclareSupportUniformBlock(CodeGenContext context, ShaderStage stage, int scaleElements)
-        {
-            bool needsSupportBlock = stage == ShaderStage.Fragment ||
-                (context.Config.LastInVertexPipeline && context.Config.GpuAccessor.QueryViewportTransformDisable());
-
-            if (!needsSupportBlock && scaleElements == 0)
-            {
-                return;
-            }
-
-            context.AppendLine($"layout (binding = 0, std140) uniform {DefaultNames.SupportBlockName}");
-            context.EnterScope();
-
-            switch (stage)
-            {
-                case ShaderStage.Fragment:
-                case ShaderStage.Vertex:
-                    context.AppendLine($"uint {DefaultNames.SupportBlockAlphaTestName};");
-                    context.AppendLine($"bool {DefaultNames.SupportBlockIsBgraName}[{SupportBuffer.FragmentIsBgraCount}];");
-                    context.AppendLine($"vec4 {DefaultNames.SupportBlockViewportInverse};");
-                    context.AppendLine($"int {DefaultNames.SupportBlockFragmentScaleCount};");
-                    break;
-                case ShaderStage.Compute:
-                    context.AppendLine($"uint s_reserved[{SupportBuffer.ComputeRenderScaleOffset / SupportBuffer.FieldSize}];");
-                    break;
-            }
-
-            context.AppendLine($"float {DefaultNames.SupportBlockRenderScaleName}[{SupportBuffer.RenderScaleMaxCount}];");
-
-            context.LeaveScope(";");
-            context.AppendLine();
-        }
-
         private static void AppendHelperFunction(CodeGenContext context, string filename)
         {
             string code = EmbeddedResources.ReadAllText(filename);

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs

@@ -15,18 +15,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
 
         public const string DataName = "data";
 
-        public const string SupportBlockName = "support_block";
-        public const string SupportBlockAlphaTestName = "s_alpha_test";
-        public const string SupportBlockIsBgraName = "s_is_bgra";
-        public const string SupportBlockViewportInverse = "s_viewport_inverse";
-        public const string SupportBlockFragmentScaleCount = "s_frag_scale_count";
-        public const string SupportBlockRenderScaleName = "s_render_scale";
-
         public const string BlockSuffix = "block";
 
-        public const string UniformNamePrefix = "c";
-        public const string UniformNameSuffix = "data";
-
         public const string LocalMemoryName  = "local_mem";
         public const string SharedMemoryName = "shared_mem";
 

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/TexelFetchScale_cp.glsl

@@ -1,6 +1,6 @@
 ivec2 Helper_TexelFetchScale(ivec2 inputVec, int samplerIndex)
 {
-    float scale = s_render_scale[samplerIndex];
+    float scale = support_buffer.s_render_scale[1 + samplerIndex];
     if (scale == 1.0)
     {
         return inputVec;
@@ -10,7 +10,7 @@
 
 int Helper_TextureSizeUnscale(int size, int samplerIndex)
 {
-    float scale = s_render_scale[samplerIndex];
+    float scale = support_buffer.s_render_scale[1 + samplerIndex];
     if (scale == 1.0)
     {
         return size;

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/TexelFetchScale_fp.glsl

@@ -1,6 +1,6 @@
 ivec2 Helper_TexelFetchScale(ivec2 inputVec, int samplerIndex)
 {
-    float scale = s_render_scale[1 + samplerIndex];
+    float scale = support_buffer.s_render_scale[1 + samplerIndex];
     if (scale == 1.0)
     {
         return inputVec;
@@ -17,7 +17,7 @@
 
 int Helper_TextureSizeUnscale(int size, int samplerIndex)
 {
-    float scale = abs(s_render_scale[1 + samplerIndex]);
+    float scale = abs(support_buffer.s_render_scale[1 + samplerIndex]);
     if (scale == 1.0)
     {
         return size;

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/TexelFetchScale_vp.glsl

@@ -1,6 +1,6 @@
 ivec2 Helper_TexelFetchScale(ivec2 inputVec, int samplerIndex)
 {
-    float scale = abs(s_render_scale[1 + samplerIndex + s_frag_scale_count]);
+    float scale = abs(support_buffer.s_render_scale[1 + samplerIndex + support_buffer.s_frag_scale_count]);
     if (scale == 1.0)
     {
         return inputVec;
@@ -11,7 +11,7 @@
 
 int Helper_TextureSizeUnscale(int size, int samplerIndex)
 {
-    float scale = abs(s_render_scale[1 + samplerIndex + s_frag_scale_count]);
+    float scale = abs(support_buffer.s_render_scale[1 + samplerIndex + support_buffer.s_frag_scale_count]);
     if (scale == 1.0)
     {
         return size;

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGen.cs

@@ -167,9 +167,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                     case Instruction.Load:
                         return Load(context, operation);
 
-                    case Instruction.LoadConstant:
-                        return LoadConstant(context, operation);
-
                     case Instruction.LoadLocal:
                         return LoadLocal(context, operation);
 

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenHelper.cs

@@ -83,7 +83,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             Add(Instruction.ImageAtomic,              InstType.Special);
             Add(Instruction.IsNan,                    InstType.CallUnary,      "isnan");
             Add(Instruction.Load,                     InstType.Special);
-            Add(Instruction.LoadConstant,             InstType.Special);
             Add(Instruction.LoadLocal,                InstType.Special);
             Add(Instruction.LoadShared,               InstType.Special);
             Add(Instruction.LoadStorage,              InstType.Special);

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenMemory.cs

@@ -215,29 +215,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             return GenerateLoadOrStore(context, operation, isStore: false);
         }
 
-        public static string LoadConstant(CodeGenContext context, AstOperation operation)
-        {
-            IAstNode src1 = operation.GetSource(0);
-            IAstNode src2 = operation.GetSource(1);
-
-            string offsetExpr = GetSoureExpr(context, src2, GetSrcVarType(operation.Inst, 1));
-            offsetExpr = Enclose(offsetExpr, src2, Instruction.ShiftRightS32, isLhs: true);
-
-            var config = context.Config;
-            bool indexElement = !config.GpuAccessor.QueryHostHasVectorIndexingBug();
-
-            if (src1 is AstOperand operand && operand.Type == OperandType.Constant)
-            {
-                bool cbIndexable = config.UsedFeatures.HasFlag(Translation.FeatureFlags.CbIndexing);
-                return OperandManager.GetConstantBufferName(operand.Value, offsetExpr, config.Stage, cbIndexable, indexElement);
-            }
-            else
-            {
-                string slotExpr = GetSoureExpr(context, src1, GetSrcVarType(operation.Inst, 0));
-                return OperandManager.GetConstantBufferName(slotExpr, offsetExpr, config.Stage, indexElement);
-            }
-        }
-
         public static string LoadLocal(CodeGenContext context, AstOperation operation)
         {
             return LoadLocalOrShared(context, operation, DefaultNames.LocalMemoryName);
@@ -809,9 +786,29 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             string varName;
             AggregateType varType;
             int srcIndex = 0;
+            int inputsCount = isStore ? operation.SourcesCount - 1 : operation.SourcesCount;
 
             switch (storageKind)
             {
+                case StorageKind.ConstantBuffer:
+                    if (!(operation.GetSource(srcIndex++) is AstOperand bindingIndex) || bindingIndex.Type != OperandType.Constant)
+                    {
+                        throw new InvalidOperationException($"First input of {operation.Inst} with {storageKind} storage must be a constant operand.");
+                    }
+
+                    int binding = bindingIndex.Value;
+                    BufferDefinition buffer = context.Config.Properties.ConstantBuffers[binding];
+
+                    if (!(operation.GetSource(srcIndex++) is AstOperand fieldIndex) || fieldIndex.Type != OperandType.Constant)
+                    {
+                        throw new InvalidOperationException($"Second input of {operation.Inst} with {storageKind} storage must be a constant operand.");
+                    }
+
+                    StructureField field = buffer.Type.Fields[fieldIndex.Value];
+                    varName = $"{buffer.Name}.{field.Name}";
+                    varType = field.Type;
+                    break;
+
                 case StorageKind.Input:
                 case StorageKind.InputPerPatch:
                 case StorageKind.Output:
@@ -864,40 +861,39 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                             varName = $"gl_out[{expr}].{varName}";
                         }
                     }
-
-                    int firstSrcIndex = srcIndex;
-                    int inputsCount = isStore ? operation.SourcesCount - 1 : operation.SourcesCount;
-
-                    for (; srcIndex < inputsCount; srcIndex++)
-                    {
-                        IAstNode src = operation.GetSource(srcIndex);
-
-                        if ((varType & AggregateType.ElementCountMask) != 0 &&
-                            srcIndex == inputsCount - 1 &&
-                            src is AstOperand elementIndex &&
-                            elementIndex.Type == OperandType.Constant)
-                        {
-                            varName += "." + "xyzw"[elementIndex.Value & 3];
-                        }
-                        else if (srcIndex == firstSrcIndex && context.Config.Stage == ShaderStage.TessellationControl && storageKind == StorageKind.Output)
-                        {
-                            // GLSL requires that for tessellation control shader outputs,
-                            // that the index expression must be *exactly* "gl_InvocationID",
-                            // otherwise the compilation fails.
-                            // TODO: Get rid of this and use expression propagation to make sure we generate the correct code from IR.
-                            varName += "[gl_InvocationID]";
-                        }
-                        else
-                        {
-                            varName += $"[{GetSoureExpr(context, src, AggregateType.S32)}]";
-                        }
-                    }
                     break;
 
                 default:
                     throw new InvalidOperationException($"Invalid storage kind {storageKind}.");
             }
 
+            int firstSrcIndex = srcIndex;
+
+            for (; srcIndex < inputsCount; srcIndex++)
+            {
+                IAstNode src = operation.GetSource(srcIndex);
+
+                if ((varType & AggregateType.ElementCountMask) != 0 &&
+                    srcIndex == inputsCount - 1 &&
+                    src is AstOperand elementIndex &&
+                    elementIndex.Type == OperandType.Constant)
+                {
+                    varName += "." + "xyzw"[elementIndex.Value & 3];
+                }
+                else if (srcIndex == firstSrcIndex && context.Config.Stage == ShaderStage.TessellationControl && storageKind == StorageKind.Output)
+                {
+                    // GLSL requires that for tessellation control shader outputs,
+                    // that the index expression must be *exactly* "gl_InvocationID",
+                    // otherwise the compilation fails.
+                    // TODO: Get rid of this and use expression propagation to make sure we generate the correct code from IR.
+                    varName += "[gl_InvocationID]";
+                }
+                else
+                {
+                    varName += $"[{GetSoureExpr(context, src, AggregateType.S32)}]";
+                }
+            }
+
             if (isStore)
             {
                 varType &= AggregateType.ElementTypeMask;

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/IoMap.cs

@@ -27,7 +27,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 IoVariable.FragmentCoord => ("gl_FragCoord", AggregateType.Vector4 | AggregateType.FP32),
                 IoVariable.FragmentOutputColor => GetFragmentOutputColorVariableName(config, location),
                 IoVariable.FragmentOutputDepth => ("gl_FragDepth", AggregateType.FP32),
-                IoVariable.FragmentOutputIsBgra => (DefaultNames.SupportBlockIsBgraName, AggregateType.Array | AggregateType.Bool),
                 IoVariable.FrontColorDiffuse => ("gl_FrontColor", AggregateType.Vector4 | AggregateType.FP32), // Deprecated.
                 IoVariable.FrontColorSpecular  => ("gl_FrontSecondaryColor", AggregateType.Vector4 | AggregateType.FP32), // Deprecated.
                 IoVariable.FrontFacing => ("gl_FrontFacing", AggregateType.Bool),
@@ -46,8 +45,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 IoVariable.SubgroupLaneId => GetSubgroupInvocationIdVariableName(config),
                 IoVariable.SubgroupLeMask => GetSubgroupMaskVariableName(config, "Le"),
                 IoVariable.SubgroupLtMask => GetSubgroupMaskVariableName(config, "Lt"),
-                IoVariable.SupportBlockRenderScale => (DefaultNames.SupportBlockRenderScaleName, AggregateType.Array | AggregateType.FP32),
-                IoVariable.SupportBlockViewInverse => (DefaultNames.SupportBlockViewportInverse, AggregateType.Vector2 | AggregateType.FP32),
                 IoVariable.TessellationCoord => ("gl_TessCoord", AggregateType.Vector3 | AggregateType.FP32),
                 IoVariable.TessellationLevelInner => ("gl_TessLevelInner", AggregateType.Array | AggregateType.FP32),
                 IoVariable.TessellationLevelOuter => ("gl_TessLevelOuter", AggregateType.Array | AggregateType.FP32),

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/OperandManager.cs

@@ -36,63 +36,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
             {
                 OperandType.Argument => GetArgumentName(operand.Value),
                 OperandType.Constant => NumberFormatter.FormatInt(operand.Value),
-                OperandType.ConstantBuffer => GetConstantBufferName(operand, context.Config),
                 OperandType.LocalVariable => _locals[operand],
                 OperandType.Undefined => DefaultNames.UndefinedName,
                 _ => throw new ArgumentException($"Invalid operand type \"{operand.Type}\".")
             };
         }
 
-        private static string GetConstantBufferName(AstOperand operand, ShaderConfig config)
-        {
-            return GetConstantBufferName(operand.CbufSlot, operand.CbufOffset, config.Stage, config.UsedFeatures.HasFlag(FeatureFlags.CbIndexing));
-        }
-
-        public static string GetConstantBufferName(int slot, int offset, ShaderStage stage, bool cbIndexable)
-        {
-            return $"{GetUbName(stage, slot, cbIndexable)}[{offset >> 2}].{GetSwizzleMask(offset & 3)}";
-        }
-
-        private static string GetVec4Indexed(string vectorName, string indexExpr, bool indexElement)
-        {
-            if (indexElement)
-            {
-                return $"{vectorName}[{indexExpr}]";
-            }
-
-            string result = $"{vectorName}.x";
-            for (int i = 1; i < 4; i++)
-            {
-                result = $"(({indexExpr}) == {i}) ? ({vectorName}.{GetSwizzleMask(i)}) : ({result})";
-            }
-            return $"({result})";
-        }
-
-        public static string GetConstantBufferName(int slot, string offsetExpr, ShaderStage stage, bool cbIndexable, bool indexElement)
-        {
-            return GetVec4Indexed(GetUbName(stage, slot, cbIndexable) + $"[{offsetExpr} >> 2]", offsetExpr + " & 3", indexElement);
-        }
-
-        public static string GetConstantBufferName(string slotExpr, string offsetExpr, ShaderStage stage, bool indexElement)
-        {
-            return GetVec4Indexed(GetUbName(stage, slotExpr) + $"[{offsetExpr} >> 2]", offsetExpr + " & 3", indexElement);
-        }
-
-        public static string GetUbName(ShaderStage stage, int slot, bool cbIndexable)
-        {
-            if (cbIndexable)
-            {
-                return GetUbName(stage, NumberFormatter.FormatInt(slot, AggregateType.S32));
-            }
-
-            return $"{GetShaderStagePrefix(stage)}_{DefaultNames.UniformNamePrefix}{slot}_{DefaultNames.UniformNameSuffix}";
-        }
-
-        private static string GetUbName(ShaderStage stage, string slotExpr)
-        {
-            return $"{GetShaderStagePrefix(stage)}_{DefaultNames.UniformNamePrefix}[{slotExpr}].{DefaultNames.DataName}";
-        }
-
         public static string GetSamplerName(ShaderStage stage, AstTextureOperation texOp, string indexExpr)
         {
             return GetSamplerName(stage, texOp.CbufSlot, texOp.Handle, texOp.Type.HasFlag(SamplerType.Indexed), indexExpr);
@@ -168,6 +117,22 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
                 {
                     switch (operation.StorageKind)
                     {
+                        case StorageKind.ConstantBuffer:
+                            if (!(operation.GetSource(0) is AstOperand bindingIndex) || bindingIndex.Type != OperandType.Constant)
+                            {
+                                throw new InvalidOperationException($"First input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
+                            }
+
+                            if (!(operation.GetSource(1) is AstOperand fieldIndex) || fieldIndex.Type != OperandType.Constant)
+                            {
+                                throw new InvalidOperationException($"Second input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
+                            }
+
+                            BufferDefinition buffer = context.Config.Properties.ConstantBuffers[bindingIndex.Value];
+                            StructureField field = buffer.Type.Fields[fieldIndex.Value];
+
+                            return field.Type & AggregateType.ElementTypeMask;
+
                         case StorageKind.Input:
                         case StorageKind.InputPerPatch:
                         case StorageKind.Output:

src/Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs

@@ -23,9 +23,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
         public int InputVertices { get; }
 
-        public Dictionary<int, Instruction> UniformBuffers { get; } = new Dictionary<int, Instruction>();
-        public Instruction SupportBuffer { get; set; }
-        public Instruction UniformBuffersArray { get; set; }
+        public Dictionary<int, Instruction> ConstantBuffers { get; } = new Dictionary<int, Instruction>();
         public Instruction StorageBuffersArray { get; set; }
         public Instruction LocalMemory { get; set; }
         public Instruction SharedMemory { get; set; }
@@ -217,7 +215,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                 {
                     IrOperandType.Argument => GetArgument(type, operand),
                     IrOperandType.Constant => GetConstant(type, operand),
-                    IrOperandType.ConstantBuffer => GetConstantBuffer(type, operand),
                     IrOperandType.LocalVariable => GetLocal(type, operand),
                     IrOperandType.Undefined => GetUndefined(type),
                     _ => throw new ArgumentException($"Invalid operand type \"{operand.Type}\".")
@@ -274,31 +271,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             };
         }
 
-        public Instruction GetConstantBuffer(AggregateType type, AstOperand operand)
-        {
-            var i1 = Constant(TypeS32(), 0);
-            var i2 = Constant(TypeS32(), operand.CbufOffset >> 2);
-            var i3 = Constant(TypeU32(), operand.CbufOffset & 3);
-
-            Instruction elemPointer;
-
-            if (UniformBuffersArray != null)
-            {
-                var ubVariable = UniformBuffersArray;
-                var i0 = Constant(TypeS32(), operand.CbufSlot);
-
-                elemPointer = AccessChain(TypePointer(StorageClass.Uniform, TypeFP32()), ubVariable, i0, i1, i2, i3);
-            }
-            else
-            {
-                var ubVariable = UniformBuffers[operand.CbufSlot];
-
-                elemPointer = AccessChain(TypePointer(StorageClass.Uniform, TypeFP32()), ubVariable, i1, i2, i3);
-            }
-
-            return BitcastIfNeeded(type, AggregateType.FP32, Load(TypeFP32(), elemPointer));
-        }
-
         public Instruction GetLocalPointer(AstOperand local)
         {
             return _locals[local];

src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs

@@ -98,8 +98,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                 DeclareLocalMemory(context, localMemorySize);
             }
 
-            DeclareSupportBuffer(context);
-            DeclareUniformBuffers(context, context.Config.GetConstantBufferDescriptors());
+            DeclareConstantBuffers(context, context.Config.Properties.ConstantBuffers.Values);
             DeclareStorageBuffers(context, context.Config.GetStorageBufferDescriptors());
             DeclareSamplers(context, context.Config.GetTextureDescriptors());
             DeclareImages(context, context.Config.GetImageDescriptors());
@@ -127,84 +126,63 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             return variable;
         }
 
-        private static void DeclareSupportBuffer(CodeGenContext context)
+        private static void DeclareConstantBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers)
         {
-            if (!context.Config.Stage.SupportsRenderScale() && !(context.Config.LastInVertexPipeline && context.Config.GpuAccessor.QueryViewportTransformDisable()))
+            HashSet<SpvInstruction> decoratedTypes = new HashSet<SpvInstruction>();
+
+            foreach (BufferDefinition buffer in buffers)
             {
-                return;
-            }
+                int alignment = buffer.Layout == BufferLayout.Std140 ? 16 : 4;
+                int alignmentMask = alignment - 1;
+                int offset = 0;
 
-            var isBgraArrayType = context.TypeArray(context.TypeU32(), context.Constant(context.TypeU32(), SupportBuffer.FragmentIsBgraCount));
-            var viewportInverseVectorType = context.TypeVector(context.TypeFP32(), 4);
-            var renderScaleArrayType = context.TypeArray(context.TypeFP32(), context.Constant(context.TypeU32(), SupportBuffer.RenderScaleMaxCount));
+                SpvInstruction[] structFieldTypes = new SpvInstruction[buffer.Type.Fields.Length];
+                int[] structFieldOffsets = new int[buffer.Type.Fields.Length];
 
-            context.Decorate(isBgraArrayType, Decoration.ArrayStride, (LiteralInteger)SupportBuffer.FieldSize);
-            context.Decorate(renderScaleArrayType, Decoration.ArrayStride, (LiteralInteger)SupportBuffer.FieldSize);
+                for (int fieldIndex = 0; fieldIndex < buffer.Type.Fields.Length; fieldIndex++)
+                {
+                    StructureField field = buffer.Type.Fields[fieldIndex];
+                    int fieldSize = (field.Type.GetSizeInBytes() + alignmentMask) & ~alignmentMask;
 
-            var supportBufferStructType = context.TypeStruct(false, context.TypeU32(), isBgraArrayType, viewportInverseVectorType, context.TypeS32(), renderScaleArrayType);
+                    structFieldTypes[fieldIndex] = context.GetType(field.Type, field.ArrayLength);
+                    structFieldOffsets[fieldIndex] = offset;
 
-            context.MemberDecorate(supportBufferStructType, 0, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentAlphaTestOffset);
-            context.MemberDecorate(supportBufferStructType, 1, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentIsBgraOffset);
-            context.MemberDecorate(supportBufferStructType, 2, Decoration.Offset, (LiteralInteger)SupportBuffer.ViewportInverseOffset);
-            context.MemberDecorate(supportBufferStructType, 3, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentRenderScaleCountOffset);
-            context.MemberDecorate(supportBufferStructType, 4, Decoration.Offset, (LiteralInteger)SupportBuffer.GraphicsRenderScaleOffset);
-            context.Decorate(supportBufferStructType, Decoration.Block);
+                    if (field.Type.HasFlag(AggregateType.Array))
+                    {
+                        // We can't decorate the type more than once.
+                        if (decoratedTypes.Add(structFieldTypes[fieldIndex]))
+                        {
+                            context.Decorate(structFieldTypes[fieldIndex], Decoration.ArrayStride, (LiteralInteger)fieldSize);
+                        }
 
-            var supportBufferPointerType = context.TypePointer(StorageClass.Uniform, supportBufferStructType);
-            var supportBufferVariable = context.Variable(supportBufferPointerType, StorageClass.Uniform);
+                        offset += fieldSize * field.ArrayLength;
+                    }
+                    else
+                    {
+                        offset += fieldSize;
+                    }
+                }
 
-            context.Decorate(supportBufferVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-            context.Decorate(supportBufferVariable, Decoration.Binding, (LiteralInteger)0);
+                var ubStructType = context.TypeStruct(false, structFieldTypes);
 
-            context.AddGlobalVariable(supportBufferVariable);
+                if (decoratedTypes.Add(ubStructType))
+                {
+                    context.Decorate(ubStructType, Decoration.Block);
 
-            context.SupportBuffer = supportBufferVariable;
-        }
+                    for (int fieldIndex = 0; fieldIndex < structFieldOffsets.Length; fieldIndex++)
+                    {
+                        context.MemberDecorate(ubStructType, fieldIndex, Decoration.Offset, (LiteralInteger)structFieldOffsets[fieldIndex]);
+                    }
+                }
 
-        private static void DeclareUniformBuffers(CodeGenContext context, BufferDescriptor[] descriptors)
-        {
-            if (descriptors.Length == 0)
-            {
-                return;
-            }
-
-            uint ubSize = Constants.ConstantBufferSize / 16;
-
-            var ubArrayType = context.TypeArray(context.TypeVector(context.TypeFP32(), 4), context.Constant(context.TypeU32(), ubSize), true);
-            context.Decorate(ubArrayType, Decoration.ArrayStride, (LiteralInteger)16);
-            var ubStructType = context.TypeStruct(true, ubArrayType);
-            context.Decorate(ubStructType, Decoration.Block);
-            context.MemberDecorate(ubStructType, 0, Decoration.Offset, (LiteralInteger)0);
-
-            if (context.Config.UsedFeatures.HasFlag(FeatureFlags.CbIndexing))
-            {
-                int count = descriptors.Max(x => x.Slot) + 1;
-
-                var ubStructArrayType = context.TypeArray(ubStructType, context.Constant(context.TypeU32(), count));
-                var ubPointerType = context.TypePointer(StorageClass.Uniform, ubStructArrayType);
+                var ubPointerType = context.TypePointer(StorageClass.Uniform, ubStructType);
                 var ubVariable = context.Variable(ubPointerType, StorageClass.Uniform);
 
-                context.Name(ubVariable, $"{GetStagePrefix(context.Config.Stage)}_u");
-                context.Decorate(ubVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-                context.Decorate(ubVariable, Decoration.Binding, (LiteralInteger)context.Config.FirstConstantBufferBinding);
+                context.Name(ubVariable, buffer.Name);
+                context.Decorate(ubVariable, Decoration.DescriptorSet, (LiteralInteger)buffer.Set);
+                context.Decorate(ubVariable, Decoration.Binding, (LiteralInteger)buffer.Binding);
                 context.AddGlobalVariable(ubVariable);
-
-                context.UniformBuffersArray = ubVariable;
-            }
-            else
-            {
-                var ubPointerType = context.TypePointer(StorageClass.Uniform, ubStructType);
-
-                foreach (var descriptor in descriptors)
-                {
-                    var ubVariable = context.Variable(ubPointerType, StorageClass.Uniform);
-
-                    context.Name(ubVariable, $"{GetStagePrefix(context.Config.Stage)}_c{descriptor.Slot}");
-                    context.Decorate(ubVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-                    context.Decorate(ubVariable, Decoration.Binding, (LiteralInteger)descriptor.Binding);
-                    context.AddGlobalVariable(ubVariable);
-                    context.UniformBuffers.Add(descriptor.Slot, ubVariable);
-                }
+                context.ConstantBuffers.Add(buffer.Binding, ubVariable);
             }
         }
 
@@ -394,25 +372,11 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             foreach (var ioDefinition in info.IoDefinitions)
             {
-                var ioVariable = ioDefinition.IoVariable;
-
-                // Those are actually from constant buffer, rather than being actual inputs or outputs,
-                // so we must ignore them here as they are declared as part of the support buffer.
-                // TODO: Delete this after we represent this properly on the IR (as a constant buffer rather than "input").
-                if (ioVariable == IoVariable.FragmentOutputIsBgra ||
-                    ioVariable == IoVariable.SupportBlockRenderScale ||
-                    ioVariable == IoVariable.SupportBlockViewInverse)
-                {
-                    continue;
-                }
-
-                bool isOutput = ioDefinition.StorageKind.IsOutput();
-                bool isPerPatch = ioDefinition.StorageKind.IsPerPatch();
-
                 PixelImap iq = PixelImap.Unused;
 
                 if (context.Config.Stage == ShaderStage.Fragment)
                 {
+                    var ioVariable = ioDefinition.IoVariable;
                     if (ioVariable == IoVariable.UserDefined)
                     {
                         iq = context.Config.ImapTypes[ioDefinition.Location].GetFirstUsedType();
@@ -429,6 +393,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                     }
                 }
 
+                bool isOutput = ioDefinition.StorageKind.IsOutput();
+                bool isPerPatch = ioDefinition.StorageKind.IsPerPatch();
+
                 DeclareInputOrOutput(context, ioDefinition, isOutput, isPerPatch, iq);
             }
         }

src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs

@@ -98,7 +98,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             Add(Instruction.ImageStore,               GenerateImageStore);
             Add(Instruction.IsNan,                    GenerateIsNan);
             Add(Instruction.Load,                     GenerateLoad);
-            Add(Instruction.LoadConstant,             GenerateLoadConstant);
             Add(Instruction.LoadLocal,                GenerateLoadLocal);
             Add(Instruction.LoadShared,               GenerateLoadShared);
             Add(Instruction.LoadStorage,              GenerateLoadStorage);
@@ -313,10 +312,11 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
             for (int i = 0; i < args.Length; i++)
             {
-                var operand = (AstOperand)operation.GetSource(i + 1);
+                var operand = operation.GetSource(i + 1);
+
                 if (i >= function.InArguments.Length)
                 {
-                    args[i] = context.GetLocalPointer(operand);
+                    args[i] = context.GetLocalPointer((AstOperand)operand);
                 }
                 else
                 {
@@ -867,68 +867,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             return GenerateLoadOrStore(context, operation, isStore: false);
         }
 
-        private static OperationResult GenerateLoadConstant(CodeGenContext context, AstOperation operation)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = context.Get(AggregateType.S32, operation.GetSource(1));
-
-            var i1 = context.Constant(context.TypeS32(), 0);
-            var i2 = context.ShiftRightArithmetic(context.TypeS32(), src2, context.Constant(context.TypeS32(), 2));
-            var i3 = context.BitwiseAnd(context.TypeS32(), src2, context.Constant(context.TypeS32(), 3));
-
-            SpvInstruction value = null;
-
-            if (context.Config.GpuAccessor.QueryHostHasVectorIndexingBug())
-            {
-                // Test for each component individually.
-                for (int i = 0; i < 4; i++)
-                {
-                    var component = context.Constant(context.TypeS32(), i);
-
-                    SpvInstruction elemPointer;
-                    if (context.UniformBuffersArray != null)
-                    {
-                        var ubVariable = context.UniformBuffersArray;
-                        var i0 = context.Get(AggregateType.S32, src1);
-
-                        elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i0, i1, i2, component);
-                    }
-                    else
-                    {
-                        var ubVariable = context.UniformBuffers[((AstOperand)src1).Value];
-
-                        elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i1, i2, component);
-                    }
-
-                    SpvInstruction newValue = context.Load(context.TypeFP32(), elemPointer);
-
-                    value = value != null ? context.Select(context.TypeFP32(), context.IEqual(context.TypeBool(), i3, component), newValue, value) : newValue;
-                }
-            }
-            else
-            {
-                SpvInstruction elemPointer;
-
-                if (context.UniformBuffersArray != null)
-                {
-                    var ubVariable = context.UniformBuffersArray;
-                    var i0 = context.Get(AggregateType.S32, src1);
-
-                    elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i0, i1, i2, i3);
-                }
-                else
-                {
-                    var ubVariable = context.UniformBuffers[((AstOperand)src1).Value];
-
-                    elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i1, i2, i3);
-                }
-
-                value = context.Load(context.TypeFP32(), elemPointer);
-            }
-
-            return new OperationResult(AggregateType.FP32, value);
-        }
-
         private static OperationResult GenerateLoadLocal(CodeGenContext context, AstOperation operation)
         {
             return GenerateLoadLocalOrShared(context, operation, StorageClass.Private, context.LocalMemory);
@@ -1623,7 +1561,19 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
             if (hasLodBias)
             {
-               lodBias = Src(AggregateType.FP32);
+                lodBias = Src(AggregateType.FP32);
+            }
+
+            if (!isGather && !intCoords && !isMultisample && !hasLodLevel && !hasDerivatives && context.Config.Stage != ShaderStage.Fragment)
+            {
+                // Implicit LOD is only valid on fragment.
+                // Use the LOD bias as explicit LOD if available.
+
+                lod = lodBias ?? context.Constant(context.TypeFP32(), 0f);
+
+                lodBias = null;
+                hasLodBias = false;
+                hasLodLevel = true;
             }
 
             SpvInstruction compIdx = null;
@@ -1978,12 +1928,32 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             StorageKind storageKind = operation.StorageKind;
 
-            SpvInstruction pointer;
+            StorageClass storageClass;
+            SpvInstruction baseObj;
             AggregateType varType;
             int srcIndex = 0;
 
             switch (storageKind)
             {
+                case StorageKind.ConstantBuffer:
+                    if (!(operation.GetSource(srcIndex++) is AstOperand bindingIndex) || bindingIndex.Type != OperandType.Constant)
+                    {
+                        throw new InvalidOperationException($"First input of {operation.Inst} with {storageKind} storage must be a constant operand.");
+                    }
+
+                    if (!(operation.GetSource(srcIndex) is AstOperand fieldIndex) || fieldIndex.Type != OperandType.Constant)
+                    {
+                        throw new InvalidOperationException($"Second input of {operation.Inst} with {storageKind} storage must be a constant operand.");
+                    }
+
+                    BufferDefinition buffer = context.Config.Properties.ConstantBuffers[bindingIndex.Value];
+                    StructureField field = buffer.Type.Fields[fieldIndex.Value];
+
+                    storageClass = StorageClass.Uniform;
+                    varType = field.Type & AggregateType.ElementTypeMask;
+                    baseObj = context.ConstantBuffers[bindingIndex.Value];
+                    break;
+
                 case StorageKind.Input:
                 case StorageKind.InputPerPatch:
                 case StorageKind.Output:
@@ -2026,33 +1996,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                     {
                         varType = context.Config.GetFragmentOutputColorType(location);
                     }
-                    else if (ioVariable == IoVariable.FragmentOutputIsBgra)
-                    {
-                        var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeU32());
-                        var elemIndex = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                        pointer = context.AccessChain(pointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 1), elemIndex);
-                        varType = AggregateType.U32;
-
-                        break;
-                    }
-                    else if (ioVariable == IoVariable.SupportBlockRenderScale)
-                    {
-                        var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-                        var elemIndex = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                        pointer = context.AccessChain(pointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 4), elemIndex);
-                        varType = AggregateType.FP32;
-
-                        break;
-                    }
-                    else if (ioVariable == IoVariable.SupportBlockViewInverse)
-                    {
-                        var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-                        var elemIndex = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                        pointer = context.AccessChain(pointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 2), elemIndex);
-                        varType = AggregateType.FP32;
-
-                        break;
-                    }
                     else
                     {
                         (_, varType) = IoMap.GetSpirvBuiltIn(ioVariable);
@@ -2060,55 +2003,57 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
                     varType &= AggregateType.ElementTypeMask;
 
-                    int inputsCount = (isStore ? operation.SourcesCount - 1 : operation.SourcesCount) - srcIndex;
-                    var storageClass = isOutput ? StorageClass.Output : StorageClass.Input;
+                    storageClass = isOutput ? StorageClass.Output : StorageClass.Input;
 
                     var ioDefinition = new IoDefinition(storageKind, ioVariable, location, component);
                     var dict = isPerPatch
                         ? (isOutput ? context.OutputsPerPatch : context.InputsPerPatch)
                         : (isOutput ? context.Outputs : context.Inputs);
 
-                    SpvInstruction baseObj = dict[ioDefinition];
-                    SpvInstruction e0, e1, e2;
-
-                    switch (inputsCount)
-                    {
-                        case 0:
-                            pointer = baseObj;
-                            break;
-                        case 1:
-                            e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0);
-                            break;
-                        case 2:
-                            e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            e1 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0, e1);
-                            break;
-                        case 3:
-                            e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            e1 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            e2 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0, e1, e2);
-                            break;
-                        default:
-                            var indexes = new SpvInstruction[inputsCount];
-                            int index = 0;
-
-                            for (; index < inputsCount; srcIndex++, index++)
-                            {
-                                indexes[index] = context.Get(AggregateType.S32, operation.GetSource(srcIndex));
-                            }
-
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, indexes);
-                            break;
-                    }
+                    baseObj = dict[ioDefinition];
                     break;
 
                 default:
                     throw new InvalidOperationException($"Invalid storage kind {storageKind}.");
             }
 
+            int inputsCount = (isStore ? operation.SourcesCount - 1 : operation.SourcesCount) - srcIndex;
+            SpvInstruction e0, e1, e2;
+            SpvInstruction pointer;
+
+            switch (inputsCount)
+            {
+                case 0:
+                    pointer = baseObj;
+                    break;
+                case 1:
+                    e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
+                    pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0);
+                    break;
+                case 2:
+                    e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
+                    e1 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
+                    pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0, e1);
+                    break;
+                case 3:
+                    e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
+                    e1 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
+                    e2 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
+                    pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0, e1, e2);
+                    break;
+                default:
+                    var indexes = new SpvInstruction[inputsCount];
+                    int index = 0;
+
+                    for (; index < inputsCount; srcIndex++, index++)
+                    {
+                        indexes[index] = context.Get(AggregateType.S32, operation.GetSource(srcIndex));
+                    }
+
+                    pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, indexes);
+                    break;
+            }
+
             if (isStore)
             {
                 context.Store(pointer, context.Get(varType, operation.GetSource(srcIndex)));

src/Ryujinx.Graphics.Shader/CodeGen/Spirv/ScalingHelpers.cs

@@ -63,7 +63,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             if (context.Config.Stage == ShaderStage.Vertex)
             {
                 var scaleCountPointerType = context.TypePointer(StorageClass.Uniform, context.TypeS32());
-                var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 3));
+                var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.ConstantBuffers[0], context.Constant(context.TypeU32(), 3));
                 var scaleCount = context.Load(context.TypeS32(), scaleCountElemPointer);
 
                 scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, scaleCount);
@@ -71,7 +71,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
             scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, context.Constant(context.TypeU32(), 1));
 
-            var scaleElemPointer = context.AccessChain(pointerType, context.SupportBuffer, fieldIndex, scaleIndex);
+            var scaleElemPointer = context.AccessChain(pointerType, context.ConstantBuffers[0], fieldIndex, scaleIndex);
             var scale = context.Load(context.TypeFP32(), scaleElemPointer);
 
             var ivector2Type = context.TypeVector(context.TypeS32(), 2);
@@ -201,7 +201,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                 if (context.Config.Stage == ShaderStage.Vertex)
                 {
                     var scaleCountPointerType = context.TypePointer(StorageClass.Uniform, context.TypeS32());
-                    var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 3));
+                    var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.ConstantBuffers[0], context.Constant(context.TypeU32(), 3));
                     var scaleCount = context.Load(context.TypeS32(), scaleCountElemPointer);
 
                     scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, scaleCount);
@@ -209,7 +209,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
                 scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, context.Constant(context.TypeU32(), 1));
 
-                var scaleElemPointer = context.AccessChain(pointerType, context.SupportBuffer, fieldIndex, scaleIndex);
+                var scaleElemPointer = context.AccessChain(pointerType, context.ConstantBuffers[0], fieldIndex, scaleIndex);
                 var scale = context.GlslFAbs(context.TypeFP32(), context.Load(context.TypeFP32(), scaleElemPointer));
 
                 var passthrough = context.FOrdEqual(context.TypeBool(), scale, context.Constant(context.TypeFP32(), 1f));

src/Ryujinx.Graphics.Shader/Instructions/InstEmitAttribute.cs

@@ -160,7 +160,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
                 {
                     // FragCoord X/Y must be divided by the render target scale, if resolution scaling is active,
                     // because the shader code is not expecting scaled values.
-                    res = context.FPDivide(res, context.Load(StorageKind.Input, IoVariable.SupportBlockRenderScale, null, Const(0)));
+                    res = context.FPDivide(res, context.Load(StorageKind.ConstantBuffer, SupportBuffer.Binding, Const((int)SupportBufferField.RenderScale), Const(0)));
                 }
                 else if (op.Imm10 == AttributeConsts.FrontFacing && context.Config.GpuAccessor.QueryHostHasFrontFacingBug())
                 {

src/Ryujinx.Graphics.Shader/Instructions/InstEmitMemory.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Graphics.Shader.Decoders;
 using Ryujinx.Graphics.Shader.IntermediateRepresentation;
 using Ryujinx.Graphics.Shader.Translation;
+using System.Numerics;
 
 using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
 using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
@@ -80,7 +81,6 @@ namespace Ryujinx.Graphics.Shader.Instructions
 
             Operand addr = context.IAdd(srcA, Const(Imm16ToSInt(op.CbufOffset)));
             Operand wordOffset = context.ShiftRightU32(addr, Const(2));
-            Operand bitOffset = GetBitOffset(context, addr);
 
             for (int index = 0; index < count; index++)
             {
@@ -92,11 +92,11 @@ namespace Ryujinx.Graphics.Shader.Instructions
                 }
 
                 Operand offset = context.IAdd(wordOffset, Const(index));
-                Operand value = context.LoadConstant(slot, offset);
+                Operand value = EmitLoadConstant(context, slot, offset);
 
                 if (isSmallInt)
                 {
-                    value = ExtractSmallInt(context, (LsSize)op.LsSize, bitOffset, value);
+                    value = ExtractSmallInt(context, (LsSize)op.LsSize, GetBitOffset(context, addr), value);
                 }
 
                 context.Copy(Register(dest), value);
@@ -154,6 +154,39 @@ namespace Ryujinx.Graphics.Shader.Instructions
             EmitStore(context, MemoryRegion.Shared, op.LsSize, GetSrcReg(context, op.SrcA), op.Dest, Imm24ToSInt(op.Imm24));
         }
 
+        private static Operand EmitLoadConstant(EmitterContext context, Operand slot, Operand offset)
+        {
+            Operand vecIndex = context.ShiftRightU32(offset, Const(2));
+            Operand elemIndex = context.BitwiseAnd(offset, Const(3));
+
+            if (slot.Type == OperandType.Constant)
+            {
+                int binding = context.Config.ResourceManager.GetConstantBufferBinding(slot.Value);
+                return context.Load(StorageKind.ConstantBuffer, binding, Const(0), vecIndex, elemIndex);
+            }
+            else
+            {
+                Operand value = Const(0);
+
+                uint cbUseMask = context.Config.GpuAccessor.QueryConstantBufferUse();
+
+                while (cbUseMask != 0)
+                {
+                    int cbIndex = BitOperations.TrailingZeroCount(cbUseMask);
+                    int binding = context.Config.ResourceManager.GetConstantBufferBinding(cbIndex);
+
+                    Operand isCurrent = context.ICompareEqual(slot, Const(cbIndex));
+                    Operand currentValue = context.Load(StorageKind.ConstantBuffer, binding, Const(0), vecIndex, elemIndex);
+
+                    value = context.ConditionalSelect(isCurrent, currentValue, value);
+
+                    cbUseMask &= ~(1u << cbIndex);
+                }
+
+                return value;
+            }
+        }
+
         private static Operand EmitAtomicOp(
             EmitterContext context,
             StorageKind storageKind,

src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Instruction.cs

@@ -79,7 +79,6 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
         ImageAtomic,
         IsNan,
         Load,
-        LoadConstant,
         LoadGlobal,
         LoadLocal,
         LoadShared,

src/Ryujinx.Graphics.Shader/IntermediateRepresentation/IoVariable.cs

@@ -15,7 +15,6 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
         FragmentCoord,
         FragmentOutputColor,
         FragmentOutputDepth,
-        FragmentOutputIsBgra, // TODO: Remove and use constant buffer access.
         FrontColorDiffuse,
         FrontColorSpecular,
         FrontFacing,
@@ -34,8 +33,6 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
         SubgroupLaneId,
         SubgroupLeMask,
         SubgroupLtMask,
-        SupportBlockViewInverse, // TODO: Remove and use constant buffer access.
-        SupportBlockRenderScale, // TODO: Remove and use constant buffer access.
         TessellationCoord,
         TessellationLevelInner,
         TessellationLevelOuter,

src/Ryujinx.Graphics.Shader/StructuredIr/AstOperand.cs

@@ -15,9 +15,6 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
 
         public int Value { get; }
 
-        public int CbufSlot   { get; }
-        public int CbufOffset { get; }
-
         private AstOperand()
         {
             Defs = new HashSet<IAstNode>();
@@ -29,16 +26,7 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
         public AstOperand(Operand operand) : this()
         {
             Type = operand.Type;
-
-            if (Type == OperandType.ConstantBuffer)
-            {
-                CbufSlot   = operand.GetCbufSlot();
-                CbufOffset = operand.GetCbufOffset();
-            }
-            else
-            {
-                Value = operand.Value;
-            }
+            Value = operand.Value;
         }
 
         public AstOperand(OperandType type, int value = 0)  : this()

src/Ryujinx.Graphics.Shader/StructuredIr/BufferDefinition.cs

@@ -0,0 +1,20 @@
+namespace Ryujinx.Graphics.Shader.StructuredIr
+{
+    readonly struct BufferDefinition
+    {
+        public BufferLayout Layout { get; }
+        public int Set { get; }
+        public int Binding { get; }
+        public string Name { get; }
+        public StructureType Type { get; }
+
+        public BufferDefinition(BufferLayout layout, int set, int binding, string name, StructureType type)
+        {
+            Layout = layout;
+            Set = set;
+            Binding = binding;
+            Name = name;
+            Type = type;
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/StructuredIr/BufferLayout.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.Graphics.Shader.StructuredIr
+{
+    enum BufferLayout
+    {
+        Std140,
+        Std430
+    }
+}

src/Ryujinx.Graphics.Shader/StructuredIr/InstructionInfo.cs

@@ -90,7 +90,6 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
             Add(Instruction.ImageAtomic,              AggregateType.S32);
             Add(Instruction.IsNan,                    AggregateType.Bool,   AggregateType.Scalar);
             Add(Instruction.Load,                     AggregateType.FP32);
-            Add(Instruction.LoadConstant,             AggregateType.FP32,   AggregateType.S32,     AggregateType.S32);
             Add(Instruction.LoadGlobal,               AggregateType.U32,    AggregateType.S32,     AggregateType.S32);
             Add(Instruction.LoadLocal,                AggregateType.U32,    AggregateType.S32);
             Add(Instruction.LoadShared,               AggregateType.U32,    AggregateType.S32);

src/Ryujinx.Graphics.Shader/StructuredIr/OperandInfo.cs

@@ -24,7 +24,6 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
             {
                 OperandType.Argument => AggregateType.S32,
                 OperandType.Constant => AggregateType.S32,
-                OperandType.ConstantBuffer => AggregateType.FP32,
                 OperandType.Undefined => AggregateType.S32,
                 _ => throw new ArgumentException($"Invalid operand type \"{type}\".")
             };

src/Ryujinx.Graphics.Shader/StructuredIr/ShaderProperties.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.Shader.StructuredIr
+{
+    class ShaderProperties
+    {
+        private readonly Dictionary<int, BufferDefinition> _constantBuffers;
+
+        public IReadOnlyDictionary<int, BufferDefinition> ConstantBuffers => _constantBuffers;
+
+        public ShaderProperties()
+        {
+            _constantBuffers = new Dictionary<int, BufferDefinition>();
+        }
+
+        public void AddConstantBuffer(int binding, BufferDefinition definition)
+        {
+            _constantBuffers[binding] = definition;
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/StructuredIr/StructureType.cs

@@ -0,0 +1,28 @@
+using Ryujinx.Graphics.Shader.Translation;
+
+namespace Ryujinx.Graphics.Shader.StructuredIr
+{
+    struct StructureField
+    {
+        public AggregateType Type { get; }
+        public string Name { get; }
+        public int ArrayLength { get; }
+
+        public StructureField(AggregateType type, string name, int arrayLength = 1)
+        {
+            Type = type;
+            Name = name;
+            ArrayLength = arrayLength;
+        }
+    }
+
+    class StructureType
+    {
+        public StructureField[] Fields { get; }
+
+        public StructureType(StructureField[] fields)
+        {
+            Fields = fields;
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/StructuredIr/StructuredProgram.cs

@@ -73,27 +73,34 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
             Instruction inst = operation.Inst;
             StorageKind storageKind = operation.StorageKind;
 
-            if ((inst == Instruction.Load || inst == Instruction.Store) && storageKind.IsInputOrOutput())
+            if (inst == Instruction.Load || inst == Instruction.Store)
             {
-                IoVariable ioVariable = (IoVariable)operation.GetSource(0).Value;
-                bool isOutput = storageKind.IsOutput();
-                bool perPatch = storageKind.IsPerPatch();
-                int location = 0;
-                int component = 0;
-
-                if (context.Config.HasPerLocationInputOrOutput(ioVariable, isOutput))
+                if (storageKind.IsInputOrOutput())
                 {
-                    location = operation.GetSource(1).Value;
+                    IoVariable ioVariable = (IoVariable)operation.GetSource(0).Value;
+                    bool isOutput = storageKind.IsOutput();
+                    bool perPatch = storageKind.IsPerPatch();
+                    int location = 0;
+                    int component = 0;
 
-                    if (operation.SourcesCount > 2 &&
-                        operation.GetSource(2).Type == OperandType.Constant &&
-                        context.Config.HasPerLocationInputOrOutputComponent(ioVariable, location, operation.GetSource(2).Value, isOutput))
+                    if (context.Config.HasPerLocationInputOrOutput(ioVariable, isOutput))
                     {
-                        component = operation.GetSource(2).Value;
-                    }
-                }
+                        location = operation.GetSource(1).Value;
 
-                context.Info.IoDefinitions.Add(new IoDefinition(storageKind, ioVariable, location, component));
+                        if (operation.SourcesCount > 2 &&
+                            operation.GetSource(2).Type == OperandType.Constant &&
+                            context.Config.HasPerLocationInputOrOutputComponent(ioVariable, location, operation.GetSource(2).Value, isOutput))
+                        {
+                            component = operation.GetSource(2).Value;
+                        }
+                    }
+
+                    context.Info.IoDefinitions.Add(new IoDefinition(storageKind, ioVariable, location, component));
+                }
+                else if (storageKind == StorageKind.ConstantBuffer && operation.GetSource(0).Type == OperandType.Constant)
+                {
+                    context.Config.ResourceManager.SetUsedConstantBufferBinding(operation.GetSource(0).Value);
+                }
             }
 
             bool vectorDest = IsVectorDestInst(inst);
@@ -105,7 +112,7 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
 
             for (int index = 0; index < operation.SourcesCount; index++)
             {
-                sources[index] = context.GetOperand(operation.GetSource(index));
+                sources[index] = context.GetOperandOrCbLoad(operation.GetSource(index));
             }
 
             for (int index = 0; index < outDestsCount; index++)

src/Ryujinx.Graphics.Shader/StructuredIr/StructuredProgramContext.cs

@@ -298,6 +298,33 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
             return newTemp;
         }
 
+        public IAstNode GetOperandOrCbLoad(Operand operand)
+        {
+            if (operand.Type == OperandType.ConstantBuffer)
+            {
+                int cbufSlot = operand.GetCbufSlot();
+                int cbufOffset = operand.GetCbufOffset();
+
+                int binding = Config.ResourceManager.GetConstantBufferBinding(cbufSlot);
+                int vecIndex = cbufOffset >> 2;
+                int elemIndex = cbufOffset & 3;
+
+                Config.ResourceManager.SetUsedConstantBufferBinding(binding);
+
+                IAstNode[] sources = new IAstNode[]
+                {
+                    new AstOperand(OperandType.Constant, binding),
+                    new AstOperand(OperandType.Constant, 0),
+                    new AstOperand(OperandType.Constant, vecIndex),
+                    new AstOperand(OperandType.Constant, elemIndex)
+                };
+
+                return new AstOperation(Instruction.Load, StorageKind.ConstantBuffer, sources, sources.Length);
+            }
+
+            return GetOperand(operand);
+        }
+
         public AstOperand GetOperand(Operand operand)
         {
             if (operand == null)
@@ -307,11 +334,6 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
 
             if (operand.Type != OperandType.LocalVariable)
             {
-                if (operand.Type == OperandType.ConstantBuffer)
-                {
-                    Config.SetUsedConstantBuffer(operand.GetCbufSlot());
-                }
-
                 return new AstOperand(operand);
             }
 

src/Ryujinx.Graphics.Shader/SupportBuffer.cs

@@ -1,4 +1,6 @@
 using Ryujinx.Common.Memory;
+using Ryujinx.Graphics.Shader.StructuredIr;
+using Ryujinx.Graphics.Shader.Translation;
 using System.Runtime.CompilerServices;
 
 namespace Ryujinx.Graphics.Shader
@@ -11,8 +13,20 @@ namespace Ryujinx.Graphics.Shader
         public T W;
     }
 
+    enum SupportBufferField
+    {
+        // Must match the order of the fields on the struct.
+        FragmentAlphaTest,
+        FragmentIsBgra,
+        ViewportInverse,
+        FragmentRenderScaleCount,
+        RenderScale
+    }
+
     public struct SupportBuffer
     {
+        internal const int Binding = 0;
+
         public static int FieldSize;
         public static int RequiredSize;
 
@@ -47,6 +61,18 @@ namespace Ryujinx.Graphics.Shader
             ComputeRenderScaleOffset = GraphicsRenderScaleOffset + FieldSize;
         }
 
+        internal static StructureType GetStructureType()
+        {
+            return new StructureType(new[]
+            {
+                new StructureField(AggregateType.U32, "s_alpha_test"),
+                new StructureField(AggregateType.Array | AggregateType.U32, "s_is_bgra", FragmentIsBgraCount),
+                new StructureField(AggregateType.Vector4 | AggregateType.FP32, "s_viewport_inverse"),
+                new StructureField(AggregateType.S32, "s_frag_scale_count"),
+                new StructureField(AggregateType.Array | AggregateType.FP32, "s_render_scale", RenderScaleMaxCount)
+            });
+        }
+
         public Vector4<int> FragmentAlphaTest;
         public Array8<Vector4<int>> FragmentIsBgra;
         public Vector4<float> ViewportInverse;

src/Ryujinx.Graphics.Shader/Translation/AggregateType.cs

@@ -22,4 +22,35 @@
 
         Array  = 1 << 10
     }
+
+    static class AggregateTypeExtensions
+    {
+        public static int GetSizeInBytes(this AggregateType type)
+        {
+            int elementSize = (type & AggregateType.ElementTypeMask) switch
+            {
+                AggregateType.Bool or
+                AggregateType.FP32 or
+                AggregateType.S32 or
+                AggregateType.U32 => 4,
+                AggregateType.FP64 => 8,
+                _ => 0
+            };
+
+            switch (type & AggregateType.ElementCountMask)
+            {
+                case AggregateType.Vector2:
+                    elementSize *= 2;
+                    break;
+                case AggregateType.Vector3:
+                    elementSize *= 3;
+                    break;
+                case AggregateType.Vector4:
+                    elementSize *= 4;
+                    break;
+            }
+
+            return elementSize;
+        }
+    }
 }

src/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs

@@ -234,8 +234,8 @@ namespace Ryujinx.Graphics.Shader.Translation
             {
                 Operand x = this.Load(StorageKind.Output, IoVariable.Position, null, Const(0));
                 Operand y = this.Load(StorageKind.Output, IoVariable.Position, null, Const(1));
-                Operand xScale = this.Load(StorageKind.Input, IoVariable.SupportBlockViewInverse, null, Const(0));
-                Operand yScale = this.Load(StorageKind.Input, IoVariable.SupportBlockViewInverse, null, Const(1));
+                Operand xScale = this.Load(StorageKind.ConstantBuffer, SupportBuffer.Binding, Const((int)SupportBufferField.ViewportInverse), Const(0));
+                Operand yScale = this.Load(StorageKind.ConstantBuffer, SupportBuffer.Binding, Const((int)SupportBufferField.ViewportInverse), Const(1));
                 Operand negativeOne = ConstF(-1.0f);
 
                 this.Store(StorageKind.Output, IoVariable.Position, null, Const(0), this.FPFusedMultiplyAdd(x, xScale, negativeOne));
@@ -420,7 +420,7 @@ namespace Ryujinx.Graphics.Shader.Translation
                         // Perform B <-> R swap if needed, for BGRA formats (not supported on OpenGL).
                         if (!supportsBgra && (component == 0 || component == 2))
                         {
-                            Operand isBgra = this.Load(StorageKind.Input, IoVariable.FragmentOutputIsBgra, null, Const(rtIndex));
+                            Operand isBgra = this.Load(StorageKind.ConstantBuffer, SupportBuffer.Binding, Const((int)SupportBufferField.FragmentIsBgra), Const(rtIndex));
 
                             Operand lblIsBgra = Label();
                             Operand lblEnd = Label();

src/Ryujinx.Graphics.Shader/Translation/EmitterContextInsts.cs

@@ -549,11 +549,31 @@ namespace Ryujinx.Graphics.Shader.Translation
             return context.Add(fpType | Instruction.IsNan, Local(), a);
         }
 
+        public static Operand Load(this EmitterContext context, StorageKind storageKind, int binding)
+        {
+            return context.Add(Instruction.Load, storageKind, Local(), Const(binding));
+        }
+
+        public static Operand Load(this EmitterContext context, StorageKind storageKind, int binding, Operand e0)
+        {
+            return context.Add(Instruction.Load, storageKind, Local(), Const(binding), e0);
+        }
+
+        public static Operand Load(this EmitterContext context, StorageKind storageKind, int binding, Operand e0, Operand e1)
+        {
+            return context.Add(Instruction.Load, storageKind, Local(), Const(binding), e0, e1);
+        }
+
+        public static Operand Load(this EmitterContext context, StorageKind storageKind, int binding, Operand e0, Operand e1, Operand e2)
+        {
+            return context.Add(Instruction.Load, storageKind, Local(), Const(binding), e0, e1, e2);
+        }
+
         public static Operand Load(this EmitterContext context, StorageKind storageKind, IoVariable ioVariable, Operand primVertex = null)
         {
             return primVertex != null
-                ? context.Add(Instruction.Load, storageKind, Local(), Const((int)ioVariable), primVertex)
-                : context.Add(Instruction.Load, storageKind, Local(), Const((int)ioVariable));
+                ? context.Load(storageKind, (int)ioVariable, primVertex)
+                : context.Load(storageKind, (int)ioVariable);
         }
 
         public static Operand Load(
@@ -564,8 +584,8 @@ namespace Ryujinx.Graphics.Shader.Translation
             Operand elemIndex)
         {
             return primVertex != null
-                ? context.Add(Instruction.Load, storageKind, Local(), Const((int)ioVariable), primVertex, elemIndex)
-                : context.Add(Instruction.Load, storageKind, Local(), Const((int)ioVariable), elemIndex);
+                ? context.Load(storageKind, (int)ioVariable, primVertex, elemIndex)
+                : context.Load(storageKind, (int)ioVariable, elemIndex);
         }
 
         public static Operand Load(
@@ -577,22 +597,8 @@ namespace Ryujinx.Graphics.Shader.Translation
             Operand elemIndex)
         {
             return primVertex != null
-                ? context.Add(Instruction.Load, storageKind, Local(), Const((int)ioVariable), primVertex, arrayIndex, elemIndex)
-                : context.Add(Instruction.Load, storageKind, Local(), Const((int)ioVariable), arrayIndex, elemIndex);
-        }
-
-        public static Operand LoadConstant(this EmitterContext context, Operand a, Operand b)
-        {
-            if (a.Type == OperandType.Constant)
-            {
-                context.Config.SetUsedConstantBuffer(a.Value);
-            }
-            else
-            {
-                context.Config.SetUsedFeature(FeatureFlags.CbIndexing);
-            }
-
-            return context.Add(Instruction.LoadConstant, Local(), a, b);
+                ? context.Load(storageKind, (int)ioVariable, primVertex, arrayIndex, elemIndex)
+                : context.Load(storageKind, (int)ioVariable, arrayIndex, elemIndex);
         }
 
         public static Operand LoadGlobal(this EmitterContext context, Operand a, Operand b)

src/Ryujinx.Graphics.Shader/Translation/FeatureFlags.cs

@@ -19,7 +19,6 @@ namespace Ryujinx.Graphics.Shader.Translation
         InstanceId = 1 << 3,
         DrawParameters = 1 << 4,
         RtLayer = 1 << 5,
-        CbIndexing = 1 << 6,
         IaIndexing = 1 << 7,
         OaIndexing = 1 << 8,
         FixedFuncAttr = 1 << 9

src/Ryujinx.Graphics.Shader/Translation/Optimizations/BindlessToIndexed.cs

@@ -32,25 +32,49 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                     continue;
                 }
 
-                if (handleAsgOp.Inst != Instruction.LoadConstant)
+                if (handleAsgOp.Inst != Instruction.Load ||
+                    handleAsgOp.StorageKind != StorageKind.ConstantBuffer ||
+                    handleAsgOp.SourcesCount != 4)
                 {
                     continue;
                 }
 
                 Operand ldcSrc0 = handleAsgOp.GetSource(0);
+
+                if (ldcSrc0.Type != OperandType.Constant ||
+                    !config.ResourceManager.TryGetConstantBufferSlot(ldcSrc0.Value, out int src0CbufSlot) ||
+                    src0CbufSlot != 2)
+                {
+                    continue;
+                }
+
                 Operand ldcSrc1 = handleAsgOp.GetSource(1);
 
-                if (ldcSrc0.Type != OperandType.Constant || ldcSrc0.Value != 2)
+                // We expect field index 0 to be accessed.
+                if (ldcSrc1.Type != OperandType.Constant || ldcSrc1.Value != 0)
                 {
                     continue;
                 }
 
-                if (!(ldcSrc1.AsgOp is Operation shrOp) || shrOp.Inst != Instruction.ShiftRightU32)
+                Operand ldcSrc2 = handleAsgOp.GetSource(2);
+
+                // FIXME: This is missing some checks, for example, a check to ensure that the shift value is 2.
+                // Might be not worth fixing since if that doesn't kick in, the result will be no texture
+                // to access anyway which is also wrong.
+                // Plus this whole transform is fundamentally flawed as-is since we have no way to know the array size.
+                // Eventually, this should be entirely removed in favor of a implementation that supports true bindless
+                // texture access.
+                if (!(ldcSrc2.AsgOp is Operation shrOp) || shrOp.Inst != Instruction.ShiftRightU32)
                 {
                     continue;
                 }
 
-                if (!(shrOp.GetSource(0).AsgOp is Operation addOp) || addOp.Inst != Instruction.Add)
+                if (!(shrOp.GetSource(0).AsgOp is Operation shrOp2) || shrOp2.Inst != Instruction.ShiftRightU32)
+                {
+                    continue;
+                }
+
+                if (!(shrOp2.GetSource(0).AsgOp is Operation addOp) || addOp.Inst != Instruction.Add)
                 {
                     continue;
                 }

src/Ryujinx.Graphics.Shader/Translation/Optimizations/ConstantFolding.cs

@@ -8,7 +8,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 {
     static class ConstantFolding
     {
-        public static void RunPass(Operation operation)
+        public static void RunPass(ShaderConfig config, Operation operation)
         {
             if (!AreAllSourcesConstant(operation))
             {
@@ -153,8 +153,21 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                     EvaluateFPUnary(operation, (x) => float.IsNaN(x));
                     break;
 
-                case Instruction.LoadConstant:
-                    operation.TurnIntoCopy(Cbuf(operation.GetSource(0).Value, operation.GetSource(1).Value));
+                case Instruction.Load:
+                    if (operation.StorageKind == StorageKind.ConstantBuffer && operation.SourcesCount == 4)
+                    {
+                        int binding = operation.GetSource(0).Value;
+                        int fieldIndex = operation.GetSource(1).Value;
+
+                        if (config.ResourceManager.TryGetConstantBufferSlot(binding, out int cbufSlot) && fieldIndex == 0)
+                        {
+                            int vecIndex = operation.GetSource(2).Value;
+                            int elemIndex = operation.GetSource(3).Value;
+                            int cbufOffset = vecIndex * 4 + elemIndex;
+
+                            operation.TurnIntoCopy(Cbuf(cbufSlot, cbufOffset));
+                        }
+                    }
                     break;
 
                 case Instruction.Maximum:

src/Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs

@@ -347,21 +347,23 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                 return wordOffset;
             }
 
-            Operand[] sources = new Operand[operation.SourcesCount];
+            Operand cbufOffset = GetCbufOffset();
+            Operand vecIndex = Local();
+            Operand elemIndex = Local();
+
+            node.List.AddBefore(node, new Operation(Instruction.ShiftRightU32, 0, vecIndex, cbufOffset, Const(2)));
+            node.List.AddBefore(node, new Operation(Instruction.BitwiseAnd, 0, elemIndex, cbufOffset, Const(3)));
+
+            Operand[] sources = new Operand[4];
 
             int cbSlot = UbeFirstCbuf + storageIndex;
 
-            sources[0] = Const(cbSlot);
-            sources[1] = GetCbufOffset();
+            sources[0] = Const(config.ResourceManager.GetConstantBufferBinding(cbSlot));
+            sources[1] = Const(0);
+            sources[2] = vecIndex;
+            sources[3] = elemIndex;
 
-            config.SetUsedConstantBuffer(cbSlot);
-
-            for (int index = 2; index < operation.SourcesCount; index++)
-            {
-                sources[index] = operation.GetSource(index);
-            }
-
-            Operation ldcOp = new Operation(Instruction.LoadConstant, operation.Dest, sources);
+            Operation ldcOp = new Operation(Instruction.Load, StorageKind.ConstantBuffer, operation.Dest, sources);
 
             for (int index = 0; index < operation.SourcesCount; index++)
             {

src/Ryujinx.Graphics.Shader/Translation/Optimizations/Optimizer.cs

@@ -9,7 +9,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
     {
         public static void RunPass(BasicBlock[] blocks, ShaderConfig config)
         {
-            RunOptimizationPasses(blocks);
+            RunOptimizationPasses(blocks, config);
 
             int sbUseMask = 0;
             int ubeUseMask = 0;
@@ -31,10 +31,10 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
             config.SetAccessibleBufferMasks(sbUseMask, ubeUseMask);
 
             // Run optimizations one last time to remove any code that is now optimizable after above passes.
-            RunOptimizationPasses(blocks);
+            RunOptimizationPasses(blocks, config);
         }
 
-        private static void RunOptimizationPasses(BasicBlock[] blocks)
+        private static void RunOptimizationPasses(BasicBlock[] blocks, ShaderConfig config)
         {
             bool modified;
 
@@ -73,7 +73,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                             continue;
                         }
 
-                        ConstantFolding.RunPass(operation);
+                        ConstantFolding.RunPass(config, operation);
                         Simplification.RunPass(operation);
 
                         if (DestIsLocalVar(operation))

src/Ryujinx.Graphics.Shader/Translation/ResourceManager.cs

@@ -0,0 +1,126 @@
+using Ryujinx.Graphics.Shader.StructuredIr;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace Ryujinx.Graphics.Shader.Translation
+{
+    class ResourceManager
+    {
+        private static readonly string[] _stagePrefixes = new string[] { "cp", "vp", "tcp", "tep", "gp", "fp" };
+
+        private readonly IGpuAccessor _gpuAccessor;
+        private readonly ShaderProperties _properties;
+        private readonly string _stagePrefix;
+
+        private readonly int[] _cbSlotToBindingMap;
+
+        private readonly HashSet<int> _usedConstantBufferBindings;
+
+        public ResourceManager(ShaderStage stage, IGpuAccessor gpuAccessor, ShaderProperties properties)
+        {
+            _gpuAccessor = gpuAccessor;
+            _properties = properties;
+            _stagePrefix = GetShaderStagePrefix(stage);
+
+            _cbSlotToBindingMap = new int[18];
+            _cbSlotToBindingMap.AsSpan().Fill(-1);
+
+            _usedConstantBufferBindings = new HashSet<int>();
+
+            properties.AddConstantBuffer(0, new BufferDefinition(BufferLayout.Std140, 0, 0, "support_buffer", SupportBuffer.GetStructureType()));
+        }
+
+        public int GetConstantBufferBinding(int slot)
+        {
+            int binding = _cbSlotToBindingMap[slot];
+            if (binding < 0)
+            {
+                binding = _gpuAccessor.QueryBindingConstantBuffer(slot);
+                _cbSlotToBindingMap[slot] = binding;
+                string slotNumber = slot.ToString(CultureInfo.InvariantCulture);
+                AddNewConstantBuffer(binding, $"{_stagePrefix}_c{slotNumber}");
+            }
+
+            return binding;
+        }
+
+        public bool TryGetConstantBufferSlot(int binding, out int slot)
+        {
+            for (slot = 0; slot < _cbSlotToBindingMap.Length; slot++)
+            {
+                if (_cbSlotToBindingMap[slot] == binding)
+                {
+                    return true;
+                }
+            }
+
+            slot = 0;
+            return false;
+        }
+
+        public void SetUsedConstantBufferBinding(int binding)
+        {
+            _usedConstantBufferBindings.Add(binding);
+        }
+
+        public BufferDescriptor[] GetConstantBufferDescriptors()
+        {
+            var descriptors = new BufferDescriptor[_usedConstantBufferBindings.Count];
+
+            int descriptorIndex = 0;
+
+            for (int slot = 0; slot < _cbSlotToBindingMap.Length; slot++)
+            {
+                int binding = _cbSlotToBindingMap[slot];
+
+                if (binding >= 0 && _usedConstantBufferBindings.Contains(binding))
+                {
+                    descriptors[descriptorIndex++] = new BufferDescriptor(binding, slot);
+                }
+            }
+
+            if (descriptors.Length != descriptorIndex)
+            {
+                Array.Resize(ref descriptors, descriptorIndex);
+            }
+
+            return descriptors;
+        }
+
+        private void AddNewConstantBuffer(int binding, string name)
+        {
+            StructureType type = new StructureType(new[]
+            {
+                new StructureField(AggregateType.Array | AggregateType.Vector4 | AggregateType.FP32, "data", Constants.ConstantBufferSize / 16)
+            });
+
+            _properties.AddConstantBuffer(binding, new BufferDefinition(BufferLayout.Std140, 0, binding, name, type));
+        }
+
+        public void InheritFrom(ResourceManager other)
+        {
+            for (int i = 0; i < other._cbSlotToBindingMap.Length; i++)
+            {
+                int binding = other._cbSlotToBindingMap[i];
+
+                if (binding >= 0)
+                {
+                    _cbSlotToBindingMap[i] = binding;
+                }
+            }
+        }
+
+        public static string GetShaderStagePrefix(ShaderStage stage)
+        {
+            uint index = (uint)stage;
+
+            if (index >= _stagePrefixes.Length)
+            {
+                return "invalid";
+            }
+
+            return _stagePrefixes[index];
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/Translation/Rewriter.cs

@@ -1,7 +1,6 @@
-using Ryujinx.Graphics.Shader.Decoders;
 using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using Ryujinx.Graphics.Shader.StructuredIr;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Numerics;
 
@@ -16,6 +15,7 @@ namespace Ryujinx.Graphics.Shader.Translation
         {
             bool isVertexShader = config.Stage == ShaderStage.Vertex;
             bool hasConstantBufferDrawParameters = config.GpuAccessor.QueryHasConstantBufferDrawParameters();
+            bool hasVectorIndexingBug = config.GpuAccessor.QueryHostHasVectorIndexingBug();
             bool supportsSnormBufferTextureFormat = config.GpuAccessor.QueryHostSupportsSnormBufferTextureFormat();
 
             for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
@@ -45,6 +45,11 @@ namespace Ryujinx.Graphics.Shader.Translation
                         }
                     }
 
+                    if (hasVectorIndexingBug)
+                    {
+                        InsertVectorComponentSelect(node, config);
+                    }
+
                     LinkedListNode<INode> nextNode = node.Next;
 
                     if (operation is TextureOperation texOp)
@@ -71,6 +76,84 @@ namespace Ryujinx.Graphics.Shader.Translation
             }
         }
 
+        private static void InsertVectorComponentSelect(LinkedListNode<INode> node, ShaderConfig config)
+        {
+            Operation operation = (Operation)node.Value;
+
+            if (operation.Inst != Instruction.Load ||
+                operation.StorageKind != StorageKind.ConstantBuffer ||
+                operation.SourcesCount < 3)
+            {
+                return;
+            }
+
+            Operand bindingIndex = operation.GetSource(0);
+            Operand fieldIndex = operation.GetSource(1);
+            Operand elemIndex = operation.GetSource(operation.SourcesCount - 1);
+
+            if (bindingIndex.Type != OperandType.Constant ||
+                fieldIndex.Type != OperandType.Constant ||
+                elemIndex.Type == OperandType.Constant)
+            {
+                return;
+            }
+
+            BufferDefinition buffer = config.Properties.ConstantBuffers[bindingIndex.Value];
+            StructureField field = buffer.Type.Fields[fieldIndex.Value];
+
+            int elemCount = (field.Type & AggregateType.ElementCountMask) switch
+            {
+                AggregateType.Vector2 => 2,
+                AggregateType.Vector3 => 3,
+                AggregateType.Vector4 => 4,
+                _ => 1
+            };
+
+            if (elemCount == 1)
+            {
+                return;
+            }
+
+            Operand result = null;
+
+            for (int i = 0; i < elemCount; i++)
+            {
+                Operand value = Local();
+                Operand[] inputs = new Operand[operation.SourcesCount];
+
+                for (int srcIndex = 0; srcIndex < inputs.Length - 1; srcIndex++)
+                {
+                    inputs[srcIndex] = operation.GetSource(srcIndex);
+                }
+
+                inputs[inputs.Length - 1] = Const(i);
+
+                Operation loadOp = new Operation(Instruction.Load, StorageKind.ConstantBuffer, value, inputs);
+
+                node.List.AddBefore(node, loadOp);
+
+                if (i == 0)
+                {
+                    result = value;
+                }
+                else
+                {
+                    Operand isCurrentIndex = Local();
+                    Operand selection = Local();
+
+                    Operation compareOp = new Operation(Instruction.CompareEqual, isCurrentIndex, new Operand[] { elemIndex, Const(i) });
+                    Operation selectOp = new Operation(Instruction.ConditionalSelect, selection, new Operand[] { isCurrentIndex, value, result });
+
+                    node.List.AddBefore(node, compareOp);
+                    node.List.AddBefore(node, selectOp);
+
+                    result = selection;
+                }
+            }
+
+            operation.TurnIntoCopy(result);
+        }
+
         private static LinkedListNode<INode> RewriteGlobalAccess(LinkedListNode<INode> node, ShaderConfig config)
         {
             Operation operation = (Operation)node.Value;
@@ -90,6 +173,15 @@ namespace Ryujinx.Graphics.Shader.Translation
                 return local;
             }
 
+            Operand PrependStorageOperation(Instruction inst, StorageKind storageKind, params Operand[] sources)
+            {
+                Operand local = Local();
+
+                node.List.AddBefore(node, new Operation(inst, storageKind, local, sources));
+
+                return local;
+            }
+
             Operand PrependExistingOperation(Operation operation)
             {
                 Operand local = Local();
@@ -204,8 +296,6 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                     cbeUseMask &= ~(1 << slot);
 
-                    config.SetUsedConstantBuffer(cbSlot);
-
                     Operand previousResult = PrependExistingOperation(storageOp);
 
                     int cbOffset = GetConstantUbeOffset(slot);
@@ -216,18 +306,17 @@ namespace Ryujinx.Graphics.Shader.Translation
                     Operand byteOffsetConst = PrependOperation(Instruction.Subtract, addrLow, baseAddrTruncConst);
 
                     Operand cbIndex = PrependOperation(Instruction.ShiftRightU32, byteOffsetConst, Const(2));
+                    Operand vecIndex = PrependOperation(Instruction.ShiftRightU32, cbIndex, Const(2));
+                    Operand elemIndex = PrependOperation(Instruction.BitwiseAnd, cbIndex, Const(3));
 
-                    Operand[] sourcesCb = new Operand[operation.SourcesCount];
+                    Operand[] sourcesCb = new Operand[4];
 
-                    sourcesCb[0] = Const(cbSlot);
-                    sourcesCb[1] = cbIndex;
+                    sourcesCb[0] = Const(config.ResourceManager.GetConstantBufferBinding(cbSlot));
+                    sourcesCb[1] = Const(0);
+                    sourcesCb[2] = vecIndex;
+                    sourcesCb[3] = elemIndex;
 
-                    for (int index = 2; index < operation.SourcesCount; index++)
-                    {
-                        sourcesCb[index] = operation.GetSource(index);
-                    }
-
-                    Operand ldcResult = PrependOperation(Instruction.LoadConstant, sourcesCb);
+                    Operand ldcResult = PrependStorageOperation(Instruction.Load, StorageKind.ConstantBuffer, sourcesCb);
 
                     storageOp = new Operation(Instruction.ConditionalSelect, operation.Dest, inRange, ldcResult, previousResult);
                 }

src/Ryujinx.Graphics.Shader/Translation/ShaderConfig.cs

@@ -39,6 +39,10 @@ namespace Ryujinx.Graphics.Shader.Translation
 
         public TranslationOptions Options { get; }
 
+        public ShaderProperties Properties { get; }
+
+        public ResourceManager ResourceManager { get; }
+
         public bool TransformFeedbackEnabled { get; }
 
         private TransformFeedbackOutput[] _transformFeedbackOutputs;
@@ -109,7 +113,6 @@ namespace Ryujinx.Graphics.Shader.Translation
         public int AccessibleStorageBuffersMask { get; private set; }
         public int AccessibleConstantBuffersMask { get; private set; }
 
-        private int _usedConstantBuffers;
         private int _usedStorageBuffers;
         private int _usedStorageBuffersWrite;
 
@@ -128,20 +131,17 @@ namespace Ryujinx.Graphics.Shader.Translation
         private readonly Dictionary<int, int> _sbSlots;
         private readonly Dictionary<int, int> _sbSlotsReverse;
 
-        private BufferDescriptor[] _cachedConstantBufferDescriptors;
         private BufferDescriptor[] _cachedStorageBufferDescriptors;
         private TextureDescriptor[] _cachedTextureDescriptors;
         private TextureDescriptor[] _cachedImageDescriptors;
 
-        private int _firstConstantBufferBinding;
         private int _firstStorageBufferBinding;
 
-        public int FirstConstantBufferBinding => _firstConstantBufferBinding;
         public int FirstStorageBufferBinding => _firstStorageBufferBinding;
 
-        public ShaderConfig(IGpuAccessor gpuAccessor, TranslationOptions options)
+        public ShaderConfig(ShaderStage stage, IGpuAccessor gpuAccessor, TranslationOptions options)
         {
-            Stage       = ShaderStage.Compute;
+            Stage       = stage;
             GpuAccessor = gpuAccessor;
             Options     = options;
 
@@ -158,6 +158,9 @@ namespace Ryujinx.Graphics.Shader.Translation
 
             _sbSlots        = new Dictionary<int, int>();
             _sbSlotsReverse = new Dictionary<int, int>();
+
+            Properties = new ShaderProperties();
+            ResourceManager = new ResourceManager(stage, gpuAccessor, Properties);
         }
 
         public ShaderConfig(
@@ -165,9 +168,8 @@ namespace Ryujinx.Graphics.Shader.Translation
             OutputTopology outputTopology,
             int maxOutputVertices,
             IGpuAccessor gpuAccessor,
-            TranslationOptions options) : this(gpuAccessor, options)
+            TranslationOptions options) : this(stage, gpuAccessor, options)
         {
-            Stage                    = stage;
             ThreadsPerInputPrimitive = 1;
             OutputTopology           = outputTopology;
             MaxOutputVertices        = maxOutputVertices;
@@ -179,9 +181,8 @@ namespace Ryujinx.Graphics.Shader.Translation
             }
         }
 
-        public ShaderConfig(ShaderHeader header, IGpuAccessor gpuAccessor, TranslationOptions options) : this(gpuAccessor, options)
+        public ShaderConfig(ShaderHeader header, IGpuAccessor gpuAccessor, TranslationOptions options) : this(header.Stage, gpuAccessor, options)
         {
-            Stage                    = header.Stage;
             GpPassthrough            = header.Stage == ShaderStage.Geometry && header.GpPassthrough;
             ThreadsPerInputPrimitive = header.ThreadsPerInputPrimitive;
             OutputTopology           = header.OutputTopology;
@@ -428,12 +429,13 @@ namespace Ryujinx.Graphics.Shader.Translation
 
         public void InheritFrom(ShaderConfig other)
         {
+            ResourceManager.InheritFrom(other.ResourceManager);
+
             ClipDistancesWritten |= other.ClipDistancesWritten;
             UsedFeatures |= other.UsedFeatures;
 
             UsedInputAttributes |= other.UsedInputAttributes;
             UsedOutputAttributes |= other.UsedOutputAttributes;
-            _usedConstantBuffers |= other._usedConstantBuffers;
             _usedStorageBuffers |= other._usedStorageBuffers;
             _usedStorageBuffersWrite |= other._usedStorageBuffersWrite;
 
@@ -641,11 +643,6 @@ namespace Ryujinx.Graphics.Shader.Translation
             AccessibleConstantBuffersMask = ubeMask;
         }
 
-        public void SetUsedConstantBuffer(int slot)
-        {
-            _usedConstantBuffers |= 1 << slot;
-        }
-
         public void SetUsedStorageBuffer(int slot, bool write)
         {
             int mask = 1 << slot;
@@ -762,27 +759,6 @@ namespace Ryujinx.Graphics.Shader.Translation
             return meta;
         }
 
-        public BufferDescriptor[] GetConstantBufferDescriptors()
-        {
-            if (_cachedConstantBufferDescriptors != null)
-            {
-                return _cachedConstantBufferDescriptors;
-            }
-
-            int usedMask = _usedConstantBuffers;
-
-            if (UsedFeatures.HasFlag(FeatureFlags.CbIndexing))
-            {
-                usedMask |= (int)GpuAccessor.QueryConstantBufferUse();
-            }
-
-            return _cachedConstantBufferDescriptors = GetUniformBufferDescriptors(
-                usedMask,
-                UsedFeatures.HasFlag(FeatureFlags.CbIndexing),
-                out _firstConstantBufferBinding,
-                GpuAccessor.QueryBindingConstantBuffer);
-        }
-
         public BufferDescriptor[] GetStorageBufferDescriptors()
         {
             if (_cachedStorageBufferDescriptors != null)
@@ -798,47 +774,6 @@ namespace Ryujinx.Graphics.Shader.Translation
                 GpuAccessor.QueryBindingStorageBuffer);
         }
 
-        private static BufferDescriptor[] GetUniformBufferDescriptors(int usedMask, bool isArray, out int firstBinding, Func<int, int> getBindingCallback)
-        {
-            firstBinding = 0;
-            int lastSlot = -1;
-            bool hasFirstBinding = false;
-            var descriptors = new BufferDescriptor[BitOperations.PopCount((uint)usedMask)];
-
-            for (int i = 0; i < descriptors.Length; i++)
-            {
-                int slot = BitOperations.TrailingZeroCount(usedMask);
-
-                if (isArray)
-                {
-                    // The next array entries also consumes bindings, even if they are unused.
-                    for (int j = lastSlot + 1; j < slot; j++)
-                    {
-                        int binding = getBindingCallback(j);
-
-                        if (!hasFirstBinding)
-                        {
-                            firstBinding = binding;
-                            hasFirstBinding = true;
-                        }
-                    }
-                }
-
-                lastSlot = slot;
-                descriptors[i] = new BufferDescriptor(getBindingCallback(slot), slot);
-
-                if (!hasFirstBinding)
-                {
-                    firstBinding = descriptors[i].Binding;
-                    hasFirstBinding = true;
-                }
-
-                usedMask &= ~(1 << slot);
-            }
-
-            return descriptors;
-        }
-
         private BufferDescriptor[] GetStorageBufferDescriptors(
             int usedMask,
             int writtenMask,
@@ -1009,7 +944,7 @@ namespace Ryujinx.Graphics.Shader.Translation
         public ShaderProgramInfo CreateProgramInfo(ShaderIdentification identification = ShaderIdentification.None)
         {
             return new ShaderProgramInfo(
-                GetConstantBufferDescriptors(),
+                ResourceManager.GetConstantBufferDescriptors(),
                 GetStorageBufferDescriptors(),
                 GetTextureDescriptors(),
                 GetImageDescriptors(),

src/Ryujinx.Graphics.Shader/Translation/Translator.cs

@@ -99,7 +99,7 @@ namespace Ryujinx.Graphics.Shader.Translation
 
             if (options.Flags.HasFlag(TranslationFlags.Compute))
             {
-                config = new ShaderConfig(gpuAccessor, options);
+                config = new ShaderConfig(ShaderStage.Compute, gpuAccessor, options);
 
                 program = Decoder.Decode(config, address);
             }

src/Ryujinx.Graphics.Vulkan/BufferManager.cs

@@ -1,4 +1,5 @@
-using Ryujinx.Graphics.GAL;
+using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
 using System;
 using System.Runtime.CompilerServices;
@@ -95,16 +96,27 @@ namespace Ryujinx.Graphics.Vulkan
             return Unsafe.As<ulong, BufferHandle>(ref handle64);
         }
 
-        public BufferHandle CreateWithHandle(VulkanRenderer gd, int size, BufferAllocationType baseType = BufferAllocationType.HostMapped, BufferHandle storageHint = default)
+        public BufferHandle CreateWithHandle(
+            VulkanRenderer gd,
+            int size,
+            BufferAllocationType baseType = BufferAllocationType.HostMapped,
+            BufferHandle storageHint = default)
         {
             return CreateWithHandle(gd, size, out _, baseType, storageHint);
         }
 
-        public BufferHandle CreateWithHandle(VulkanRenderer gd, int size, out BufferHolder holder, BufferAllocationType baseType = BufferAllocationType.HostMapped, BufferHandle storageHint = default)
+        public BufferHandle CreateWithHandle(
+            VulkanRenderer gd,
+            int size,
+            out BufferHolder holder,
+            BufferAllocationType baseType = BufferAllocationType.HostMapped,
+            BufferHandle storageHint = default)
         {
             holder = Create(gd, size, baseType: baseType, storageHint: storageHint);
             if (holder == null)
             {
+                Logger.Error?.Print(LogClass.Gpu, $"Failed to create buffer with size 0x{size:X} and type \"{baseType}\".");
+
                 return BufferHandle.Null;
             }
 

src/Ryujinx.Graphics.Vulkan/DescriptorSetUpdater.cs

@@ -372,8 +372,9 @@ namespace Ryujinx.Graphics.Vulkan
         private void UpdateAndBind(CommandBufferScoped cbs, int setIndex, PipelineBindPoint pbp)
         {
             var program = _program;
-            int stagesCount = program.Bindings[setIndex].Length;
-            if (stagesCount == 0 && setIndex != PipelineBase.UniformSetIndex)
+            var bindingSegments = program.BindingSegments[setIndex];
+
+            if (bindingSegments.Length == 0 && setIndex != PipelineBase.UniformSetIndex)
             {
                 return;
             }
@@ -410,125 +411,113 @@ namespace Ryujinx.Graphics.Vulkan
                 }
             }
 
-            for (int stageIndex = 0; stageIndex < stagesCount; stageIndex++)
+            foreach (ResourceBindingSegment segment in bindingSegments)
             {
-                var stageBindings = program.Bindings[setIndex][stageIndex];
-                int bindingsCount = stageBindings.Length;
-                int count;
+                int binding = segment.Binding;
+                int count = segment.Count;
 
-                for (int bindingIndex = 0; bindingIndex < bindingsCount; bindingIndex += count)
+                if (setIndex == PipelineBase.UniformSetIndex)
                 {
-                    int binding = stageBindings[bindingIndex];
-                    count = 1;
-
-                    while (bindingIndex + count < bindingsCount && stageBindings[bindingIndex + count] == binding + count)
+                    for (int i = 0; i < count; i++)
                     {
-                        count++;
+                        int index = binding + i;
+
+                        if (!_uniformSet[index])
+                        {
+                            UpdateBuffer(cbs, ref _uniformBuffers[index], _uniformBufferRefs[index], dummyBuffer);
+
+                            _uniformSet[index] = true;
+                        }
                     }
 
-                    if (setIndex == PipelineBase.UniformSetIndex)
+                    ReadOnlySpan<DescriptorBufferInfo> uniformBuffers = _uniformBuffers;
+                    dsc.UpdateBuffers(0, binding, uniformBuffers.Slice(binding, count), DescriptorType.UniformBuffer);
+                }
+                else if (setIndex == PipelineBase.StorageSetIndex)
+                {
+                    for (int i = 0; i < count; i++)
                     {
+                        int index = binding + i;
+
+                        if (!_storageSet[index])
+                        {
+                            UpdateBuffer(cbs, ref _storageBuffers[index], _storageBufferRefs[index], dummyBuffer);
+
+                            _storageSet[index] = true;
+                        }
+                    }
+
+                    ReadOnlySpan<DescriptorBufferInfo> storageBuffers = _storageBuffers;
+                    if (program.HasMinimalLayout)
+                    {
+                        dsc.UpdateBuffers(0, binding, storageBuffers.Slice(binding, count), DescriptorType.StorageBuffer);
+                    }
+                    else
+                    {
+                        dsc.UpdateStorageBuffers(0, binding, storageBuffers.Slice(binding, count));
+                    }
+                }
+                else if (setIndex == PipelineBase.TextureSetIndex)
+                {
+                    if (segment.Type != ResourceType.BufferTexture)
+                    {
+                        Span<DescriptorImageInfo> textures = _textures;
+
                         for (int i = 0; i < count; i++)
                         {
-                            int index = binding + i;
+                            ref var texture = ref textures[i];
 
-                            if (!_uniformSet[index])
+                            texture.ImageView = _textureRefs[binding + i]?.Get(cbs).Value ?? default;
+                            texture.Sampler = _samplerRefs[binding + i]?.Get(cbs).Value ?? default;
+
+                            if (texture.ImageView.Handle == 0)
                             {
-                                UpdateBuffer(cbs, ref _uniformBuffers[index], _uniformBufferRefs[index], dummyBuffer);
+                                texture.ImageView = _dummyTexture.GetImageView().Get(cbs).Value;
+                            }
 
-                                _uniformSet[index] = true;
+                            if (texture.Sampler.Handle == 0)
+                            {
+                                texture.Sampler = _dummySampler.GetSampler().Get(cbs).Value;
                             }
                         }
 
-                        ReadOnlySpan<DescriptorBufferInfo> uniformBuffers = _uniformBuffers;
-                        dsc.UpdateBuffers(0, binding, uniformBuffers.Slice(binding, count), DescriptorType.UniformBuffer);
+                        dsc.UpdateImages(0, binding, textures.Slice(0, count), DescriptorType.CombinedImageSampler);
                     }
-                    else if (setIndex == PipelineBase.StorageSetIndex)
+                    else
                     {
+                        Span<BufferView> bufferTextures = _bufferTextures;
+
                         for (int i = 0; i < count; i++)
                         {
-                            int index = binding + i;
-
-                            if (!_storageSet[index])
-                            {
-                                UpdateBuffer(cbs, ref _storageBuffers[index], _storageBufferRefs[index], dummyBuffer);
-
-                                _storageSet[index] = true;
-                            }
+                            bufferTextures[i] = _bufferTextureRefs[binding + i]?.GetBufferView(cbs) ?? default;
                         }
 
-                        ReadOnlySpan<DescriptorBufferInfo> storageBuffers = _storageBuffers;
-                        if (program.HasMinimalLayout)
-                        {
-                            dsc.UpdateBuffers(0, binding, storageBuffers.Slice(binding, count), DescriptorType.StorageBuffer);
-                        }
-                        else
-                        {
-                            dsc.UpdateStorageBuffers(0, binding, storageBuffers.Slice(binding, count));
-                        }
+                        dsc.UpdateBufferImages(0, binding, bufferTextures.Slice(0, count), DescriptorType.UniformTexelBuffer);
                     }
-                    else if (setIndex == PipelineBase.TextureSetIndex)
+                }
+                else if (setIndex == PipelineBase.ImageSetIndex)
+                {
+                    if (segment.Type != ResourceType.BufferImage)
                     {
-                        if (((uint)binding % (Constants.MaxTexturesPerStage * 2)) < Constants.MaxTexturesPerStage || program.HasMinimalLayout)
+                        Span<DescriptorImageInfo> images = _images;
+
+                        for (int i = 0; i < count; i++)
                         {
-                            Span<DescriptorImageInfo> textures = _textures;
-
-                            for (int i = 0; i < count; i++)
-                            {
-                                ref var texture = ref textures[i];
-
-                                texture.ImageView = _textureRefs[binding + i]?.Get(cbs).Value ?? default;
-                                texture.Sampler = _samplerRefs[binding + i]?.Get(cbs).Value ?? default;
-
-                                if (texture.ImageView.Handle == 0)
-                                {
-                                    texture.ImageView = _dummyTexture.GetImageView().Get(cbs).Value;
-                                }
-
-                                if (texture.Sampler.Handle == 0)
-                                {
-                                    texture.Sampler = _dummySampler.GetSampler().Get(cbs).Value;
-                                }
-                            }
-
-                            dsc.UpdateImages(0, binding, textures.Slice(0, count), DescriptorType.CombinedImageSampler);
+                            images[i].ImageView = _imageRefs[binding + i]?.Get(cbs).Value ?? default;
                         }
-                        else
-                        {
-                            Span<BufferView> bufferTextures = _bufferTextures;
 
-                            for (int i = 0; i < count; i++)
-                            {
-                                bufferTextures[i] = _bufferTextureRefs[binding + i]?.GetBufferView(cbs) ?? default;
-                            }
-
-                            dsc.UpdateBufferImages(0, binding, bufferTextures.Slice(0, count), DescriptorType.UniformTexelBuffer);
-                        }
+                        dsc.UpdateImages(0, binding, images.Slice(0, count), DescriptorType.StorageImage);
                     }
-                    else if (setIndex == PipelineBase.ImageSetIndex)
+                    else
                     {
-                        if (((uint)binding % (Constants.MaxImagesPerStage * 2)) < Constants.MaxImagesPerStage || program.HasMinimalLayout)
+                        Span<BufferView> bufferImages = _bufferImages;
+
+                        for (int i = 0; i < count; i++)
                         {
-                            Span<DescriptorImageInfo> images = _images;
-
-                            for (int i = 0; i < count; i++)
-                            {
-                                images[i].ImageView = _imageRefs[binding + i]?.Get(cbs).Value ?? default;
-                            }
-
-                            dsc.UpdateImages(0, binding, images.Slice(0, count), DescriptorType.StorageImage);
+                            bufferImages[i] = _bufferImageRefs[binding + i]?.GetBufferView(cbs, _bufferImageFormats[binding + i]) ?? default;
                         }
-                        else
-                        {
-                            Span<BufferView> bufferImages = _bufferImages;
 
-                            for (int i = 0; i < count; i++)
-                            {
-                                bufferImages[i] = _bufferImageRefs[binding + i]?.GetBufferView(cbs, _bufferImageFormats[binding + i]) ?? default;
-                            }
-
-                            dsc.UpdateBufferImages(0, binding, bufferImages.Slice(0, count), DescriptorType.StorageTexelBuffer);
-                        }
+                        dsc.UpdateBufferImages(0, binding, bufferImages.Slice(0, count), DescriptorType.StorageTexelBuffer);
                     }
                 }
             }
@@ -568,9 +557,6 @@ namespace Ryujinx.Graphics.Vulkan
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void UpdateAndBindUniformBufferPd(CommandBufferScoped cbs, PipelineBindPoint pbp)
         {
-            var dummyBuffer = _dummyBuffer?.GetBuffer();
-            int stagesCount = _program.Bindings[PipelineBase.UniformSetIndex].Length;
-
             if (!_uniformSet[0])
             {
                 Span<DescriptorBufferInfo> uniformBuffer = stackalloc DescriptorBufferInfo[1];
@@ -587,41 +573,32 @@ namespace Ryujinx.Graphics.Vulkan
                 UpdateBuffers(cbs, pbp, 0, uniformBuffer, DescriptorType.UniformBuffer);
             }
 
-            for (int stageIndex = 0; stageIndex < stagesCount; stageIndex++)
+            var bindingSegments = _program.BindingSegments[PipelineBase.UniformSetIndex];
+            var dummyBuffer = _dummyBuffer?.GetBuffer();
+
+            foreach (ResourceBindingSegment segment in bindingSegments)
             {
-                var stageBindings = _program.Bindings[PipelineBase.UniformSetIndex][stageIndex];
-                int bindingsCount = stageBindings.Length;
-                int count;
+                int binding = segment.Binding;
+                int count = segment.Count;
 
-                for (int bindingIndex = 0; bindingIndex < bindingsCount; bindingIndex += count)
+                bool doUpdate = false;
+
+                for (int i = 0; i < count; i++)
                 {
-                    int binding = stageBindings[bindingIndex];
-                    count = 1;
+                    int index = binding + i;
 
-                    while (bindingIndex + count < bindingsCount && stageBindings[bindingIndex + count] == binding + count)
+                    if (!_uniformSet[index])
                     {
-                        count++;
+                        UpdateBuffer(cbs, ref _uniformBuffers[index], _uniformBufferRefs[index], dummyBuffer);
+                        _uniformSet[index] = true;
+                        doUpdate = true;
                     }
+                }
 
-                    bool doUpdate = false;
-
-                    for (int i = 0; i < count; i++)
-                    {
-                        int index = binding + i;
-
-                        if (!_uniformSet[index])
-                        {
-                            UpdateBuffer(cbs, ref _uniformBuffers[index], _uniformBufferRefs[index], dummyBuffer);
-                            _uniformSet[index] = true;
-                            doUpdate = true;
-                        }
-                    }
-
-                    if (doUpdate)
-                    {
-                        ReadOnlySpan<DescriptorBufferInfo> uniformBuffers = _uniformBuffers;
-                        UpdateBuffers(cbs, pbp, binding, uniformBuffers.Slice(binding, count), DescriptorType.UniformBuffer);
-                    }
+                if (doUpdate)
+                {
+                    ReadOnlySpan<DescriptorBufferInfo> uniformBuffers = _uniformBuffers;
+                    UpdateBuffers(cbs, pbp, binding, uniformBuffers.Slice(binding, count), DescriptorType.UniformBuffer);
                 }
             }
         }

src/Ryujinx.Graphics.Vulkan/Effects/FsrScalingFilter.cs

@@ -54,29 +54,29 @@ namespace Ryujinx.Graphics.Vulkan.Effects
             var scalingShader = EmbeddedResources.Read("Ryujinx.Graphics.Vulkan/Effects/Shaders/FsrScaling.spv");
             var sharpeningShader = EmbeddedResources.Read("Ryujinx.Graphics.Vulkan/Effects/Shaders/FsrSharpening.spv");
 
-            var computeBindings = new ShaderBindings(
-                new[] { 2 },
-                Array.Empty<int>(),
-                new[] { 1 },
-                new[] { 0 });
+            var scalingResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 1)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0).Build();
 
-            var sharpeningBindings = new ShaderBindings(
-                new[] { 2, 3, 4 },
-                Array.Empty<int>(),
-                new[] { 1 },
-                new[] { 0 });
+            var sharpeningResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 3)
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 4)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 1)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0).Build();
 
             _sampler = _renderer.CreateSampler(GAL.SamplerCreateInfo.Create(MinFilter.Linear, MagFilter.Linear));
 
             _scalingProgram = _renderer.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(scalingShader, computeBindings, ShaderStage.Compute, TargetLanguage.Spirv)
-            });
+                new ShaderSource(scalingShader, ShaderStage.Compute, TargetLanguage.Spirv)
+            }, scalingResourceLayout);
 
             _sharpeningProgram = _renderer.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(sharpeningShader, sharpeningBindings, ShaderStage.Compute, TargetLanguage.Spirv)
-            });
+                new ShaderSource(sharpeningShader, ShaderStage.Compute, TargetLanguage.Spirv)
+            }, sharpeningResourceLayout);
         }
 
         public void Run(
@@ -160,10 +160,8 @@ namespace Ryujinx.Graphics.Vulkan.Effects
             _pipeline.ComputeBarrier();
 
             // Sharpening pass
-            _pipeline.SetCommandBuffer(cbs);
             _pipeline.SetProgram(_sharpeningProgram);
             _pipeline.SetTextureAndSampler(ShaderStage.Compute, 1, _intermediaryTexture, _sampler);
-            _pipeline.SetUniformBuffers(stackalloc[] { new BufferAssignment(2, bufferRanges) });
             var sharpeningRange = new BufferRange(sharpeningBufferHandle, 0, sizeof(float));
             _pipeline.SetUniformBuffers(stackalloc[] { new BufferAssignment(4, sharpeningRange) });
             _pipeline.SetImage(0, destinationTexture);

src/Ryujinx.Graphics.Vulkan/Effects/FxaaPostProcessingEffect.cs

@@ -38,18 +38,17 @@ namespace Ryujinx.Graphics.Vulkan.Effects
 
             var shader = EmbeddedResources.Read("Ryujinx.Graphics.Vulkan/Effects/Shaders/Fxaa.spv");
 
-            var computeBindings = new ShaderBindings(
-                new[] { 2 },
-                Array.Empty<int>(),
-                new[] { 1 },
-                new[] { 0 });
+            var resourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 1)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0).Build();
 
             _samplerLinear = _renderer.CreateSampler(GAL.SamplerCreateInfo.Create(MinFilter.Linear, MagFilter.Linear));
 
             _shaderProgram = _renderer.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(shader, computeBindings, ShaderStage.Compute, TargetLanguage.Spirv)
-            });
+                new ShaderSource(shader, ShaderStage.Compute, TargetLanguage.Spirv)
+            }, resourceLayout);
         }
 
         public TextureView Run(TextureView view, CommandBufferScoped cbs, int width, int height)

src/Ryujinx.Graphics.Vulkan/Effects/SmaaPostProcessingEffect.cs

@@ -77,23 +77,23 @@ namespace Ryujinx.Graphics.Vulkan.Effects
             var blendShader = EmbeddedResources.Read("Ryujinx.Graphics.Vulkan/Effects/Shaders/SmaaBlend.spv");
             var neighbourShader = EmbeddedResources.Read("Ryujinx.Graphics.Vulkan/Effects/Shaders/SmaaNeighbour.spv");
 
-            var edgeBindings = new ShaderBindings(
-                new[] { 2 },
-                Array.Empty<int>(),
-                new[] { 1 },
-                new[] { 0 });
+            var edgeResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 1)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0).Build();
 
-            var blendBindings = new ShaderBindings(
-                new[] { 2 },
-                Array.Empty<int>(),
-                new[] { 1, 3, 4 },
-                new[] { 0 });
+            var blendResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 1)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 3)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 4)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0).Build();
 
-            var neighbourBindings = new ShaderBindings(
-                new[] { 2 },
-                Array.Empty<int>(),
-                new[] { 1, 3 },
-                new[] { 0 });
+            var neighbourResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 1)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 3)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0).Build();
 
             _samplerLinear = _renderer.CreateSampler(GAL.SamplerCreateInfo.Create(MinFilter.Linear, MagFilter.Linear));
 
@@ -117,18 +117,18 @@ namespace Ryujinx.Graphics.Vulkan.Effects
 
             _edgeProgram = _renderer.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(edgeShader, edgeBindings, ShaderStage.Compute, TargetLanguage.Spirv)
-            }, new[] { specInfo });
+                new ShaderSource(edgeShader, ShaderStage.Compute, TargetLanguage.Spirv)
+            }, edgeResourceLayout, new[] { specInfo });
 
             _blendProgram = _renderer.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(blendShader, blendBindings, ShaderStage.Compute, TargetLanguage.Spirv)
-            }, new[] { specInfo });
+                new ShaderSource(blendShader, ShaderStage.Compute, TargetLanguage.Spirv)
+            }, blendResourceLayout, new[] { specInfo });
 
             _neighbourProgram = _renderer.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(neighbourShader, neighbourBindings, ShaderStage.Compute, TargetLanguage.Spirv)
-            }, new[] { specInfo });
+                new ShaderSource(neighbourShader, ShaderStage.Compute, TargetLanguage.Spirv)
+            }, neighbourResourceLayout, new[] { specInfo });
         }
 
         public void DeletePipelines()

src/Ryujinx.Graphics.Vulkan/EnumConversion.cs

@@ -36,6 +36,56 @@ namespace Ryujinx.Graphics.Vulkan
             };
         }
 
+        public static ShaderStageFlags Convert(this ResourceStages stages)
+        {
+            ShaderStageFlags stageFlags = stages.HasFlag(ResourceStages.Compute)
+                ? ShaderStageFlags.ComputeBit
+                : ShaderStageFlags.None;
+
+            if (stages.HasFlag(ResourceStages.Vertex))
+            {
+                stageFlags |= ShaderStageFlags.VertexBit;
+            }
+
+            if (stages.HasFlag(ResourceStages.TessellationControl))
+            {
+                stageFlags |= ShaderStageFlags.TessellationControlBit;
+            }
+
+            if (stages.HasFlag(ResourceStages.TessellationEvaluation))
+            {
+                stageFlags |= ShaderStageFlags.TessellationEvaluationBit;
+            }
+
+            if (stages.HasFlag(ResourceStages.Geometry))
+            {
+                stageFlags |= ShaderStageFlags.GeometryBit;
+            }
+
+            if (stages.HasFlag(ResourceStages.Fragment))
+            {
+                stageFlags |= ShaderStageFlags.FragmentBit;
+            }
+
+            return stageFlags;
+        }
+
+        public static DescriptorType Convert(this ResourceType type)
+        {
+            return type switch
+            {
+                ResourceType.UniformBuffer => DescriptorType.UniformBuffer,
+                ResourceType.StorageBuffer => DescriptorType.StorageBuffer,
+                ResourceType.Texture => DescriptorType.SampledImage,
+                ResourceType.Sampler => DescriptorType.Sampler,
+                ResourceType.TextureAndSampler => DescriptorType.CombinedImageSampler,
+                ResourceType.Image => DescriptorType.StorageImage,
+                ResourceType.BufferTexture => DescriptorType.UniformTexelBuffer,
+                ResourceType.BufferImage => DescriptorType.StorageTexelBuffer,
+                _ => throw new ArgumentException($"Invalid resource type \"{type}\".")
+            };
+        }
+
         public static SamplerAddressMode Convert(this AddressMode mode)
         {
             return mode switch
@@ -48,7 +98,7 @@ namespace Ryujinx.Graphics.Vulkan
                 AddressMode.ClampToBorder => SamplerAddressMode.ClampToBorder,
                 AddressMode.MirroredRepeat => SamplerAddressMode.MirroredRepeat,
                 AddressMode.ClampToEdge => SamplerAddressMode.ClampToEdge,
-                _ => LogInvalidAndReturn(mode, nameof(AddressMode), SamplerAddressMode.ClampToEdge)  // TODO: Should be clamp.
+                _ => LogInvalidAndReturn(mode, nameof(AddressMode), SamplerAddressMode.ClampToEdge) // TODO: Should be clamp.
             };
         }
 

src/Ryujinx.Graphics.Vulkan/HelperShader.cs

@@ -55,192 +55,168 @@ namespace Ryujinx.Graphics.Vulkan
             _samplerLinear = gd.CreateSampler(GAL.SamplerCreateInfo.Create(MinFilter.Linear, MagFilter.Linear));
             _samplerNearest = gd.CreateSampler(GAL.SamplerCreateInfo.Create(MinFilter.Nearest, MagFilter.Nearest));
 
-            var blitVertexBindings = new ShaderBindings(
-                new[] { 1 },
-                Array.Empty<int>(),
-                Array.Empty<int>(),
-                Array.Empty<int>());
-
-            var blitFragmentBindings = new ShaderBindings(
-                Array.Empty<int>(),
-                Array.Empty<int>(),
-                new[] { 0 },
-                Array.Empty<int>());
+            var blitResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Vertex, ResourceType.UniformBuffer, 1)
+                .Add(ResourceStages.Fragment, ResourceType.TextureAndSampler, 0).Build();
 
             _programColorBlit = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.ColorBlitFragmentShaderSource, blitFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.ColorBlitFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, blitResourceLayout);
 
             _programColorBlitMs = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.ColorBlitMsFragmentShaderSource, blitFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.ColorBlitMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, blitResourceLayout);
 
             _programColorBlitClearAlpha = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.ColorBlitClearAlphaFragmentShaderSource, blitFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.ColorBlitClearAlphaFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, blitResourceLayout);
 
-            var colorClearFragmentBindings = new ShaderBindings(
-                Array.Empty<int>(),
-                Array.Empty<int>(),
-                Array.Empty<int>(),
-                Array.Empty<int>());
+            var colorClearResourceLayout = new ResourceLayoutBuilder().Add(ResourceStages.Vertex, ResourceType.UniformBuffer, 1).Build();
 
             _programColorClearF = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorClearVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.ColorClearFFragmentShaderSource, colorClearFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorClearVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.ColorClearFFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, colorClearResourceLayout);
 
             _programColorClearSI = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorClearVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.ColorClearSIFragmentShaderSource, colorClearFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorClearVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.ColorClearSIFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, colorClearResourceLayout);
 
             _programColorClearUI = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorClearVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.ColorClearUIFragmentShaderSource, colorClearFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorClearVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.ColorClearUIFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, colorClearResourceLayout);
 
-            var strideChangeBindings = new ShaderBindings(
-                new[] { 0 },
-                new[] { 1, 2 },
-                Array.Empty<int>(),
-                Array.Empty<int>());
+            var strideChangeResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 0)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 1)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 2).Build();
 
             _programStrideChange = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ChangeBufferStrideShaderSource, strideChangeBindings, ShaderStage.Compute, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ChangeBufferStrideShaderSource, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, strideChangeResourceLayout);
 
-            var colorCopyBindings = new ShaderBindings(
-                new[] { 0 },
-                Array.Empty<int>(),
-                new[] { 0 },
-                new[] { 0 });
+            var colorCopyResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 0)
+                .Add(ResourceStages.Compute, ResourceType.TextureAndSampler, 0)
+                .Add(ResourceStages.Compute, ResourceType.Image, 0).Build();
 
             _programColorCopyShortening = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorCopyShorteningComputeShaderSource, colorCopyBindings, ShaderStage.Compute, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorCopyShorteningComputeShaderSource, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, colorCopyResourceLayout);
 
             _programColorCopyToNonMs = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorCopyToNonMsComputeShaderSource, colorCopyBindings, ShaderStage.Compute, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorCopyToNonMsComputeShaderSource, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, colorCopyResourceLayout);
 
             _programColorCopyWidening = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorCopyWideningComputeShaderSource, colorCopyBindings, ShaderStage.Compute, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorCopyWideningComputeShaderSource, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, colorCopyResourceLayout);
 
-            var colorDrawToMsVertexBindings = new ShaderBindings(
-                Array.Empty<int>(),
-                Array.Empty<int>(),
-                Array.Empty<int>(),
-                Array.Empty<int>());
-
-            var colorDrawToMsFragmentBindings = new ShaderBindings(
-                new[] { 0 },
-                Array.Empty<int>(),
-                new[] { 0 },
-                Array.Empty<int>());
+            var colorDrawToMsResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Fragment, ResourceType.UniformBuffer, 0)
+                .Add(ResourceStages.Fragment, ResourceType.TextureAndSampler, 0).Build();
 
             _programColorDrawToMs = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, colorDrawToMsVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.ColorDrawToMsFragmentShaderSource, colorDrawToMsFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.ColorDrawToMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, colorDrawToMsResourceLayout);
 
-            var convertD32S8ToD24S8Bindings = new ShaderBindings(
-                new[] { 0 },
-                new[] { 1, 2 },
-                Array.Empty<int>(),
-                Array.Empty<int>());
+            var convertD32S8ToD24S8ResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 0)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 1)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 2).Build();
 
             _programConvertD32S8ToD24S8 = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ConvertD32S8ToD24S8ShaderSource, convertD32S8ToD24S8Bindings, ShaderStage.Compute, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ConvertD32S8ToD24S8ShaderSource, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, convertD32S8ToD24S8ResourceLayout);
 
-            var convertIndexBufferBindings = new ShaderBindings(
-                new[] { 0 },
-                new[] { 1, 2 },
-                Array.Empty<int>(),
-                Array.Empty<int>());
+            var convertIndexBufferResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 0)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 1)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 2).Build();
 
             _programConvertIndexBuffer = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ConvertIndexBufferShaderSource, convertIndexBufferBindings, ShaderStage.Compute, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ConvertIndexBufferShaderSource, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, convertIndexBufferResourceLayout);
 
-            var convertIndirectDataBindings = new ShaderBindings(
-                new[] { 0 },
-                new[] { 1, 2, 3 },
-                Array.Empty<int>(),
-                Array.Empty<int>());
+            var convertIndirectDataResourceLayout = new ResourceLayoutBuilder()
+                .Add(ResourceStages.Compute, ResourceType.UniformBuffer, 0)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 1)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 2)
+                .Add(ResourceStages.Compute, ResourceType.StorageBuffer, 3).Build();
 
             _programConvertIndirectData = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ConvertIndirectDataShaderSource, convertIndirectDataBindings, ShaderStage.Compute, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ConvertIndirectDataShaderSource, ShaderStage.Compute, TargetLanguage.Spirv),
+            }, convertIndirectDataResourceLayout);
 
             _programDepthBlit = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.DepthBlitFragmentShaderSource, blitFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.DepthBlitFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, blitResourceLayout);
 
             _programDepthBlitMs = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.DepthBlitMsFragmentShaderSource, blitFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.DepthBlitMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, blitResourceLayout);
 
             _programDepthDrawToMs = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, colorDrawToMsVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.DepthDrawToMsFragmentShaderSource, colorDrawToMsFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.DepthDrawToMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, colorDrawToMsResourceLayout);
 
             _programDepthDrawToNonMs = gd.CreateProgramWithMinimalLayout(new[]
             {
-                new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, colorDrawToMsVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                new ShaderSource(ShaderBinaries.DepthDrawToNonMsFragmentShaderSource, colorDrawToMsFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-            });
+                new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                new ShaderSource(ShaderBinaries.DepthDrawToNonMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+            }, colorDrawToMsResourceLayout);
 
             if (gd.Capabilities.SupportsShaderStencilExport)
             {
                 _programStencilBlit = gd.CreateProgramWithMinimalLayout(new[]
                 {
-                    new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                    new ShaderSource(ShaderBinaries.StencilBlitFragmentShaderSource, blitFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-                });
+                    new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                    new ShaderSource(ShaderBinaries.StencilBlitFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+                }, blitResourceLayout);
 
                 _programStencilBlitMs = gd.CreateProgramWithMinimalLayout(new[]
                 {
-                    new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, blitVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                    new ShaderSource(ShaderBinaries.StencilBlitMsFragmentShaderSource, blitFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-                });
+                    new ShaderSource(ShaderBinaries.ColorBlitVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                    new ShaderSource(ShaderBinaries.StencilBlitMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+                }, blitResourceLayout);
 
                 _programStencilDrawToMs = gd.CreateProgramWithMinimalLayout(new[]
                 {
-                    new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, colorDrawToMsVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                    new ShaderSource(ShaderBinaries.StencilDrawToMsFragmentShaderSource, colorDrawToMsFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-                });
+                    new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                    new ShaderSource(ShaderBinaries.StencilDrawToMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+                }, colorDrawToMsResourceLayout);
 
                 _programStencilDrawToNonMs = gd.CreateProgramWithMinimalLayout(new[]
                 {
-                    new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, colorDrawToMsVertexBindings, ShaderStage.Vertex, TargetLanguage.Spirv),
-                    new ShaderSource(ShaderBinaries.StencilDrawToNonMsFragmentShaderSource, colorDrawToMsFragmentBindings, ShaderStage.Fragment, TargetLanguage.Spirv),
-                });
+                    new ShaderSource(ShaderBinaries.ColorDrawToMsVertexShaderSource, ShaderStage.Vertex, TargetLanguage.Spirv),
+                    new ShaderSource(ShaderBinaries.StencilDrawToNonMsFragmentShaderSource, ShaderStage.Fragment, TargetLanguage.Spirv),
+                }, colorDrawToMsResourceLayout);
             }
         }
 

src/Ryujinx.Graphics.Vulkan/PipelineLayoutCache.cs

@@ -1,52 +1,101 @@
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
-using System.Collections.Generic;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.ObjectModel;
 
 namespace Ryujinx.Graphics.Vulkan
 {
     class PipelineLayoutCache
     {
-        private readonly PipelineLayoutCacheEntry[] _plce;
-        private readonly List<PipelineLayoutCacheEntry> _plceMinimal;
+        private readonly struct PlceKey : IEquatable<PlceKey>
+        {
+            public readonly ReadOnlyCollection<ResourceDescriptorCollection> SetDescriptors;
+            public readonly bool UsePushDescriptors;
+
+            public PlceKey(ReadOnlyCollection<ResourceDescriptorCollection> setDescriptors, bool usePushDescriptors)
+            {
+                SetDescriptors = setDescriptors;
+                UsePushDescriptors = usePushDescriptors;
+            }
+
+            public override int GetHashCode()
+            {
+                HashCode hasher = new HashCode();
+
+                if (SetDescriptors != null)
+                {
+                    foreach (var setDescriptor in SetDescriptors)
+                    {
+                        hasher.Add(setDescriptor);
+                    }
+                }
+
+                hasher.Add(UsePushDescriptors);
+
+                return hasher.ToHashCode();
+            }
+
+            public override bool Equals(object obj)
+            {
+                return obj is PlceKey other && Equals(other);
+            }
+
+            public bool Equals(PlceKey other)
+            {
+                if ((SetDescriptors == null) != (other.SetDescriptors == null))
+                {
+                    return false;
+                }
+
+                if (SetDescriptors != null)
+                {
+                    if (SetDescriptors.Count != other.SetDescriptors.Count)
+                    {
+                        return false;
+                    }
+
+                    for (int index = 0; index < SetDescriptors.Count; index++)
+                    {
+                        if (!SetDescriptors[index].Equals(other.SetDescriptors[index]))
+                        {
+                            return false;
+                        }
+                    }
+                }
+
+                return UsePushDescriptors == other.UsePushDescriptors;
+            }
+        }
+
+        private readonly ConcurrentDictionary<PlceKey, PipelineLayoutCacheEntry> _plces;
 
         public PipelineLayoutCache()
         {
-            _plce = new PipelineLayoutCacheEntry[1 << Constants.MaxShaderStages];
-            _plceMinimal = new List<PipelineLayoutCacheEntry>();
+            _plces = new ConcurrentDictionary<PlceKey, PipelineLayoutCacheEntry>();
         }
 
-        public PipelineLayoutCacheEntry Create(VulkanRenderer gd, Device device, ShaderSource[] shaders)
+        public PipelineLayoutCacheEntry GetOrCreate(
+            VulkanRenderer gd,
+            Device device,
+            ReadOnlyCollection<ResourceDescriptorCollection> setDescriptors,
+            bool usePushDescriptors)
         {
-            var plce = new PipelineLayoutCacheEntry(gd, device, shaders);
-            _plceMinimal.Add(plce);
-            return plce;
-        }
+            var key = new PlceKey(setDescriptors, usePushDescriptors);
 
-        public PipelineLayoutCacheEntry GetOrCreate(VulkanRenderer gd, Device device, uint stages, bool usePd)
-        {
-            if (_plce[stages] == null)
-            {
-                _plce[stages] = new PipelineLayoutCacheEntry(gd, device, stages, usePd);
-            }
-
-            return _plce[stages];
+            return _plces.GetOrAdd(key, (newKey) => new PipelineLayoutCacheEntry(gd, device, setDescriptors, usePushDescriptors));
         }
 
         protected virtual unsafe void Dispose(bool disposing)
         {
             if (disposing)
             {
-                for (int i = 0; i < _plce.Length; i++)
-                {
-                    _plce[i]?.Dispose();
-                }
-
-                foreach (var plce in _plceMinimal)
+                foreach (var plce in _plces.Values)
                 {
                     plce.Dispose();
                 }
 
-                _plceMinimal.Clear();
+                _plces.Clear();
             }
         }
 

src/Ryujinx.Graphics.Vulkan/PipelineLayoutCacheEntry.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 
 namespace Ryujinx.Graphics.Vulkan
 {
@@ -16,7 +17,7 @@ namespace Ryujinx.Graphics.Vulkan
         private readonly int[] _dsCacheCursor;
         private int _dsLastCbIndex;
 
-        private PipelineLayoutCacheEntry(VulkanRenderer gd, Device device)
+        private PipelineLayoutCacheEntry(VulkanRenderer gd, Device device, int setsCount)
         {
             _gd = gd;
             _device = device;
@@ -25,27 +26,24 @@ namespace Ryujinx.Graphics.Vulkan
 
             for (int i = 0; i < CommandBufferPool.MaxCommandBuffers; i++)
             {
-                _dsCache[i] = new List<Auto<DescriptorSetCollection>>[PipelineBase.DescriptorSetLayouts];
+                _dsCache[i] = new List<Auto<DescriptorSetCollection>>[setsCount];
 
-                for (int j = 0; j < PipelineBase.DescriptorSetLayouts; j++)
+                for (int j = 0; j < _dsCache[i].Length; j++)
                 {
                     _dsCache[i][j] = new List<Auto<DescriptorSetCollection>>();
                 }
             }
 
-            _dsCacheCursor = new int[PipelineBase.DescriptorSetLayouts];
+            _dsCacheCursor = new int[setsCount];
         }
 
-        public PipelineLayoutCacheEntry(VulkanRenderer gd, Device device, uint stages, bool usePd) : this(gd, device)
+        public PipelineLayoutCacheEntry(
+            VulkanRenderer gd,
+            Device device,
+            ReadOnlyCollection<ResourceDescriptorCollection> setDescriptors,
+            bool usePushDescriptors) : this(gd, device, setDescriptors.Count)
         {
-            DescriptorSetLayouts = PipelineLayoutFactory.Create(gd, device, stages, usePd, out var pipelineLayout);
-            PipelineLayout = pipelineLayout;
-        }
-
-        public PipelineLayoutCacheEntry(VulkanRenderer gd, Device device, ShaderSource[] shaders) : this(gd, device)
-        {
-            DescriptorSetLayouts = PipelineLayoutFactory.CreateMinimal(gd, device, shaders, out var pipelineLayout);
-            PipelineLayout = pipelineLayout;
+            (DescriptorSetLayouts, PipelineLayout) = PipelineLayoutFactory.Create(gd, device, setDescriptors, usePushDescriptors);
         }
 
         public Auto<DescriptorSetCollection> GetNewDescriptorSetCollection(
@@ -58,7 +56,7 @@ namespace Ryujinx.Graphics.Vulkan
             {
                 _dsLastCbIndex = commandBufferIndex;
 
-                for (int i = 0; i < PipelineBase.DescriptorSetLayouts; i++)
+                for (int i = 0; i < _dsCacheCursor.Length; i++)
                 {
                     _dsCacheCursor[i] = 0;
                 }

src/Ryujinx.Graphics.Vulkan/PipelineLayoutFactory.cs

@@ -1,257 +1,74 @@
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
-using System.Collections.Generic;
-using System.Numerics;
+using System.Collections.ObjectModel;
 
 namespace Ryujinx.Graphics.Vulkan
 {
     static class PipelineLayoutFactory
     {
-        private const ShaderStageFlags SupportBufferStages =
-            ShaderStageFlags.VertexBit |
-            ShaderStageFlags.FragmentBit |
-            ShaderStageFlags.ComputeBit;
-
-        private static ShaderStageFlags ActiveStages(uint stages)
+        public static unsafe (DescriptorSetLayout[], PipelineLayout) Create(
+            VulkanRenderer gd,
+            Device device,
+            ReadOnlyCollection<ResourceDescriptorCollection> setDescriptors,
+            bool usePushDescriptors)
         {
-            ShaderStageFlags stageFlags = 0;
+            DescriptorSetLayout[] layouts = new DescriptorSetLayout[setDescriptors.Count];
 
-            while (stages != 0)
+            bool isMoltenVk = gd.IsMoltenVk;
+
+            for (int setIndex = 0; setIndex < setDescriptors.Count; setIndex++)
             {
-                int stage = BitOperations.TrailingZeroCount(stages);
-                stages &= ~(1u << stage);
+                ResourceDescriptorCollection rdc = setDescriptors[setIndex];
 
-                stageFlags |= stage switch
+                ResourceStages activeStages = ResourceStages.None;
+
+                if (isMoltenVk)
                 {
-                    1 => ShaderStageFlags.FragmentBit,
-                    2 => ShaderStageFlags.GeometryBit,
-                    3 => ShaderStageFlags.TessellationControlBit,
-                    4 => ShaderStageFlags.TessellationEvaluationBit,
-                    _ => ShaderStageFlags.VertexBit | ShaderStageFlags.ComputeBit
-                };
-            }
-
-            return stageFlags;
-        }
-
-        public static unsafe DescriptorSetLayout[] Create(VulkanRenderer gd, Device device, uint stages, bool usePd, out PipelineLayout layout)
-        {
-            int stagesCount = BitOperations.PopCount(stages);
-
-            int uCount = Constants.MaxUniformBuffersPerStage * stagesCount + 1;
-            int tCount = Constants.MaxTexturesPerStage * 2 * stagesCount;
-            int iCount = Constants.MaxImagesPerStage * 2 * stagesCount;
-
-            DescriptorSetLayoutBinding* uLayoutBindings = stackalloc DescriptorSetLayoutBinding[uCount];
-            DescriptorSetLayoutBinding* sLayoutBindings = stackalloc DescriptorSetLayoutBinding[stagesCount];
-            DescriptorSetLayoutBinding* tLayoutBindings = stackalloc DescriptorSetLayoutBinding[tCount];
-            DescriptorSetLayoutBinding* iLayoutBindings = stackalloc DescriptorSetLayoutBinding[iCount];
-
-            uLayoutBindings[0] = new DescriptorSetLayoutBinding
-            {
-                Binding = 0,
-                DescriptorType = DescriptorType.UniformBuffer,
-                DescriptorCount = 1,
-                StageFlags = SupportBufferStages
-            };
-
-            int iter = 0;
-            var activeStages = ActiveStages(stages);
-
-            while (stages != 0)
-            {
-                int stage = BitOperations.TrailingZeroCount(stages);
-                stages &= ~(1u << stage);
-
-                var stageFlags = stage switch
-                {
-                    1 => ShaderStageFlags.FragmentBit,
-                    2 => ShaderStageFlags.GeometryBit,
-                    3 => ShaderStageFlags.TessellationControlBit,
-                    4 => ShaderStageFlags.TessellationEvaluationBit,
-                    _ => ShaderStageFlags.VertexBit | ShaderStageFlags.ComputeBit
-                };
-
-                void Set(DescriptorSetLayoutBinding* bindings, int maxPerStage, DescriptorType type, int start, int skip)
-                {
-                    int totalPerStage = maxPerStage * skip;
-
-                    for (int i = 0; i < maxPerStage; i++)
+                    for (int descIndex = 0; descIndex < rdc.Descriptors.Count; descIndex++)
                     {
-                        bindings[start + iter * totalPerStage + i] = new DescriptorSetLayoutBinding
-                        {
-                            Binding = (uint)(start + stage * totalPerStage + i),
-                            DescriptorType = type,
-                            DescriptorCount = 1,
-                            StageFlags = stageFlags
-                        };
+                        activeStages |= rdc.Descriptors[descIndex].Stages;
                     }
                 }
 
-                void SetStorage(DescriptorSetLayoutBinding* bindings, int maxPerStage, int start = 0)
-                {
-                    // There's a bug on MoltenVK where using the same buffer across different stages
-                    // causes invalid resource errors, allow the binding on all active stages as workaround.
-                    var flags = gd.IsMoltenVk ? activeStages : stageFlags;
+                DescriptorSetLayoutBinding[] layoutBindings = new DescriptorSetLayoutBinding[rdc.Descriptors.Count];
 
-                    bindings[start + iter] = new DescriptorSetLayoutBinding
+                for (int descIndex = 0; descIndex < rdc.Descriptors.Count; descIndex++)
+                {
+                    ResourceDescriptor descriptor = rdc.Descriptors[descIndex];
+
+                    ResourceStages stages = descriptor.Stages;
+
+                    if (descriptor.Type == ResourceType.StorageBuffer && isMoltenVk)
                     {
-                        Binding = (uint)(start + stage * maxPerStage),
-                        DescriptorType = DescriptorType.StorageBuffer,
-                        DescriptorCount = (uint)maxPerStage,
-                        StageFlags = flags
+                        // There's a bug on MoltenVK where using the same buffer across different stages
+                        // causes invalid resource errors, allow the binding on all active stages as workaround.
+                        stages = activeStages;
+                    }
+
+                    layoutBindings[descIndex] = new DescriptorSetLayoutBinding()
+                    {
+                        Binding = (uint)descriptor.Binding,
+                        DescriptorType = descriptor.Type.Convert(),
+                        DescriptorCount = (uint)descriptor.Count,
+                        StageFlags = stages.Convert()
                     };
                 }
 
-                Set(uLayoutBindings, Constants.MaxUniformBuffersPerStage, DescriptorType.UniformBuffer, 1, 1);
-                SetStorage(sLayoutBindings, Constants.MaxStorageBuffersPerStage);
-                Set(tLayoutBindings, Constants.MaxTexturesPerStage, DescriptorType.CombinedImageSampler, 0, 2);
-                Set(tLayoutBindings, Constants.MaxTexturesPerStage, DescriptorType.UniformTexelBuffer, Constants.MaxTexturesPerStage, 2);
-                Set(iLayoutBindings, Constants.MaxImagesPerStage, DescriptorType.StorageImage, 0, 2);
-                Set(iLayoutBindings, Constants.MaxImagesPerStage, DescriptorType.StorageTexelBuffer, Constants.MaxImagesPerStage, 2);
-
-                iter++;
-            }
-
-            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineBase.DescriptorSetLayouts];
-
-            var uDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = uLayoutBindings,
-                BindingCount = (uint)uCount,
-                Flags = usePd ? DescriptorSetLayoutCreateFlags.PushDescriptorBitKhr : 0
-            };
-
-            var sDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = sLayoutBindings,
-                BindingCount = (uint)stagesCount
-            };
-
-            var tDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = tLayoutBindings,
-                BindingCount = (uint)tCount
-            };
-
-            var iDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = iLayoutBindings,
-                BindingCount = (uint)iCount
-            };
-
-            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.UniformSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.StorageSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.TextureSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.ImageSetIndex]).ThrowOnError();
-
-            fixed (DescriptorSetLayout* pLayouts = layouts)
-            {
-                var pipelineLayoutCreateInfo = new PipelineLayoutCreateInfo()
+                fixed (DescriptorSetLayoutBinding* pLayoutBindings = layoutBindings)
                 {
-                    SType = StructureType.PipelineLayoutCreateInfo,
-                    PSetLayouts = pLayouts,
-                    SetLayoutCount = PipelineBase.DescriptorSetLayouts
-                };
-
-                gd.Api.CreatePipelineLayout(device, &pipelineLayoutCreateInfo, null, out layout).ThrowOnError();
-            }
-
-            return layouts;
-        }
-
-        public static unsafe DescriptorSetLayout[] CreateMinimal(VulkanRenderer gd, Device device, ShaderSource[] shaders, out PipelineLayout layout)
-        {
-            int stagesCount = shaders.Length;
-
-            int uCount = 0;
-            int sCount = 0;
-            int tCount = 0;
-            int iCount = 0;
-
-            foreach (var shader in shaders)
-            {
-                uCount += shader.Bindings.UniformBufferBindings.Count;
-                sCount += shader.Bindings.StorageBufferBindings.Count;
-                tCount += shader.Bindings.TextureBindings.Count;
-                iCount += shader.Bindings.ImageBindings.Count;
-            }
-
-            DescriptorSetLayoutBinding* uLayoutBindings = stackalloc DescriptorSetLayoutBinding[uCount];
-            DescriptorSetLayoutBinding* sLayoutBindings = stackalloc DescriptorSetLayoutBinding[sCount];
-            DescriptorSetLayoutBinding* tLayoutBindings = stackalloc DescriptorSetLayoutBinding[tCount];
-            DescriptorSetLayoutBinding* iLayoutBindings = stackalloc DescriptorSetLayoutBinding[iCount];
-
-            int uIndex = 0;
-            int sIndex = 0;
-            int tIndex = 0;
-            int iIndex = 0;
-
-            foreach (var shader in shaders)
-            {
-                var stageFlags = shader.Stage.Convert();
-
-                void Set(DescriptorSetLayoutBinding* bindings, DescriptorType type, ref int start, IEnumerable<int> bds)
-                {
-                    foreach (var b in bds)
+                    var descriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
                     {
-                        bindings[start++] = new DescriptorSetLayoutBinding
-                        {
-                            Binding = (uint)b,
-                            DescriptorType = type,
-                            DescriptorCount = 1,
-                            StageFlags = stageFlags
-                        };
-                    }
-                }
+                        SType = StructureType.DescriptorSetLayoutCreateInfo,
+                        PBindings = pLayoutBindings,
+                        BindingCount = (uint)layoutBindings.Length,
+                        Flags = usePushDescriptors && setIndex == 0 ? DescriptorSetLayoutCreateFlags.PushDescriptorBitKhr : DescriptorSetLayoutCreateFlags.None
+                    };
 
-                // TODO: Support buffer textures and images here.
-                // This is only used for the helper shaders on the backend, and we don't use buffer textures on them
-                // so far, so it's not really necessary right now.
-                Set(uLayoutBindings, DescriptorType.UniformBuffer, ref uIndex, shader.Bindings.UniformBufferBindings);
-                Set(sLayoutBindings, DescriptorType.StorageBuffer, ref sIndex, shader.Bindings.StorageBufferBindings);
-                Set(tLayoutBindings, DescriptorType.CombinedImageSampler, ref tIndex, shader.Bindings.TextureBindings);
-                Set(iLayoutBindings, DescriptorType.StorageImage, ref iIndex, shader.Bindings.ImageBindings);
+                    gd.Api.CreateDescriptorSetLayout(device, descriptorSetLayoutCreateInfo, null, out layouts[setIndex]).ThrowOnError();
+                }
             }
 
-            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineBase.DescriptorSetLayouts];
-
-            var uDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = uLayoutBindings,
-                BindingCount = (uint)uCount
-            };
-
-            var sDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = sLayoutBindings,
-                BindingCount = (uint)sCount
-            };
-
-            var tDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = tLayoutBindings,
-                BindingCount = (uint)tCount
-            };
-
-            var iDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = iLayoutBindings,
-                BindingCount = (uint)iCount
-            };
-
-            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.UniformSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.StorageSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.TextureSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.ImageSetIndex]).ThrowOnError();
+            PipelineLayout layout;
 
             fixed (DescriptorSetLayout* pLayouts = layouts)
             {
@@ -259,13 +76,13 @@ namespace Ryujinx.Graphics.Vulkan
                 {
                     SType = StructureType.PipelineLayoutCreateInfo,
                     PSetLayouts = pLayouts,
-                    SetLayoutCount = PipelineBase.DescriptorSetLayouts
+                    SetLayoutCount = (uint)layouts.Length
                 };
 
                 gd.Api.CreatePipelineLayout(device, &pipelineLayoutCreateInfo, null, out layout).ThrowOnError();
             }
 
-            return layouts;
+            return (layouts, layout);
         }
     }
 }

src/Ryujinx.Graphics.Vulkan/ResourceBindingSegment.cs

@@ -0,0 +1,22 @@
+using Ryujinx.Graphics.GAL;
+
+namespace Ryujinx.Graphics.Vulkan
+{
+    readonly struct ResourceBindingSegment
+    {
+        public readonly int Binding;
+        public readonly int Count;
+        public readonly ResourceType Type;
+        public readonly ResourceStages Stages;
+        public readonly ResourceAccess Access;
+
+        public ResourceBindingSegment(int binding, int count, ResourceType type, ResourceStages stages, ResourceAccess access)
+        {
+            Binding = binding;
+            Count = count;
+            Type = type;
+            Stages = stages;
+            Access = access;
+        }
+    }
+}

src/Ryujinx.Graphics.Vulkan/ResourceLayoutBuilder.cs

@@ -0,0 +1,67 @@
+using Ryujinx.Graphics.GAL;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.Vulkan
+{
+    class ResourceLayoutBuilder
+    {
+        private const int TotalSets = PipelineBase.DescriptorSetLayouts;
+
+        private readonly List<ResourceDescriptor>[] _resourceDescriptors;
+        private readonly List<ResourceUsage>[] _resourceUsages;
+
+        public ResourceLayoutBuilder()
+        {
+            _resourceDescriptors = new List<ResourceDescriptor>[TotalSets];
+            _resourceUsages = new List<ResourceUsage>[TotalSets];
+
+            for (int index = 0; index < TotalSets; index++)
+            {
+                _resourceDescriptors[index] = new();
+                _resourceUsages[index] = new();
+            }
+        }
+
+        public ResourceLayoutBuilder Add(ResourceStages stages, ResourceType type, int binding)
+        {
+            int setIndex = type switch
+            {
+                ResourceType.UniformBuffer => PipelineBase.UniformSetIndex,
+                ResourceType.StorageBuffer => PipelineBase.StorageSetIndex,
+                ResourceType.TextureAndSampler or ResourceType.BufferTexture => PipelineBase.TextureSetIndex,
+                ResourceType.Image or ResourceType.BufferImage => PipelineBase.ImageSetIndex,
+                _ => throw new ArgumentException($"Invalid resource type \"{type}\".")
+            };
+
+            ResourceAccess access = IsReadOnlyType(type) ? ResourceAccess.Read : ResourceAccess.ReadWrite;
+
+            _resourceDescriptors[setIndex].Add(new ResourceDescriptor(binding, 1, type, stages));
+            _resourceUsages[setIndex].Add(new ResourceUsage(binding, type, stages, access));
+
+            return this;
+        }
+
+        private static bool IsReadOnlyType(ResourceType type)
+        {
+            return type == ResourceType.UniformBuffer ||
+                   type == ResourceType.Sampler ||
+                   type == ResourceType.TextureAndSampler ||
+                   type == ResourceType.BufferTexture;
+        }
+
+        public ResourceLayout Build()
+        {
+            var descriptors = new ResourceDescriptorCollection[TotalSets];
+            var usages = new ResourceUsageCollection[TotalSets];
+
+            for (int index = 0; index < TotalSets; index++)
+            {
+                descriptors[index] = new ResourceDescriptorCollection(_resourceDescriptors[index].ToArray().AsReadOnly());
+                usages[index] = new ResourceUsageCollection(_resourceUsages[index].ToArray().AsReadOnly());
+            }
+
+            return new ResourceLayout(descriptors.AsReadOnly(), usages.AsReadOnly());
+        }
+    }
+}

src/Ryujinx.Graphics.Vulkan/Shader.cs

@@ -26,8 +26,6 @@ namespace Ryujinx.Graphics.Vulkan
 
         public ShaderStageFlags StageFlags => _stage;
 
-        public ShaderBindings Bindings { get; }
-
         public ProgramLinkStatus CompileStatus { private set; get; }
 
         public readonly Task CompileTask;
@@ -36,7 +34,6 @@ namespace Ryujinx.Graphics.Vulkan
         {
             _api = api;
             _device = device;
-            Bindings = shaderSource.Bindings;
 
             CompileStatus = ProgramLinkStatus.Incomplete;
 

src/Ryujinx.Graphics.Vulkan/ShaderCollection.cs

@@ -3,6 +3,7 @@ using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -23,7 +24,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         public uint Stages { get; }
 
-        public int[][][] Bindings { get; }
+        public ResourceBindingSegment[][] BindingSegments { get; }
 
         public ProgramLinkStatus LinkStatus { get; private set; }
 
@@ -54,7 +55,13 @@ namespace Ryujinx.Graphics.Vulkan
         private Task _compileTask;
         private bool _firstBackgroundUse;
 
-        public ShaderCollection(VulkanRenderer gd, Device device, ShaderSource[] shaders, SpecDescription[] specDescription = null, bool isMinimal = false)
+        public ShaderCollection(
+            VulkanRenderer gd,
+            Device device,
+            ShaderSource[] shaders,
+            ResourceLayout resourceLayout,
+            SpecDescription[] specDescription = null,
+            bool isMinimal = false)
         {
             _gd = gd;
             _device = device;
@@ -99,39 +106,16 @@ namespace Ryujinx.Graphics.Vulkan
 
             _shaders = internalShaders;
 
-            bool usePd = !isMinimal && VulkanConfiguration.UsePushDescriptors && _gd.Capabilities.SupportsPushDescriptors;
+            bool usePushDescriptors = !isMinimal && VulkanConfiguration.UsePushDescriptors && _gd.Capabilities.SupportsPushDescriptors;
 
-            _plce = isMinimal
-                ? gd.PipelineLayoutCache.Create(gd, device, shaders)
-                : gd.PipelineLayoutCache.GetOrCreate(gd, device, stages, usePd);
+            _plce = gd.PipelineLayoutCache.GetOrCreate(gd, device, resourceLayout.Sets, usePushDescriptors);
 
             HasMinimalLayout = isMinimal;
-            UsePushDescriptors = usePd;
+            UsePushDescriptors = usePushDescriptors;
 
             Stages = stages;
 
-            int[][] GrabAll(Func<ShaderBindings, IReadOnlyCollection<int>> selector)
-            {
-                bool hasAny = false;
-                int[][] bindings = new int[internalShaders.Length][];
-
-                for (int i = 0; i < internalShaders.Length; i++)
-                {
-                    var collection = selector(internalShaders[i].Bindings);
-                    hasAny |= collection.Count != 0;
-                    bindings[i] = collection.ToArray();
-                }
-
-                return hasAny ? bindings : Array.Empty<int[]>();
-            }
-
-            Bindings = new[]
-            {
-                GrabAll(x => x.UniformBufferBindings),
-                GrabAll(x => x.StorageBufferBindings),
-                GrabAll(x => x.TextureBindings),
-                GrabAll(x => x.ImageBindings)
-            };
+            BindingSegments = BuildBindingSegments(resourceLayout.SetUsages);
 
             _compileTask = Task.CompletedTask;
             _firstBackgroundUse = false;
@@ -141,8 +125,9 @@ namespace Ryujinx.Graphics.Vulkan
             VulkanRenderer gd,
             Device device,
             ShaderSource[] sources,
+            ResourceLayout resourceLayout,
             ProgramPipelineState state,
-            bool fromCache) : this(gd, device, sources)
+            bool fromCache) : this(gd, device, sources, resourceLayout)
         {
             _state = state;
 
@@ -150,6 +135,67 @@ namespace Ryujinx.Graphics.Vulkan
             _firstBackgroundUse = !fromCache;
         }
 
+        private static ResourceBindingSegment[][] BuildBindingSegments(ReadOnlyCollection<ResourceUsageCollection> setUsages)
+        {
+            ResourceBindingSegment[][] segments = new ResourceBindingSegment[setUsages.Count][];
+
+            for (int setIndex = 0; setIndex < setUsages.Count; setIndex++)
+            {
+                List<ResourceBindingSegment> currentSegments = new List<ResourceBindingSegment>();
+
+                ResourceUsage currentUsage = default;
+                int currentCount = 0;
+
+                for (int index = 0; index < setUsages[setIndex].Usages.Count; index++)
+                {
+                    ResourceUsage usage = setUsages[setIndex].Usages[index];
+
+                    // If the resource is not accessed, we don't need to update it.
+                    if (usage.Access == ResourceAccess.None)
+                    {
+                        continue;
+                    }
+
+                    if (currentUsage.Binding + currentCount != usage.Binding ||
+                        currentUsage.Type != usage.Type ||
+                        currentUsage.Stages != usage.Stages ||
+                        currentUsage.Access != usage.Access)
+                    {
+                        if (currentCount != 0)
+                        {
+                            currentSegments.Add(new ResourceBindingSegment(
+                                currentUsage.Binding,
+                                currentCount,
+                                currentUsage.Type,
+                                currentUsage.Stages,
+                                currentUsage.Access));
+                        }
+
+                        currentUsage = usage;
+                        currentCount = 1;
+                    }
+                    else
+                    {
+                        currentCount++;
+                    }
+                }
+
+                if (currentCount != 0)
+                {
+                    currentSegments.Add(new ResourceBindingSegment(
+                        currentUsage.Binding,
+                        currentCount,
+                        currentUsage.Type,
+                        currentUsage.Stages,
+                        currentUsage.Access));
+                }
+
+                segments[setIndex] = currentSegments.ToArray();
+            }
+
+            return segments;
+        }
+
         private async Task BackgroundCompilation()
         {
             await Task.WhenAll(_shaders.Select(shader => shader.CompileTask));

src/Ryujinx.Graphics.Vulkan/VulkanRenderer.cs

@@ -10,7 +10,6 @@ using Silk.NET.Vulkan.Extensions.EXT;
 using Silk.NET.Vulkan.Extensions.KHR;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.Graphics.Vulkan
@@ -398,17 +397,17 @@ namespace Ryujinx.Graphics.Vulkan
 
             if (info.State.HasValue || isCompute)
             {
-                return new ShaderCollection(this, _device, sources, info.State ?? default, info.FromCache);
+                return new ShaderCollection(this, _device, sources, info.ResourceLayout, info.State ?? default, info.FromCache);
             }
             else
             {
-                return new ShaderCollection(this, _device, sources);
+                return new ShaderCollection(this, _device, sources, info.ResourceLayout);
             }
         }
 
-        internal ShaderCollection CreateProgramWithMinimalLayout(ShaderSource[] sources, SpecDescription[] specDescription = null)
+        internal ShaderCollection CreateProgramWithMinimalLayout(ShaderSource[] sources, ResourceLayout resourceLayout, SpecDescription[] specDescription = null)
         {
-            return new ShaderCollection(this, _device, sources, specDescription: specDescription, isMinimal: true);
+            return new ShaderCollection(this, _device, sources, resourceLayout, specDescription, isMinimal: true);
         }
 
         public ISampler CreateSampler(GAL.SamplerCreateInfo info)
@@ -600,6 +599,25 @@ namespace Ryujinx.Graphics.Vulkan
             return new HardwareInfo(GpuVendor, GpuRenderer);
         }
 
+        /// <summary>
+        /// Gets the available Vulkan devices using the default Vulkan API
+        /// object returned by <see cref="Vk.GetApi()"/>
+        /// </summary>
+        /// <returns></returns>
+        public static DeviceInfo[] GetPhysicalDevices()
+        {
+            try
+            {
+                return VulkanInitialization.GetSuitablePhysicalDevices(Vk.GetApi());
+            }
+            catch (Exception ex)
+            {
+                Logger.Error?.PrintMsg(LogClass.Gpu, $"Error querying Vulkan devices: {ex.Message}");
+
+                return Array.Empty<DeviceInfo>();
+            }
+        }
+
         public static DeviceInfo[] GetPhysicalDevices(Vk api)
         {
             try
@@ -658,7 +676,7 @@ namespace Ryujinx.Graphics.Vulkan
             Logger.Notice.Print(LogClass.Gpu, $"{GpuVendor} {GpuRenderer} ({GpuVersion})");
         }
 
-        public GAL.PrimitiveTopology TopologyRemap(GAL.PrimitiveTopology topology)
+        internal GAL.PrimitiveTopology TopologyRemap(GAL.PrimitiveTopology topology)
         {
             return topology switch
             {
@@ -669,7 +687,7 @@ namespace Ryujinx.Graphics.Vulkan
             };
         }
 
-        public bool TopologyUnsupported(GAL.PrimitiveTopology topology)
+        internal bool TopologyUnsupported(GAL.PrimitiveTopology topology)
         {
             return topology switch
             {

src/Ryujinx.HLE/HOS/Services/ServerBase.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common;
+using Ryujinx.Common.Logging;
 using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS.Ipc;
 using Ryujinx.HLE.HOS.Kernel;
@@ -32,13 +33,14 @@ namespace Ryujinx.HLE.HOS.Services
             0x01007FFF
         };
 
-        private readonly object _handleLock = new();
+        // The amount of time Dispose() will wait to Join() the thread executing the ServerLoop()
+        private static readonly TimeSpan ThreadJoinTimeout = TimeSpan.FromSeconds(3);
 
         private readonly KernelContext _context;
         private KProcess _selfProcess;
+        private KThread _selfThread;
 
-        private readonly List<int> _sessionHandles = new List<int>();
-        private readonly List<int> _portHandles = new List<int>();
+        private readonly ReaderWriterLockSlim _handleLock = new ReaderWriterLockSlim();
         private readonly Dictionary<int, IpcService> _sessions = new Dictionary<int, IpcService>();
         private readonly Dictionary<int, Func<IpcService>> _ports = new Dictionary<int, Func<IpcService>>();
 
@@ -48,6 +50,8 @@ namespace Ryujinx.HLE.HOS.Services
         private readonly MemoryStream _responseDataStream;
         private readonly BinaryWriter _responseDataWriter;
 
+        private int _isDisposed = 0;
+
         public ManualResetEvent InitDone { get; }
         public string Name { get; }
         public Func<IpcService> SmObjectFactory { get; }
@@ -79,11 +83,20 @@ namespace Ryujinx.HLE.HOS.Services
 
         private void AddPort(int serverPortHandle, Func<IpcService> objectFactory)
         {
-            lock (_handleLock)
+            bool lockTaken = false;
+            try
             {
-                _portHandles.Add(serverPortHandle);
+                lockTaken = _handleLock.TryEnterWriteLock(Timeout.Infinite);
+
+                _ports.Add(serverPortHandle, objectFactory);
+            }
+            finally
+            {
+                if (lockTaken)
+                {
+                    _handleLock.ExitWriteLock();
+                }
             }
-            _ports.Add(serverPortHandle, objectFactory);
         }
 
         public void AddSessionObj(KServerSession serverSession, IpcService obj)
@@ -92,16 +105,62 @@ namespace Ryujinx.HLE.HOS.Services
             InitDone.WaitOne();
 
             _selfProcess.HandleTable.GenerateHandle(serverSession, out int serverSessionHandle);
+
             AddSessionObj(serverSessionHandle, obj);
         }
 
         public void AddSessionObj(int serverSessionHandle, IpcService obj)
         {
-            lock (_handleLock)
+            bool lockTaken = false;
+            try
             {
-                _sessionHandles.Add(serverSessionHandle);
+                lockTaken = _handleLock.TryEnterWriteLock(Timeout.Infinite);
+
+                _sessions.Add(serverSessionHandle, obj);
+            }
+            finally
+            {
+                if (lockTaken)
+                {
+                    _handleLock.ExitWriteLock();
+                }
+            }
+        }
+
+        private IpcService GetSessionObj(int serverSessionHandle)
+        {
+            bool lockTaken = false;
+            try
+            {
+                lockTaken = _handleLock.TryEnterReadLock(Timeout.Infinite);
+
+                return _sessions[serverSessionHandle];
+            }
+            finally
+            {
+                if (lockTaken)
+                {
+                    _handleLock.ExitReadLock();
+                }
+            }
+        }
+
+        private bool RemoveSessionObj(int serverSessionHandle, out IpcService obj)
+        {
+            bool lockTaken = false;
+            try
+            {
+                lockTaken = _handleLock.TryEnterWriteLock(Timeout.Infinite);
+
+                return _sessions.Remove(serverSessionHandle, out obj);
+            }
+            finally
+            {
+                if (lockTaken)
+                {
+                    _handleLock.ExitWriteLock();
+                }
             }
-            _sessions.Add(serverSessionHandle, obj);
         }
 
         private void Main()
@@ -112,6 +171,7 @@ namespace Ryujinx.HLE.HOS.Services
         private void ServerLoop()
         {
             _selfProcess = KernelStatic.GetCurrentProcess();
+            _selfThread = KernelStatic.GetCurrentThread();
 
             if (SmObjectFactory != null)
             {
@@ -122,8 +182,7 @@ namespace Ryujinx.HLE.HOS.Services
 
             InitDone.Set();
 
-            KThread thread = KernelStatic.GetCurrentThread();
-            ulong messagePtr = thread.TlsAddress;
+            ulong messagePtr = _selfThread.TlsAddress;
             _context.Syscall.SetHeapSize(out ulong heapAddr, 0x200000);
 
             _selfProcess.CpuMemory.Write(messagePtr + 0x0, 0);
@@ -134,27 +193,39 @@ namespace Ryujinx.HLE.HOS.Services
 
             while (true)
             {
-                int handleCount;
                 int portHandleCount;
+                int handleCount;
                 int[] handles;
 
-                lock (_handleLock)
+                bool handleLockTaken = false;
+                try
                 {
-                    portHandleCount = _portHandles.Count;
-                    handleCount = portHandleCount + _sessionHandles.Count;
+                    handleLockTaken = _handleLock.TryEnterReadLock(Timeout.Infinite);
+
+                    portHandleCount = _ports.Count;
+
+                    handleCount = portHandleCount + _sessions.Count;
 
                     handles = ArrayPool<int>.Shared.Rent(handleCount);
 
-                    _portHandles.CopyTo(handles, 0);
-                    _sessionHandles.CopyTo(handles, portHandleCount);
+                    _ports.Keys.CopyTo(handles, 0);
+
+                    _sessions.Keys.CopyTo(handles, portHandleCount);
+                }
+                finally
+                {
+                    if (handleLockTaken)
+                    {
+                        _handleLock.ExitReadLock();
+                    }
                 }
 
                 // We still need a timeout here to allow the service to pick up and listen new sessions...
                 var rc = _context.Syscall.ReplyAndReceive(out int signaledIndex, handles.AsSpan(0, handleCount), replyTargetHandle, 1000000L);
 
-                thread.HandlePostSyscall();
+                _selfThread.HandlePostSyscall();
 
-                if (!thread.Context.Running)
+                if (!_selfThread.Context.Running)
                 {
                     break;
                 }
@@ -178,9 +249,20 @@ namespace Ryujinx.HLE.HOS.Services
                         // We got a new connection, accept the session to allow servicing future requests.
                         if (_context.Syscall.AcceptSession(out int serverSessionHandle, handles[signaledIndex]) == Result.Success)
                         {
-                            IpcService obj = _ports[handles[signaledIndex]].Invoke();
-
-                            AddSessionObj(serverSessionHandle, obj);
+                            bool handleWriteLockTaken = false;
+                            try
+                            {
+                                handleWriteLockTaken = _handleLock.TryEnterWriteLock(Timeout.Infinite);
+                                IpcService obj = _ports[handles[signaledIndex]].Invoke();
+                                _sessions.Add(serverSessionHandle, obj);
+                            }
+                            finally
+                            {
+                                if (handleWriteLockTaken)
+                                {
+                                    _handleLock.ExitWriteLock();
+                                }
+                            }
                         }
                     }
 
@@ -197,11 +279,7 @@ namespace Ryujinx.HLE.HOS.Services
 
         private bool Process(int serverSessionHandle, ulong recvListAddr)
         {
-            KProcess process = KernelStatic.GetCurrentProcess();
-            KThread thread = KernelStatic.GetCurrentThread();
-            ulong messagePtr = thread.TlsAddress;
-
-            IpcMessage request = ReadRequest(process, messagePtr);
+            IpcMessage request = ReadRequest();
 
             IpcMessage response = new IpcMessage();
 
@@ -247,15 +325,15 @@ namespace Ryujinx.HLE.HOS.Services
 
                 ServiceCtx context = new ServiceCtx(
                     _context.Device,
-                    process,
-                    process.CpuMemory,
-                    thread,
+                    _selfProcess,
+                    _selfProcess.CpuMemory,
+                    _selfThread,
                     request,
                     response,
                     _requestDataReader,
                     _responseDataWriter);
 
-                _sessions[serverSessionHandle].CallCmifMethod(context);
+                GetSessionObj(serverSessionHandle).CallCmifMethod(context);
 
                 response.RawData = _responseDataStream.ToArray();
             }
@@ -268,7 +346,7 @@ namespace Ryujinx.HLE.HOS.Services
                 switch (cmdId)
                 {
                     case 0:
-                        FillHipcResponse(response, 0, _sessions[serverSessionHandle].ConvertToDomain());
+                        FillHipcResponse(response, 0, GetSessionObj(serverSessionHandle).ConvertToDomain());
                         break;
 
                     case 3:
@@ -278,17 +356,31 @@ namespace Ryujinx.HLE.HOS.Services
                     // TODO: Whats the difference between IpcDuplicateSession/Ex?
                     case 2:
                     case 4:
-                        int unknown = _requestDataReader.ReadInt32();
+                        {
+                            _ = _requestDataReader.ReadInt32();
 
-                        _context.Syscall.CreateSession(out int dupServerSessionHandle, out int dupClientSessionHandle, false, 0);
+                            _context.Syscall.CreateSession(out int dupServerSessionHandle, out int dupClientSessionHandle, false, 0);
 
-                        AddSessionObj(dupServerSessionHandle, _sessions[serverSessionHandle]);
+                            bool writeLockTaken = false;
+                            try
+                            {
+                                writeLockTaken = _handleLock.TryEnterWriteLock(Timeout.Infinite);
+                                _sessions[dupServerSessionHandle] = _sessions[serverSessionHandle];
+                            }
+                            finally
+                            {
+                                if (writeLockTaken)
+                                {
+                                    _handleLock.ExitWriteLock();
+                                }
+                            }
 
-                        response.HandleDesc = IpcHandleDesc.MakeMove(dupClientSessionHandle);
+                            response.HandleDesc = IpcHandleDesc.MakeMove(dupClientSessionHandle);
 
-                        FillHipcResponse(response, 0);
+                            FillHipcResponse(response, 0);
 
-                        break;
+                            break;
+                        }
 
                     default: throw new NotImplementedException(cmdId.ToString());
                 }
@@ -296,13 +388,10 @@ namespace Ryujinx.HLE.HOS.Services
             else if (request.Type == IpcMessageType.CmifCloseSession || request.Type == IpcMessageType.TipcCloseSession)
             {
                 _context.Syscall.CloseHandle(serverSessionHandle);
-                lock (_handleLock)
+                if (RemoveSessionObj(serverSessionHandle, out var session))
                 {
-                    _sessionHandles.Remove(serverSessionHandle);
+                    (session as IDisposable)?.Dispose();
                 }
-                IpcService service = _sessions[serverSessionHandle];
-                (service as IDisposable)?.Dispose();
-                _sessions.Remove(serverSessionHandle);
                 shouldReply = false;
             }
             // If the type is past 0xF, we are using TIPC
@@ -317,20 +406,20 @@ namespace Ryujinx.HLE.HOS.Services
 
                 ServiceCtx context = new ServiceCtx(
                     _context.Device,
-                    process,
-                    process.CpuMemory,
-                    thread,
+                    _selfProcess,
+                    _selfProcess.CpuMemory,
+                    _selfThread,
                     request,
                     response,
                     _requestDataReader,
                     _responseDataWriter);
 
-                _sessions[serverSessionHandle].CallTipcMethod(context);
+                GetSessionObj(serverSessionHandle).CallTipcMethod(context);
 
                 response.RawData = _responseDataStream.ToArray();
 
                 using var responseStream = response.GetStreamTipc();
-                process.CpuMemory.Write(messagePtr, responseStream.GetReadOnlySequence());
+                _selfProcess.CpuMemory.Write(_selfThread.TlsAddress, responseStream.GetReadOnlySequence());
             }
             else
             {
@@ -339,27 +428,24 @@ namespace Ryujinx.HLE.HOS.Services
 
             if (!isTipcCommunication)
             {
-                using var responseStream = response.GetStream((long)messagePtr, recvListAddr | ((ulong)PointerBufferSize << 48));
-                process.CpuMemory.Write(messagePtr, responseStream.GetReadOnlySequence());
+                using var responseStream = response.GetStream((long)_selfThread.TlsAddress, recvListAddr | ((ulong)PointerBufferSize << 48));
+                _selfProcess.CpuMemory.Write(_selfThread.TlsAddress, responseStream.GetReadOnlySequence());
             }
 
             return shouldReply;
         }
 
-        private static IpcMessage ReadRequest(KProcess process, ulong messagePtr)
+        private IpcMessage ReadRequest()
         {
             const int messageSize = 0x100;
 
-            byte[] reqData = ArrayPool<byte>.Shared.Rent(messageSize);
+            using IMemoryOwner<byte> reqDataOwner = ByteMemoryPool.Shared.Rent(messageSize);
 
-            Span<byte> reqDataSpan = reqData.AsSpan(0, messageSize);
-            reqDataSpan.Clear();
+            Span<byte> reqDataSpan = reqDataOwner.Memory.Span;
 
-            process.CpuMemory.Read(messagePtr, reqDataSpan);
+            _selfProcess.CpuMemory.Read(_selfThread.TlsAddress, reqDataSpan);
 
-            IpcMessage request = new IpcMessage(reqDataSpan, (long)messagePtr);
-
-            ArrayPool<byte>.Shared.Return(reqData);
+            IpcMessage request = new IpcMessage(reqDataSpan, (long)_selfThread.TlsAddress);
 
             return request;
         }
@@ -392,26 +478,35 @@ namespace Ryujinx.HLE.HOS.Services
 
         protected virtual void Dispose(bool disposing)
         {
-            if (disposing)
+            if (disposing && _selfThread != null)
             {
-                foreach (IpcService service in _sessions.Values)
+                if (_selfThread.HostThread.ManagedThreadId != Environment.CurrentManagedThreadId && _selfThread.HostThread.Join(ThreadJoinTimeout) == false)
                 {
-                    if (service is IDisposable disposableObj)
-                    {
-                        disposableObj.Dispose();
-                    }
+                    Logger.Warning?.Print(LogClass.Service, $"The ServerBase thread didn't terminate within {ThreadJoinTimeout:g}, waiting longer.");
 
-                    service.DestroyAtExit();
+                    _selfThread.HostThread.Join(Timeout.Infinite);
                 }
 
-                _sessions.Clear();
+                if (Interlocked.Exchange(ref _isDisposed, 1) == 0)
+                {
+                    foreach (IpcService service in _sessions.Values)
+                    {
+                        (service as IDisposable)?.Dispose();
 
-                _requestDataReader.Dispose();
-                _requestDataStream.Dispose();
-                _responseDataWriter.Dispose();
-                _responseDataStream.Dispose();
+                        service.DestroyAtExit();
+                    }
 
-                InitDone.Dispose();
+                    _sessions.Clear();
+                    _ports.Clear();
+                    _handleLock.Dispose();
+
+                    _requestDataReader.Dispose();
+                    _requestDataStream.Dispose();
+                    _responseDataWriter.Dispose();
+                    _responseDataStream.Dispose();
+
+                    InitDone.Dispose();
+                }
             }
         }
 

src/Ryujinx/Ui/Windows/SettingsWindow.cs

@@ -478,7 +478,7 @@ namespace Ryujinx.Ui.Windows
 
             if (Enum.Parse<GraphicsBackend>(_graphicsBackend.ActiveId) == GraphicsBackend.Vulkan)
             {
-                var devices = VulkanRenderer.GetPhysicalDevices(Vk.GetApi());
+                var devices = VulkanRenderer.GetPhysicalDevices();
                 string preferredGpuIdFromConfig = ConfigurationState.Instance.Graphics.PreferredGpu.Value;
                 string preferredGpuId = preferredGpuIdFromConfig;
                 bool noGpuId = string.IsNullOrEmpty(preferredGpuIdFromConfig);