Add support for bindless textures from shader input (vertex buffer) on Vulkan (#6577)

* Add support for bindless textures from shader input (vertex buffer)

* Shader cache version bump

* Format whitespace

* Remove cache entries on pool removal, disable for OpenGL

* PR feedback

Directory.Packages.props

@@ -20,7 +20,7 @@
     <PackageVersion Include="LibHac" Version="0.19.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" />
-    <PackageVersion Include="Microsoft.IdentityModel.JsonWebTokens" Version="7.4.0" />
+    <PackageVersion Include="Microsoft.IdentityModel.JsonWebTokens" Version="7.5.1" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
     <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.0" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
@@ -42,7 +42,7 @@
     <PackageVersion Include="Silk.NET.Vulkan" Version="2.16.0" />
     <PackageVersion Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.16.0" />
     <PackageVersion Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.16.0" />
-    <PackageVersion Include="SixLabors.ImageSharp" Version="2.1.7" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="2.1.8" />
     <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="1.0.0" />
     <PackageVersion Include="SPB" Version="0.0.4-build32" />
     <PackageVersion Include="System.IO.Hashing" Version="8.0.0" />

src/ARMeilleure/Instructions/InstEmitAlu32.cs

@@ -19,6 +19,12 @@ namespace ARMeilleure.Instructions
             Operand n = GetAluN(context);
             Operand m = GetAluM(context, setCarry: false);
 
+            if (op.Rn == RegisterAlias.Aarch32Pc && op is OpCodeT32AluImm12)
+            {
+                // For ADR, PC is always 4 bytes aligned, even in Thumb mode.
+                n = context.BitwiseAnd(n, Const(~3u));
+            }
+
             Operand res = context.Add(n, m);
 
             if (ShouldSetFlags(context))
@@ -467,6 +473,12 @@ namespace ARMeilleure.Instructions
             Operand n = GetAluN(context);
             Operand m = GetAluM(context, setCarry: false);
 
+            if (op.Rn == RegisterAlias.Aarch32Pc && op is OpCodeT32AluImm12)
+            {
+                // For ADR, PC is always 4 bytes aligned, even in Thumb mode.
+                n = context.BitwiseAnd(n, Const(~3u));
+            }
+
             Operand res = context.Subtract(n, m);
 
             if (ShouldSetFlags(context))

src/ARMeilleure/Instructions/InstEmitSimdArithmetic.cs

@@ -2426,7 +2426,11 @@ namespace ARMeilleure.Instructions
             }
             else if (Optimizations.FastFP && Optimizations.UseSse41 && sizeF == 0)
             {
-                Operand res = EmitSse41Round32Exp8OpF(context, context.AddIntrinsic(Intrinsic.X86Rsqrtss, GetVec(op.Rn)), scalar: true);
+                // RSQRTSS handles subnormals as zero, which differs from Arm, so we can't use it here.
+
+                Operand res = context.AddIntrinsic(Intrinsic.X86Sqrtss, GetVec(op.Rn));
+                res = context.AddIntrinsic(Intrinsic.X86Rcpss, res);
+                res = EmitSse41Round32Exp8OpF(context, res, scalar: true);
 
                 context.Copy(GetVec(op.Rd), context.VectorZeroUpper96(res));
             }
@@ -2451,7 +2455,11 @@ namespace ARMeilleure.Instructions
             }
             else if (Optimizations.FastFP && Optimizations.UseSse41 && sizeF == 0)
             {
-                Operand res = EmitSse41Round32Exp8OpF(context, context.AddIntrinsic(Intrinsic.X86Rsqrtps, GetVec(op.Rn)), scalar: false);
+                // RSQRTPS handles subnormals as zero, which differs from Arm, so we can't use it here.
+
+                Operand res = context.AddIntrinsic(Intrinsic.X86Sqrtps, GetVec(op.Rn));
+                res = context.AddIntrinsic(Intrinsic.X86Rcpps, res);
+                res = EmitSse41Round32Exp8OpF(context, res, scalar: false);
 
                 if (op.RegisterSize == RegisterSize.Simd64)
                 {

src/ARMeilleure/Translation/PTC/Ptc.cs

@@ -29,7 +29,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 5518; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 6634; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";

src/Ryujinx.Audio.Backends.SDL2/SDL2HardwareDeviceSession.cs

@@ -1,8 +1,10 @@
 using Ryujinx.Audio.Backends.Common;
 using Ryujinx.Audio.Common;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Threading;
 
@@ -87,7 +89,9 @@ namespace Ryujinx.Audio.Backends.SDL2
                 return;
             }
 
-            byte[] samples = new byte[frameCount * _bytesPerFrame];
+            using IMemoryOwner<byte> samplesOwner = ByteMemoryPool.Rent(frameCount * _bytesPerFrame);
+
+            Span<byte> samples = samplesOwner.Memory.Span;
 
             _ringBuffer.Read(samples, 0, samples.Length);
 

src/Ryujinx.Audio.Backends.SoundIo/SoundIoHardwareDeviceSession.cs

@@ -1,8 +1,10 @@
 using Ryujinx.Audio.Backends.Common;
 using Ryujinx.Audio.Backends.SoundIo.Native;
 using Ryujinx.Audio.Common;
+using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -37,7 +39,7 @@ namespace Ryujinx.Audio.Backends.SoundIo
             _outputStream = _driver.OpenStream(RequestedSampleFormat, RequestedSampleRate, RequestedChannelCount);
             _outputStream.WriteCallback += Update;
             _outputStream.Volume = requestedVolume;
-            // TODO: Setup other callbacks (errors, ect).
+            // TODO: Setup other callbacks (errors, etc.)
 
             _outputStream.Open();
         }
@@ -120,7 +122,9 @@ namespace Ryujinx.Audio.Backends.SoundIo
 
             int channelCount = areas.Length;
 
-            byte[] samples = new byte[frameCount * bytesPerFrame];
+            using IMemoryOwner<byte> samplesOwner = ByteMemoryPool.Rent(frameCount * bytesPerFrame);
+
+            Span<byte> samples = samplesOwner.Memory.Span;
 
             _ringBuffer.Read(samples, 0, samples.Length);
 

src/Ryujinx.Audio/Renderer/Server/BehaviourContext.cs

@@ -212,7 +212,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <summary>
         /// Check if the audio renderer should fix the GC-ADPCM context not being provided to the DSP.
         /// </summary>
-        /// <returns>True if if the audio renderer should fix it.</returns>
+        /// <returns>True if the audio renderer should fix it.</returns>
         public bool IsAdpcmLoopContextBugFixed()
         {
             return CheckFeatureSupported(UserRevision, BaseRevisionMagic + Revision2);

src/Ryujinx.Audio/Renderer/Server/Splitter/SplitterState.cs

@@ -159,6 +159,11 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
                 }
             }
 
+            if (destinationCount < parameter.DestinationCount)
+            {
+                input.Advance((parameter.DestinationCount - destinationCount) * sizeof(int));
+            }
+
             Debug.Assert(parameter.Id == Id);
 
             if (parameter.Id == Id)

src/Ryujinx.Common/Configuration/Hid/KeyboardHotkeys.cs

@@ -1,7 +1,5 @@
 namespace Ryujinx.Common.Configuration.Hid
 {
-    // NOTE: Please don't change this to struct.
-    //       This breaks Avalonia's TwoWay binding, which makes us unable to save new KeyboardHotkeys.
     public class KeyboardHotkeys
     {
         public Key ToggleVsync { get; set; }

src/Ryujinx.Common/Extensions/SequenceReaderExtensions.cs

@@ -44,7 +44,7 @@ namespace Ryujinx.Common.Extensions
         /// <remarks>
         /// DO NOT use <paramref name="copyDestinationIfRequiredDoNotUse"/> after calling this method, as it will only
         /// contain a value if the value couldn't be referenced directly because it spans multiple <see cref="ReadOnlyMemory{Byte}"/> segments.
-        /// To discourage use, it is recommended to to call this method like the following:
+        /// To discourage use, it is recommended to call this method like the following:
         /// <c>
         ///     ref readonly MyStruct value = ref sequenceReader.GetRefOrRefToCopy{MyStruct}(out _);
         /// </c>

src/Ryujinx.Common/Memory/SpanOrArray.cs

@@ -1,89 +0,0 @@
-using System;
-
-namespace Ryujinx.Common.Memory
-{
-    /// <summary>
-    /// A struct that can represent both a Span and Array.
-    /// This is useful to keep the Array representation when possible to avoid copies.
-    /// </summary>
-    /// <typeparam name="T">Element Type</typeparam>
-    public readonly ref struct SpanOrArray<T> where T : unmanaged
-    {
-        public readonly T[] Array;
-        public readonly ReadOnlySpan<T> Span;
-
-        /// <summary>
-        /// Create a new SpanOrArray from an array.
-        /// </summary>
-        /// <param name="array">Array to store</param>
-        public SpanOrArray(T[] array)
-        {
-            Array = array;
-            Span = ReadOnlySpan<T>.Empty;
-        }
-
-        /// <summary>
-        /// Create a new SpanOrArray from a readonly span.
-        /// </summary>
-        /// <param name="array">Span to store</param>
-        public SpanOrArray(ReadOnlySpan<T> span)
-        {
-            Array = null;
-            Span = span;
-        }
-
-        /// <summary>
-        /// Return the contained array, or convert the span if necessary.
-        /// </summary>
-        /// <returns>An array containing the data</returns>
-        public T[] ToArray()
-        {
-            return Array ?? Span.ToArray();
-        }
-
-        /// <summary>
-        /// Return a ReadOnlySpan from either the array or ReadOnlySpan.
-        /// </summary>
-        /// <returns>A ReadOnlySpan containing the data</returns>
-        public ReadOnlySpan<T> AsSpan()
-        {
-            return Array ?? Span;
-        }
-
-        /// <summary>
-        /// Cast an array to a SpanOrArray.
-        /// </summary>
-        /// <param name="array">Source array</param>
-        public static implicit operator SpanOrArray<T>(T[] array)
-        {
-            return new SpanOrArray<T>(array);
-        }
-
-        /// <summary>
-        /// Cast a ReadOnlySpan to a SpanOrArray.
-        /// </summary>
-        /// <param name="span">Source ReadOnlySpan</param>
-        public static implicit operator SpanOrArray<T>(ReadOnlySpan<T> span)
-        {
-            return new SpanOrArray<T>(span);
-        }
-
-        /// <summary>
-        /// Cast a Span to a SpanOrArray.
-        /// </summary>
-        /// <param name="span">Source Span</param>
-        public static implicit operator SpanOrArray<T>(Span<T> span)
-        {
-            return new SpanOrArray<T>(span);
-        }
-
-        /// <summary>
-        /// Cast a SpanOrArray to a ReadOnlySpan
-        /// </summary>
-        /// <param name="spanOrArray">Source SpanOrArray</param>
-        public static implicit operator ReadOnlySpan<T>(SpanOrArray<T> spanOrArray)
-        {
-            return spanOrArray.AsSpan();
-        }
-    }
-}

src/Ryujinx.Common/Utilities/EmbeddedResources.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Common.Utilities;
 using System;
+using System.Buffers;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -41,6 +42,22 @@ namespace Ryujinx.Common
             return StreamUtils.StreamToBytes(stream);
         }
 
+        public static IMemoryOwner<byte> ReadFileToRentedMemory(string filename)
+        {
+            var (assembly, path) = ResolveManifestPath(filename);
+
+            return ReadFileToRentedMemory(assembly, path);
+        }
+
+        public static IMemoryOwner<byte> ReadFileToRentedMemory(Assembly assembly, string filename)
+        {
+            using var stream = GetStream(assembly, filename);
+
+            return stream is null
+                ? null
+                : StreamUtils.StreamToRentedMemory(stream);
+        }
+
         public async static Task<byte[]> ReadAsync(Assembly assembly, string filename)
         {
             using var stream = GetStream(assembly, filename);

src/Ryujinx.Common/Utilities/StreamUtils.cs

@@ -1,4 +1,6 @@
+using Microsoft.IO;
 using Ryujinx.Common.Memory;
+using System.Buffers;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,12 +11,50 @@ namespace Ryujinx.Common.Utilities
     {
         public static byte[] StreamToBytes(Stream input)
         {
-            using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
+            using RecyclableMemoryStream output = StreamToRecyclableMemoryStream(input);
 
+            return output.ToArray();
+        }
 
-            input.CopyTo(stream);
+        public static IMemoryOwner<byte> StreamToRentedMemory(Stream input)
+        {
+            if (input is MemoryStream inputMemoryStream)
+            {
+                return MemoryStreamToRentedMemory(inputMemoryStream);
+            }
+            else if (input.CanSeek)
+            {
+                long bytesExpected = input.Length;
 
-            return stream.ToArray();
+                IMemoryOwner<byte> ownedMemory = ByteMemoryPool.Rent(bytesExpected);
+
+                var destSpan = ownedMemory.Memory.Span;
+
+                int totalBytesRead = 0;
+
+                while (totalBytesRead < bytesExpected)
+                {
+                    int bytesRead = input.Read(destSpan[totalBytesRead..]);
+
+                    if (bytesRead == 0)
+                    {
+                        ownedMemory.Dispose();
+
+                        throw new IOException($"Tried reading {bytesExpected} but the stream closed after reading {totalBytesRead}.");
+                    }
+
+                    totalBytesRead += bytesRead;
+                }
+
+                return ownedMemory;
+            }
+            else
+            {
+                // If input is (non-seekable) then copy twice: first into a RecyclableMemoryStream, then to a rented IMemoryOwner<byte>.
+                using RecyclableMemoryStream output = StreamToRecyclableMemoryStream(input);
+
+                return MemoryStreamToRentedMemory(output);
+            }
         }
 
         public static async Task<byte[]> StreamToBytesAsync(Stream input, CancellationToken cancellationToken = default)
@@ -25,5 +65,26 @@ namespace Ryujinx.Common.Utilities
 
             return stream.ToArray();
         }
+
+        private static IMemoryOwner<byte> MemoryStreamToRentedMemory(MemoryStream input)
+        {
+            input.Position = 0;
+
+            IMemoryOwner<byte> ownedMemory = ByteMemoryPool.Rent(input.Length);
+
+            // Discard the return value because we assume reading a MemoryStream always succeeds completely.
+            _ = input.Read(ownedMemory.Memory.Span);
+
+            return ownedMemory;
+        }
+
+        private static RecyclableMemoryStream StreamToRecyclableMemoryStream(Stream input)
+        {
+            RecyclableMemoryStream stream = MemoryStreamManager.Shared.GetStream();
+
+            input.CopyTo(stream);
+
+            return stream;
+        }
     }
 }

src/Ryujinx.Cpu/Jit/MemoryManagerHostTracked.cs

@@ -85,6 +85,70 @@ namespace Ryujinx.Cpu.Jit
             _addressSpace = new(Tracking, backingMemory, _nativePageTable, useProtectionMirrors);
         }
 
+        public override ReadOnlySequence<byte> GetReadOnlySequence(ulong va, int size, bool tracked = false)
+        {
+            if (size == 0)
+            {
+                return ReadOnlySequence<byte>.Empty;
+            }
+
+            try
+            {
+                if (tracked)
+                {
+                    SignalMemoryTracking(va, (ulong)size, false);
+                }
+                else
+                {
+                    AssertValidAddressAndSize(va, (ulong)size);
+                }
+
+                ulong endVa = va + (ulong)size;
+                int offset = 0;
+
+                BytesReadOnlySequenceSegment first = null, last = null;
+
+                while (va < endVa)
+                {
+                    (MemoryBlock memory, ulong rangeOffset, ulong copySize) = GetMemoryOffsetAndSize(va, (ulong)(size - offset));
+
+                    Memory<byte> physicalMemory = memory.GetMemory(rangeOffset, (int)copySize);
+
+                    if (first is null)
+                    {
+                        first = last = new BytesReadOnlySequenceSegment(physicalMemory);
+                    }
+                    else
+                    {
+                        if (last.IsContiguousWith(physicalMemory, out nuint contiguousStart, out int contiguousSize))
+                        {
+                            Memory<byte> contiguousPhysicalMemory = new NativeMemoryManager<byte>(contiguousStart, contiguousSize).Memory;
+
+                            last.Replace(contiguousPhysicalMemory);
+                        }
+                        else
+                        {
+                            last = last.Append(physicalMemory);
+                        }
+                    }
+
+                    va += copySize;
+                    offset += (int)copySize;
+                }
+
+                return new ReadOnlySequence<byte>(first, 0, last, (int)(size - last.RunningIndex));
+            }
+            catch (InvalidMemoryRegionException)
+            {
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
+
+                return ReadOnlySequence<byte>.Empty;
+            }
+        }
+
         /// <inheritdoc/>
         public void Map(ulong va, ulong pa, ulong size, MemoryMapFlags flags)
         {

src/Ryujinx.Graphics.Device/DeviceMemoryManager.cs

@@ -1,5 +1,7 @@
+using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using System;
+using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -143,11 +145,11 @@ namespace Ryujinx.Graphics.Device
             }
             else
             {
-                Memory<byte> memory = new byte[size];
+                IMemoryOwner<byte> memoryOwner = ByteMemoryPool.Rent(size);
 
-                GetSpan(va, size).CopyTo(memory.Span);
+                GetSpan(va, size).CopyTo(memoryOwner.Memory.Span);
 
-                return new WritableRegion(this, va, memory, tracked: true);
+                return new WritableRegion(this, va, memoryOwner, tracked: true);
             }
         }
 

src/Ryujinx.Graphics.GAL/Capabilities.cs

@@ -36,6 +36,7 @@ namespace Ryujinx.Graphics.GAL
         public readonly bool SupportsMismatchingViewFormat;
         public readonly bool SupportsCubemapView;
         public readonly bool SupportsNonConstantTextureOffset;
+        public readonly bool SupportsSeparateSampler;
         public readonly bool SupportsShaderBallot;
         public readonly bool SupportsShaderBarrierDivergence;
         public readonly bool SupportsShaderFloat64;
@@ -92,6 +93,7 @@ namespace Ryujinx.Graphics.GAL
             bool supportsMismatchingViewFormat,
             bool supportsCubemapView,
             bool supportsNonConstantTextureOffset,
+            bool supportsSeparateSampler,
             bool supportsShaderBallot,
             bool supportsShaderBarrierDivergence,
             bool supportsShaderFloat64,
@@ -144,6 +146,7 @@ namespace Ryujinx.Graphics.GAL
             SupportsMismatchingViewFormat = supportsMismatchingViewFormat;
             SupportsCubemapView = supportsCubemapView;
             SupportsNonConstantTextureOffset = supportsNonConstantTextureOffset;
+            SupportsSeparateSampler = supportsSeparateSampler;
             SupportsShaderBallot = supportsShaderBallot;
             SupportsShaderBarrierDivergence = supportsShaderBarrierDivergence;
             SupportsShaderFloat64 = supportsShaderFloat64;

src/Ryujinx.Graphics.GAL/IImageArray.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.Graphics.GAL
+{
+    public interface IImageArray
+    {
+        void SetFormats(int index, Format[] imageFormats);
+        void SetImages(int index, ITexture[] images);
+    }
+}

src/Ryujinx.Graphics.GAL/IPipeline.cs

@@ -59,6 +59,7 @@ namespace Ryujinx.Graphics.GAL
         void SetIndexBuffer(BufferRange buffer, IndexType type);
 
         void SetImage(ShaderStage stage, int binding, ITexture texture, Format imageFormat);
+        void SetImageArray(ShaderStage stage, int binding, IImageArray array);
 
         void SetLineParameters(float width, bool smooth);
 
@@ -89,6 +90,7 @@ namespace Ryujinx.Graphics.GAL
         void SetStorageBuffers(ReadOnlySpan<BufferAssignment> buffers);
 
         void SetTextureAndSampler(ShaderStage stage, int binding, ITexture texture, ISampler sampler);
+        void SetTextureArray(ShaderStage stage, int binding, ITextureArray array);
 
         void SetTransformFeedbackBuffers(ReadOnlySpan<BufferRange> buffers);
         void SetUniformBuffers(ReadOnlySpan<BufferAssignment> buffers);

src/Ryujinx.Graphics.GAL/IRenderer.cs

@@ -21,10 +21,14 @@ namespace Ryujinx.Graphics.GAL
         BufferHandle CreateBuffer(nint pointer, int size);
         BufferHandle CreateBufferSparse(ReadOnlySpan<BufferRange> storageBuffers);
 
+        IImageArray CreateImageArray(int size, bool isBuffer);
+
         IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info);
 
         ISampler CreateSampler(SamplerCreateInfo info);
         ITexture CreateTexture(TextureCreateInfo info);
+        ITextureArray CreateTextureArray(int size, bool isBuffer);
+
         bool PrepareHostMapping(nint address, ulong size);
 
         void CreateSync(ulong id, bool strict);

src/Ryujinx.Graphics.GAL/ITexture.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Memory;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.GAL
 {
@@ -17,10 +17,34 @@ namespace Ryujinx.Graphics.GAL
         PinnedSpan<byte> GetData();
         PinnedSpan<byte> GetData(int layer, int level);
 
-        void SetData(SpanOrArray<byte> data);
-        void SetData(SpanOrArray<byte> data, int layer, int level);
-        void SetData(SpanOrArray<byte> data, int layer, int level, Rectangle<int> region);
+        /// <summary>
+        /// Sets the texture data. The data passed as a <see cref="IMemoryOwner{Byte}" /> will be disposed when
+        /// the operation completes.
+        /// </summary>
+        /// <param name="data">Texture data bytes</param>
+        void SetData(IMemoryOwner<byte> data);
+
+        /// <summary>
+        /// Sets the texture data. The data passed as a <see cref="IMemoryOwner{Byte}" /> will be disposed when
+        /// the operation completes.
+        /// </summary>
+        /// <param name="data">Texture data bytes</param>
+        /// <param name="layer">Target layer</param>
+        /// <param name="level">Target level</param>
+        void SetData(IMemoryOwner<byte> data, int layer, int level);
+
+        /// <summary>
+        /// Sets the texture data. The data passed as a <see cref="IMemoryOwner{Byte}" /> will be disposed when
+        /// the operation completes.
+        /// </summary>
+        /// <param name="data">Texture data bytes</param>
+        /// <param name="layer">Target layer</param>
+        /// <param name="level">Target level</param>
+        /// <param name="region">Target sub-region of the texture to update</param>
+        void SetData(IMemoryOwner<byte> data, int layer, int level, Rectangle<int> region);
+
         void SetStorage(BufferRange buffer);
+
         void Release();
     }
 }

src/Ryujinx.Graphics.GAL/ITextureArray.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.Graphics.GAL
+{
+    public interface ITextureArray
+    {
+        void SetSamplers(int index, ISampler[] samplers);
+        void SetTextures(int index, ITexture[] textures);
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/CommandHelper.cs

@@ -1,10 +1,12 @@
 using Ryujinx.Graphics.GAL.Multithreading.Commands;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Buffer;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.CounterEvent;
+using Ryujinx.Graphics.GAL.Multithreading.Commands.ImageArray;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Program;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Sampler;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Texture;
+using Ryujinx.Graphics.GAL.Multithreading.Commands.TextureArray;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Window;
 using System;
 using System.Linq;
@@ -46,10 +48,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             Register<CreateBufferAccessCommand>(CommandType.CreateBufferAccess);
             Register<CreateBufferSparseCommand>(CommandType.CreateBufferSparse);
             Register<CreateHostBufferCommand>(CommandType.CreateHostBuffer);
+            Register<CreateImageArrayCommand>(CommandType.CreateImageArray);
             Register<CreateProgramCommand>(CommandType.CreateProgram);
             Register<CreateSamplerCommand>(CommandType.CreateSampler);
             Register<CreateSyncCommand>(CommandType.CreateSync);
             Register<CreateTextureCommand>(CommandType.CreateTexture);
+            Register<CreateTextureArrayCommand>(CommandType.CreateTextureArray);
             Register<GetCapabilitiesCommand>(CommandType.GetCapabilities);
             Register<PreFrameCommand>(CommandType.PreFrame);
             Register<ReportCounterCommand>(CommandType.ReportCounter);
@@ -63,6 +67,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             Register<CounterEventDisposeCommand>(CommandType.CounterEventDispose);
             Register<CounterEventFlushCommand>(CommandType.CounterEventFlush);
 
+            Register<ImageArraySetFormatsCommand>(CommandType.ImageArraySetFormats);
+            Register<ImageArraySetImagesCommand>(CommandType.ImageArraySetImages);
+
             Register<ProgramDisposeCommand>(CommandType.ProgramDispose);
             Register<ProgramGetBinaryCommand>(CommandType.ProgramGetBinary);
             Register<ProgramCheckLinkCommand>(CommandType.ProgramCheckLink);
@@ -82,6 +89,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             Register<TextureSetDataSliceRegionCommand>(CommandType.TextureSetDataSliceRegion);
             Register<TextureSetStorageCommand>(CommandType.TextureSetStorage);
 
+            Register<TextureArraySetSamplersCommand>(CommandType.TextureArraySetSamplers);
+            Register<TextureArraySetTexturesCommand>(CommandType.TextureArraySetTextures);
+
             Register<WindowPresentCommand>(CommandType.WindowPresent);
 
             Register<BarrierCommand>(CommandType.Barrier);
@@ -114,6 +124,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             Register<SetTransformFeedbackBuffersCommand>(CommandType.SetTransformFeedbackBuffers);
             Register<SetUniformBuffersCommand>(CommandType.SetUniformBuffers);
             Register<SetImageCommand>(CommandType.SetImage);
+            Register<SetImageArrayCommand>(CommandType.SetImageArray);
             Register<SetIndexBufferCommand>(CommandType.SetIndexBuffer);
             Register<SetLineParametersCommand>(CommandType.SetLineParameters);
             Register<SetLogicOpStateCommand>(CommandType.SetLogicOpState);
@@ -130,6 +141,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             Register<SetScissorsCommand>(CommandType.SetScissor);
             Register<SetStencilTestCommand>(CommandType.SetStencilTest);
             Register<SetTextureAndSamplerCommand>(CommandType.SetTextureAndSampler);
+            Register<SetTextureArrayCommand>(CommandType.SetTextureArray);
             Register<SetUserClipDistanceCommand>(CommandType.SetUserClipDistance);
             Register<SetVertexAttribsCommand>(CommandType.SetVertexAttribs);
             Register<SetVertexBuffersCommand>(CommandType.SetVertexBuffers);

src/Ryujinx.Graphics.GAL/Multithreading/CommandType.cs

@@ -7,10 +7,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
         CreateBufferAccess,
         CreateBufferSparse,
         CreateHostBuffer,
+        CreateImageArray,
         CreateProgram,
         CreateSampler,
         CreateSync,
         CreateTexture,
+        CreateTextureArray,
         GetCapabilities,
         Unused,
         PreFrame,
@@ -25,6 +27,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
         CounterEventDispose,
         CounterEventFlush,
 
+        ImageArraySetFormats,
+        ImageArraySetImages,
+
         ProgramDispose,
         ProgramGetBinary,
         ProgramCheckLink,
@@ -44,6 +49,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
         TextureSetDataSliceRegion,
         TextureSetStorage,
 
+        TextureArraySetSamplers,
+        TextureArraySetTextures,
+
         WindowPresent,
 
         Barrier,
@@ -76,6 +84,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
         SetTransformFeedbackBuffers,
         SetUniformBuffers,
         SetImage,
+        SetImageArray,
         SetIndexBuffer,
         SetLineParameters,
         SetLogicOpState,
@@ -92,6 +101,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
         SetScissor,
         SetStencilTest,
         SetTextureAndSampler,
+        SetTextureArray,
         SetUserClipDistance,
         SetVertexAttribs,
         SetVertexBuffers,

src/Ryujinx.Graphics.GAL/Multithreading/Commands/ImageArray/ImageArraySetFormatsCommand.cs

@@ -0,0 +1,26 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.ImageArray
+{
+    struct ImageArraySetFormatsCommand : IGALCommand, IGALCommand<ImageArraySetFormatsCommand>
+    {
+        public readonly CommandType CommandType => CommandType.ImageArraySetFormats;
+        private TableRef<ThreadedImageArray> _imageArray;
+        private int _index;
+        private TableRef<Format[]> _imageFormats;
+
+        public void Set(TableRef<ThreadedImageArray> imageArray, int index, TableRef<Format[]> imageFormats)
+        {
+            _imageArray = imageArray;
+            _index = index;
+            _imageFormats = imageFormats;
+        }
+
+        public static void Run(ref ImageArraySetFormatsCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            ThreadedImageArray imageArray = command._imageArray.Get(threaded);
+            imageArray.Base.SetFormats(command._index, command._imageFormats.Get(threaded));
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Commands/ImageArray/ImageArraySetImagesCommand.cs

@@ -0,0 +1,27 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+using System.Linq;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.ImageArray
+{
+    struct ImageArraySetImagesCommand : IGALCommand, IGALCommand<ImageArraySetImagesCommand>
+    {
+        public readonly CommandType CommandType => CommandType.ImageArraySetImages;
+        private TableRef<ThreadedImageArray> _imageArray;
+        private int _index;
+        private TableRef<ITexture[]> _images;
+
+        public void Set(TableRef<ThreadedImageArray> imageArray, int index, TableRef<ITexture[]> images)
+        {
+            _imageArray = imageArray;
+            _index = index;
+            _images = images;
+        }
+
+        public static void Run(ref ImageArraySetImagesCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            ThreadedImageArray imageArray = command._imageArray.Get(threaded);
+            imageArray.Base.SetImages(command._index, command._images.Get(threaded).Select(texture => ((ThreadedTexture)texture)?.Base).ToArray());
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateImageArrayCommand.cs

@@ -0,0 +1,25 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
+{
+    struct CreateImageArrayCommand : IGALCommand, IGALCommand<CreateImageArrayCommand>
+    {
+        public readonly CommandType CommandType => CommandType.CreateImageArray;
+        private TableRef<ThreadedImageArray> _imageArray;
+        private int _size;
+        private bool _isBuffer;
+
+        public void Set(TableRef<ThreadedImageArray> imageArray, int size, bool isBuffer)
+        {
+            _imageArray = imageArray;
+            _size = size;
+            _isBuffer = isBuffer;
+        }
+
+        public static void Run(ref CreateImageArrayCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            command._imageArray.Get(threaded).Base = renderer.CreateImageArray(command._size, command._isBuffer);
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateTextureArrayCommand.cs

@@ -0,0 +1,25 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
+{
+    struct CreateTextureArrayCommand : IGALCommand, IGALCommand<CreateTextureArrayCommand>
+    {
+        public readonly CommandType CommandType => CommandType.CreateTextureArray;
+        private TableRef<ThreadedTextureArray> _textureArray;
+        private int _size;
+        private bool _isBuffer;
+
+        public void Set(TableRef<ThreadedTextureArray> textureArray, int size, bool isBuffer)
+        {
+            _textureArray = textureArray;
+            _size = size;
+            _isBuffer = isBuffer;
+        }
+
+        public static void Run(ref CreateTextureArrayCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            command._textureArray.Get(threaded).Base = renderer.CreateTextureArray(command._size, command._isBuffer);
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Commands/SetImageArrayCommand.cs

@@ -0,0 +1,26 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+using Ryujinx.Graphics.Shader;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct SetImageArrayCommand : IGALCommand, IGALCommand<SetImageArrayCommand>
+    {
+        public readonly CommandType CommandType => CommandType.SetImageArray;
+        private ShaderStage _stage;
+        private int _binding;
+        private TableRef<IImageArray> _array;
+
+        public void Set(ShaderStage stage, int binding, TableRef<IImageArray> array)
+        {
+            _stage = stage;
+            _binding = binding;
+            _array = array;
+        }
+
+        public static void Run(ref SetImageArrayCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.SetImageArray(command._stage, command._binding, command._array.GetAs<ThreadedImageArray>(threaded)?.Base);
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Commands/SetTextureArrayCommand.cs

@@ -0,0 +1,26 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+using Ryujinx.Graphics.Shader;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct SetTextureArrayCommand : IGALCommand, IGALCommand<SetTextureArrayCommand>
+    {
+        public readonly CommandType CommandType => CommandType.SetTextureArray;
+        private ShaderStage _stage;
+        private int _binding;
+        private TableRef<ITextureArray> _array;
+
+        public void Set(ShaderStage stage, int binding, TableRef<ITextureArray> array)
+        {
+            _stage = stage;
+            _binding = binding;
+            _array = array;
+        }
+
+        public static void Run(ref SetTextureArrayCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.SetTextureArray(command._stage, command._binding, command._array.GetAs<ThreadedTextureArray>(threaded)?.Base);
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataCommand.cs

@@ -1,6 +1,6 @@
 using Ryujinx.Graphics.GAL.Multithreading.Model;
 using Ryujinx.Graphics.GAL.Multithreading.Resources;
-using System;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
@@ -8,9 +8,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
     {
         public readonly CommandType CommandType => CommandType.TextureSetData;
         private TableRef<ThreadedTexture> _texture;
-        private TableRef<byte[]> _data;
+        private TableRef<IMemoryOwner<byte>> _data;
 
-        public void Set(TableRef<ThreadedTexture> texture, TableRef<byte[]> data)
+        public void Set(TableRef<ThreadedTexture> texture, TableRef<IMemoryOwner<byte>> data)
         {
             _texture = texture;
             _data = data;
@@ -19,7 +19,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
         public static void Run(ref TextureSetDataCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
             ThreadedTexture texture = command._texture.Get(threaded);
-            texture.Base.SetData(new ReadOnlySpan<byte>(command._data.Get(threaded)));
+            texture.Base.SetData(command._data.Get(threaded));
         }
     }
 }

src/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataSliceCommand.cs

@@ -1,6 +1,6 @@
 using Ryujinx.Graphics.GAL.Multithreading.Model;
 using Ryujinx.Graphics.GAL.Multithreading.Resources;
-using System;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
@@ -8,11 +8,11 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
     {
         public readonly CommandType CommandType => CommandType.TextureSetDataSlice;
         private TableRef<ThreadedTexture> _texture;
-        private TableRef<byte[]> _data;
+        private TableRef<IMemoryOwner<byte>> _data;
         private int _layer;
         private int _level;
 
-        public void Set(TableRef<ThreadedTexture> texture, TableRef<byte[]> data, int layer, int level)
+        public void Set(TableRef<ThreadedTexture> texture, TableRef<IMemoryOwner<byte>> data, int layer, int level)
         {
             _texture = texture;
             _data = data;
@@ -23,7 +23,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
         public static void Run(ref TextureSetDataSliceCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
             ThreadedTexture texture = command._texture.Get(threaded);
-            texture.Base.SetData(new ReadOnlySpan<byte>(command._data.Get(threaded)), command._layer, command._level);
+            texture.Base.SetData(command._data.Get(threaded), command._layer, command._level);
         }
     }
 }

src/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataSliceRegionCommand.cs

@@ -1,6 +1,6 @@
 using Ryujinx.Graphics.GAL.Multithreading.Model;
 using Ryujinx.Graphics.GAL.Multithreading.Resources;
-using System;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
@@ -8,12 +8,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
     {
         public readonly CommandType CommandType => CommandType.TextureSetDataSliceRegion;
         private TableRef<ThreadedTexture> _texture;
-        private TableRef<byte[]> _data;
+        private TableRef<IMemoryOwner<byte>> _data;
         private int _layer;
         private int _level;
         private Rectangle<int> _region;
 
-        public void Set(TableRef<ThreadedTexture> texture, TableRef<byte[]> data, int layer, int level, Rectangle<int> region)
+        public void Set(TableRef<ThreadedTexture> texture, TableRef<IMemoryOwner<byte>> data, int layer, int level, Rectangle<int> region)
         {
             _texture = texture;
             _data = data;
@@ -25,7 +25,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
         public static void Run(ref TextureSetDataSliceRegionCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
             ThreadedTexture texture = command._texture.Get(threaded);
-            texture.Base.SetData(new ReadOnlySpan<byte>(command._data.Get(threaded)), command._layer, command._level, command._region);
+            texture.Base.SetData(command._data.Get(threaded), command._layer, command._level, command._region);
         }
     }
 }

src/Ryujinx.Graphics.GAL/Multithreading/Commands/TextureAndSamplerArray/TextureArraySetSamplersCommand.cs

@@ -0,0 +1,27 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+using System.Linq;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.TextureArray
+{
+    struct TextureArraySetSamplersCommand : IGALCommand, IGALCommand<TextureArraySetSamplersCommand>
+    {
+        public readonly CommandType CommandType => CommandType.TextureArraySetSamplers;
+        private TableRef<ThreadedTextureArray> _textureArray;
+        private int _index;
+        private TableRef<ISampler[]> _samplers;
+
+        public void Set(TableRef<ThreadedTextureArray> textureArray, int index, TableRef<ISampler[]> samplers)
+        {
+            _textureArray = textureArray;
+            _index = index;
+            _samplers = samplers;
+        }
+
+        public static void Run(ref TextureArraySetSamplersCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            ThreadedTextureArray textureArray = command._textureArray.Get(threaded);
+            textureArray.Base.SetSamplers(command._index, command._samplers.Get(threaded).Select(sampler => ((ThreadedSampler)sampler)?.Base).ToArray());
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Commands/TextureAndSamplerArray/TextureArraySetTexturesCommand.cs

@@ -0,0 +1,27 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+using System.Linq;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.TextureArray
+{
+    struct TextureArraySetTexturesCommand : IGALCommand, IGALCommand<TextureArraySetTexturesCommand>
+    {
+        public readonly CommandType CommandType => CommandType.TextureArraySetTextures;
+        private TableRef<ThreadedTextureArray> _textureArray;
+        private int _index;
+        private TableRef<ITexture[]> _textures;
+
+        public void Set(TableRef<ThreadedTextureArray> textureArray, int index, TableRef<ITexture[]> textures)
+        {
+            _textureArray = textureArray;
+            _index = index;
+            _textures = textures;
+        }
+
+        public static void Run(ref TextureArraySetTexturesCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            ThreadedTextureArray textureArray = command._textureArray.Get(threaded);
+            textureArray.Base.SetTextures(command._index, command._textures.Get(threaded).Select(texture => ((ThreadedTexture)texture)?.Base).ToArray());
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedImageArray.cs

@@ -0,0 +1,36 @@
+using Ryujinx.Graphics.GAL.Multithreading.Commands.ImageArray;
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Resources
+{
+    /// <summary>
+    /// Threaded representation of a image array.
+    /// </summary>
+    class ThreadedImageArray : IImageArray
+    {
+        private readonly ThreadedRenderer _renderer;
+        public IImageArray Base;
+
+        public ThreadedImageArray(ThreadedRenderer renderer)
+        {
+            _renderer = renderer;
+        }
+
+        private TableRef<T> Ref<T>(T reference)
+        {
+            return new TableRef<T>(_renderer, reference);
+        }
+
+        public void SetFormats(int index, Format[] imageFormats)
+        {
+            _renderer.New<ImageArraySetFormatsCommand>().Set(Ref(this), index, Ref(imageFormats));
+            _renderer.QueueCommand();
+        }
+
+        public void SetImages(int index, ITexture[] images)
+        {
+            _renderer.New<ImageArraySetImagesCommand>().Set(Ref(this), index, Ref(images));
+            _renderer.QueueCommand();
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedTexture.cs

@@ -1,6 +1,6 @@
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Texture;
 using Ryujinx.Graphics.GAL.Multithreading.Model;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.GAL.Multithreading.Resources
 {
@@ -110,21 +110,24 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             _renderer.QueueCommand();
         }
 
-        public void SetData(SpanOrArray<byte> data)
+        /// <inheritdoc/>
+        public void SetData(IMemoryOwner<byte> data)
         {
-            _renderer.New<TextureSetDataCommand>().Set(Ref(this), Ref(data.ToArray()));
+            _renderer.New<TextureSetDataCommand>().Set(Ref(this), Ref(data));
             _renderer.QueueCommand();
         }
 
-        public void SetData(SpanOrArray<byte> data, int layer, int level)
+        /// <inheritdoc/>
+        public void SetData(IMemoryOwner<byte> data, int layer, int level)
         {
-            _renderer.New<TextureSetDataSliceCommand>().Set(Ref(this), Ref(data.ToArray()), layer, level);
+            _renderer.New<TextureSetDataSliceCommand>().Set(Ref(this), Ref(data), layer, level);
             _renderer.QueueCommand();
         }
 
-        public void SetData(SpanOrArray<byte> data, int layer, int level, Rectangle<int> region)
+        /// <inheritdoc/>
+        public void SetData(IMemoryOwner<byte> data, int layer, int level, Rectangle<int> region)
         {
-            _renderer.New<TextureSetDataSliceRegionCommand>().Set(Ref(this), Ref(data.ToArray()), layer, level, region);
+            _renderer.New<TextureSetDataSliceRegionCommand>().Set(Ref(this), Ref(data), layer, level, region);
             _renderer.QueueCommand();
         }
 

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedTextureArray.cs

@@ -0,0 +1,37 @@
+using Ryujinx.Graphics.GAL.Multithreading.Commands.TextureArray;
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using System.Linq;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Resources
+{
+    /// <summary>
+    /// Threaded representation of a texture and sampler array.
+    /// </summary>
+    class ThreadedTextureArray : ITextureArray
+    {
+        private readonly ThreadedRenderer _renderer;
+        public ITextureArray Base;
+
+        public ThreadedTextureArray(ThreadedRenderer renderer)
+        {
+            _renderer = renderer;
+        }
+
+        private TableRef<T> Ref<T>(T reference)
+        {
+            return new TableRef<T>(_renderer, reference);
+        }
+
+        public void SetSamplers(int index, ISampler[] samplers)
+        {
+            _renderer.New<TextureArraySetSamplersCommand>().Set(Ref(this), index, Ref(samplers.ToArray()));
+            _renderer.QueueCommand();
+        }
+
+        public void SetTextures(int index, ITexture[] textures)
+        {
+            _renderer.New<TextureArraySetTexturesCommand>().Set(Ref(this), index, Ref(textures.ToArray()));
+            _renderer.QueueCommand();
+        }
+    }
+}

src/Ryujinx.Graphics.GAL/Multithreading/ThreadedPipeline.cs

@@ -183,6 +183,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
+        public void SetImageArray(ShaderStage stage, int binding, IImageArray array)
+        {
+            _renderer.New<SetImageArrayCommand>().Set(stage, binding, Ref(array));
+            _renderer.QueueCommand();
+        }
+
         public void SetIndexBuffer(BufferRange buffer, IndexType type)
         {
             _renderer.New<SetIndexBufferCommand>().Set(buffer, type);
@@ -285,6 +291,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
+        public void SetTextureArray(ShaderStage stage, int binding, ITextureArray array)
+        {
+            _renderer.New<SetTextureArrayCommand>().Set(stage, binding, Ref(array));
+            _renderer.QueueCommand();
+        }
+
         public void SetTransformFeedbackBuffers(ReadOnlySpan<BufferRange> buffers)
         {
             _renderer.New<SetTransformFeedbackBuffersCommand>().Set(_renderer.CopySpan(buffers));

src/Ryujinx.Graphics.GAL/Multithreading/ThreadedRenderer.cs

@@ -299,6 +299,15 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             return handle;
         }
 
+        public IImageArray CreateImageArray(int size, bool isBuffer)
+        {
+            var imageArray = new ThreadedImageArray(this);
+            New<CreateImageArrayCommand>().Set(Ref(imageArray), size, isBuffer);
+            QueueCommand();
+
+            return imageArray;
+        }
+
         public IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info)
         {
             var program = new ThreadedProgram(this);
@@ -349,6 +358,14 @@ namespace Ryujinx.Graphics.GAL.Multithreading
                 return texture;
             }
         }
+        public ITextureArray CreateTextureArray(int size, bool isBuffer)
+        {
+            var textureArray = new ThreadedTextureArray(this);
+            New<CreateTextureArrayCommand>().Set(Ref(textureArray), size, isBuffer);
+            QueueCommand();
+
+            return textureArray;
+        }
 
         public void DeleteBuffer(BufferHandle buffer)
         {

src/Ryujinx.Graphics.GAL/ResourceLayout.cs

@@ -71,19 +71,21 @@ namespace Ryujinx.Graphics.GAL
     public readonly struct ResourceUsage : IEquatable<ResourceUsage>
     {
         public int Binding { get; }
+        public int ArrayLength { get; }
         public ResourceType Type { get; }
         public ResourceStages Stages { get; }
 
-        public ResourceUsage(int binding, ResourceType type, ResourceStages stages)
+        public ResourceUsage(int binding, int arrayLength, ResourceType type, ResourceStages stages)
         {
             Binding = binding;
+            ArrayLength = arrayLength;
             Type = type;
             Stages = stages;
         }
 
         public override int GetHashCode()
         {
-            return HashCode.Combine(Binding, Type, Stages);
+            return HashCode.Combine(Binding, ArrayLength, Type, Stages);
         }
 
         public override bool Equals(object obj)
@@ -93,7 +95,7 @@ namespace Ryujinx.Graphics.GAL
 
         public bool Equals(ResourceUsage other)
         {
-            return Binding == other.Binding && Type == other.Type && Stages == other.Stages;
+            return Binding == other.Binding && ArrayLength == other.ArrayLength && Type == other.Type && Stages == other.Stages;
         }
 
         public static bool operator ==(ResourceUsage left, ResourceUsage right)

src/Ryujinx.Graphics.Gpu/Constants.cs

@@ -89,5 +89,10 @@ namespace Ryujinx.Graphics.Gpu
         /// Maximum size that an storage buffer is assumed to have when the correct size is unknown.
         /// </summary>
         public const ulong MaxUnknownStorageSize = 0x100000;
+
+        /// <summary>
+        /// Size of a bindless texture handle as exposed by guest graphics APIs.
+        /// </summary>
+        public const int TextureHandleSizeInBytes = sizeof(ulong);
     }
 }

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

@@ -126,6 +126,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
             ulong samplerPoolGpuVa = ((ulong)_state.State.SetTexSamplerPoolAOffsetUpper << 32) | _state.State.SetTexSamplerPoolB;
             ulong texturePoolGpuVa = ((ulong)_state.State.SetTexHeaderPoolAOffsetUpper << 32) | _state.State.SetTexHeaderPoolB;
 
+            int samplerPoolMaximumId = _state.State.SetTexSamplerPoolCMaximumIndex;
+
             GpuChannelPoolState poolState = new(
                 texturePoolGpuVa,
                 _state.State.SetTexHeaderPoolCMaximumIndex,
@@ -139,7 +141,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
                 sharedMemorySize,
                 _channel.BufferManager.HasUnalignedStorageBuffers);
 
-            CachedShaderProgram cs = memoryManager.Physical.ShaderCache.GetComputeShader(_channel, poolState, computeState, shaderGpuVa);
+            CachedShaderProgram cs = memoryManager.Physical.ShaderCache.GetComputeShader(_channel, samplerPoolMaximumId, poolState, computeState, shaderGpuVa);
 
             _context.Renderer.Pipeline.SetProgram(cs.HostProgram);
 
@@ -184,7 +186,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
                     sharedMemorySize,
                     _channel.BufferManager.HasUnalignedStorageBuffers);
 
-                cs = memoryManager.Physical.ShaderCache.GetComputeShader(_channel, poolState, computeState, shaderGpuVa);
+                cs = memoryManager.Physical.ShaderCache.GetComputeShader(_channel, samplerPoolMaximumId, poolState, computeState, shaderGpuVa);
 
                 _context.Renderer.Pipeline.SetProgram(cs.HostProgram);
             }

src/Ryujinx.Graphics.Gpu/Engine/Dma/DmaClass.cs

@@ -4,6 +4,7 @@ using Ryujinx.Graphics.Gpu.Engine.Threed;
 using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Texture;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -308,7 +309,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Dma
 
                     if (target != null)
                     {
-                        byte[] data;
+                        IMemoryOwner<byte> data;
                         if (srcLinear)
                         {
                             data = LayoutConverter.ConvertLinearStridedToLinear(

src/Ryujinx.Graphics.Gpu/Engine/GPFifo/GPFifoClass.cs

@@ -157,6 +157,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
             }
             else if (operation == SyncpointbOperation.Incr)
             {
+                // "Unbind" render targets since a syncpoint increment might indicate future CPU access for the textures.
+                _parent.TextureManager.RefreshModifiedTextures();
+
                 _context.CreateHostSyncIfNeeded(HostSyncFlags.StrictSyncpoint);
                 _context.Synchronization.IncrementSyncpoint(syncpointId);
             }

src/Ryujinx.Graphics.Gpu/Engine/GPFifo/GPFifoProcessor.cs

@@ -4,6 +4,7 @@ using Ryujinx.Graphics.Gpu.Engine.Dma;
 using Ryujinx.Graphics.Gpu.Engine.InlineToMemory;
 using Ryujinx.Graphics.Gpu.Engine.Threed;
 using Ryujinx.Graphics.Gpu.Engine.Twod;
+using Ryujinx.Graphics.Gpu.Image;
 using Ryujinx.Graphics.Gpu.Memory;
 using System;
 using System.Runtime.CompilerServices;
@@ -28,6 +29,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
         /// </summary>
         public MemoryManager MemoryManager => _channel.MemoryManager;
 
+        /// <summary>
+        /// Channel texture manager.
+        /// </summary>
+        public TextureManager TextureManager => _channel.TextureManager;
+
         /// <summary>
         /// 3D Engine.
         /// </summary>

src/Ryujinx.Graphics.Gpu/Engine/InlineToMemory/InlineToMemoryClass.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common;
+using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Device;
 using Ryujinx.Graphics.Texture;
 using System;
@@ -198,7 +199,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.InlineToMemory
                     if (target != null)
                     {
                         target.SynchronizeMemory();
-                        target.SetData(data, 0, 0, new GAL.Rectangle<int>(_dstX, _dstY, _lineLengthIn / target.Info.FormatInfo.BytesPerPixel, _lineCount));
+                        var dataCopy = ByteMemoryPool.RentCopy(data);
+                        target.SetData(dataCopy, 0, 0, new GAL.Rectangle<int>(_dstX, _dstY, _lineLengthIn / target.Info.FormatInfo.BytesPerPixel, _lineCount));
                         target.SignalModified();
 
                         return;

src/Ryujinx.Graphics.Gpu/Engine/ShaderTexture.cs

@@ -16,7 +16,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
         /// <returns>Texture target value</returns>
         public static Target GetTarget(SamplerType type)
         {
-            type &= ~(SamplerType.Indexed | SamplerType.Shadow);
+            type &= ~SamplerType.Shadow;
 
             switch (type)
             {

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

@@ -1429,7 +1429,18 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 addressesSpan[index] = baseAddress + shader.Offset;
             }
 
-            CachedShaderProgram gs = shaderCache.GetGraphicsShader(ref _state.State, ref _pipeline, _channel, ref _currentSpecState.GetPoolState(), ref _currentSpecState.GetGraphicsState(), addresses);
+            int samplerPoolMaximumId = _state.State.SamplerIndex == SamplerIndex.ViaHeaderIndex
+                ? _state.State.TexturePoolState.MaximumId
+                : _state.State.SamplerPoolState.MaximumId;
+
+            CachedShaderProgram gs = shaderCache.GetGraphicsShader(
+                ref _state.State,
+                ref _pipeline,
+                _channel,
+                samplerPoolMaximumId,
+                ref _currentSpecState.GetPoolState(),
+                ref _currentSpecState.GetGraphicsState(),
+                addresses);
 
             // Consume the modified flag for spec state so that it isn't checked again.
             _currentSpecState.SetShader(gs);

src/Ryujinx.Graphics.Gpu/Image/AutoDeleteCache.cs

@@ -107,8 +107,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 if (texture.CacheNode != _textures.Last)
                 {
                     _textures.Remove(texture.CacheNode);
-
-                    texture.CacheNode = _textures.AddLast(texture);
+                    _textures.AddLast(texture.CacheNode);
                 }
 
                 if (_totalSize > MaxTextureSizeCapacity && _textures.Count >= MinCountForDeletion)

src/Ryujinx.Graphics.Gpu/Image/Pool.cs

@@ -111,6 +111,21 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <returns>The GPU resource with the given ID</returns>
         public abstract T1 Get(int id);
 
+        /// <summary>
+        /// Gets the cached item with the given ID, or null if there is no cached item for the specified ID.
+        /// </summary>
+        /// <param name="id">ID of the item. This is effectively a zero-based index</param>
+        /// <returns>The cached item with the given ID</returns>
+        public T1 GetCachedItem(int id)
+        {
+            if (!IsValidId(id))
+            {
+                return default;
+            }
+
+            return Items[id];
+        }
+
         /// <summary>
         /// Checks if a given ID is valid and inside the range of the pool.
         /// </summary>
@@ -197,6 +212,23 @@ namespace Ryujinx.Graphics.Gpu.Image
             return false;
         }
 
+        /// <summary>
+        /// Checks if the pool was modified by comparing the current <seealso cref="ModifiedSequenceNumber"/> with a cached one.
+        /// </summary>
+        /// <param name="sequenceNumber">Cached modified sequence number</param>
+        /// <returns>True if the pool was modified, false otherwise</returns>
+        public bool WasModified(ref int sequenceNumber)
+        {
+            if (sequenceNumber != ModifiedSequenceNumber)
+            {
+                sequenceNumber = ModifiedSequenceNumber;
+
+                return true;
+            }
+
+            return false;
+        }
+
         protected abstract void InvalidateRangeImpl(ulong address, ulong size);
 
         protected abstract void Delete(T1 item);

src/Ryujinx.Graphics.Gpu/Image/PoolCache.cs

@@ -62,8 +62,9 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="channel">GPU channel that the texture pool cache belongs to</param>
         /// <param name="address">Start address of the texture pool</param>
         /// <param name="maximumId">Maximum ID of the texture pool</param>
+        /// <param name="bindingsArrayCache">Cache of texture array bindings</param>
         /// <returns>The found or newly created texture pool</returns>
-        public T FindOrCreate(GpuChannel channel, ulong address, int maximumId)
+        public T FindOrCreate(GpuChannel channel, ulong address, int maximumId, TextureBindingsArrayCache bindingsArrayCache)
         {
             // Remove old entries from the cache, if possible.
             while (_pools.Count > MaxCapacity && (_currentTimestamp - _pools.First.Value.CacheTimestamp) >= MinDeltaForRemoval)
@@ -73,6 +74,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 _pools.RemoveFirst();
                 oldestPool.Dispose();
                 oldestPool.CacheNode = null;
+                bindingsArrayCache.RemoveAllWithPool(oldestPool);
             }
 
             T pool;
@@ -87,8 +89,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                     if (pool.CacheNode != _pools.Last)
                     {
                         _pools.Remove(pool.CacheNode);
-
-                        pool.CacheNode = _pools.AddLast(pool);
+                        _pools.AddLast(pool.CacheNode);
                     }
 
                     pool.CacheTimestamp = _currentTimestamp;

src/Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -1,5 +1,4 @@
 using Ryujinx.Common.Logging;
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Texture;
@@ -7,6 +6,7 @@ using Ryujinx.Graphics.Texture.Astc;
 using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -661,7 +661,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 }
             }
 
-            SpanOrArray<byte> result = ConvertToHostCompatibleFormat(data);
+            IMemoryOwner<byte> result = ConvertToHostCompatibleFormat(data);
 
             if (ScaleFactor != 1f && AllowScaledSetData())
             {
@@ -684,7 +684,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// Uploads new texture data to the host GPU.
         /// </summary>
         /// <param name="data">New data</param>
-        public void SetData(SpanOrArray<byte> data)
+        public void SetData(IMemoryOwner<byte> data)
         {
             BlacklistScale();
 
@@ -703,7 +703,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="data">New data</param>
         /// <param name="layer">Target layer</param>
         /// <param name="level">Target level</param>
-        public void SetData(SpanOrArray<byte> data, int layer, int level)
+        public void SetData(IMemoryOwner<byte> data, int layer, int level)
         {
             BlacklistScale();
 
@@ -721,7 +721,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="layer">Target layer</param>
         /// <param name="level">Target level</param>
         /// <param name="region">Target sub-region of the texture to update</param>
-        public void SetData(ReadOnlySpan<byte> data, int layer, int level, Rectangle<int> region)
+        public void SetData(IMemoryOwner<byte> data, int layer, int level, Rectangle<int> region)
         {
             BlacklistScale();
 
@@ -739,7 +739,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="level">Mip level to convert</param>
         /// <param name="single">True to convert a single slice</param>
         /// <returns>Converted data</returns>
-        public SpanOrArray<byte> ConvertToHostCompatibleFormat(ReadOnlySpan<byte> data, int level = 0, bool single = false)
+        public IMemoryOwner<byte> ConvertToHostCompatibleFormat(ReadOnlySpan<byte> data, int level = 0, bool single = false)
         {
             int width = Info.Width;
             int height = Info.Height;
@@ -754,11 +754,11 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             int sliceDepth = single ? 1 : depth;
 
-            SpanOrArray<byte> result;
+            IMemoryOwner<byte> linear;
 
             if (Info.IsLinear)
             {
-                result = LayoutConverter.ConvertLinearStridedToLinear(
+                linear = LayoutConverter.ConvertLinearStridedToLinear(
                     width,
                     height,
                     Info.FormatInfo.BlockWidth,
@@ -770,7 +770,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
             else
             {
-                result = LayoutConverter.ConvertBlockLinearToLinear(
+                linear = LayoutConverter.ConvertBlockLinearToLinear(
                     width,
                     height,
                     depth,
@@ -787,33 +787,41 @@ namespace Ryujinx.Graphics.Gpu.Image
                     data);
             }
 
+            IMemoryOwner<byte> result = linear;
+
             // Handle compressed cases not supported by the host:
             // - ASTC is usually not supported on desktop cards.
             // - BC4/BC5 is not supported on 3D textures.
             if (!_context.Capabilities.SupportsAstcCompression && Format.IsAstc())
             {
-                if (!AstcDecoder.TryDecodeToRgba8P(
-                    result.ToArray(),
-                    Info.FormatInfo.BlockWidth,
-                    Info.FormatInfo.BlockHeight,
-                    width,
-                    height,
-                    sliceDepth,
-                    levels,
-                    layers,
-                    out byte[] decoded))
+                using (result)
                 {
-                    string texInfo = $"{Info.Target} {Info.FormatInfo.Format} {Info.Width}x{Info.Height}x{Info.DepthOrLayers} levels {Info.Levels}";
+                    if (!AstcDecoder.TryDecodeToRgba8P(
+                        result.Memory,
+                        Info.FormatInfo.BlockWidth,
+                        Info.FormatInfo.BlockHeight,
+                        width,
+                        height,
+                        sliceDepth,
+                        levels,
+                        layers,
+                        out IMemoryOwner<byte> decoded))
+                    {
+                        string texInfo = $"{Info.Target} {Info.FormatInfo.Format} {Info.Width}x{Info.Height}x{Info.DepthOrLayers} levels {Info.Levels}";
 
-                    Logger.Debug?.Print(LogClass.Gpu, $"Invalid ASTC texture at 0x{Info.GpuAddress:X} ({texInfo}).");
+                        Logger.Debug?.Print(LogClass.Gpu, $"Invalid ASTC texture at 0x{Info.GpuAddress:X} ({texInfo}).");
+                    }
+
+                    if (GraphicsConfig.EnableTextureRecompression)
+                    {
+                        using (decoded)
+                        {
+                            return BCnEncoder.EncodeBC7(decoded.Memory, width, height, sliceDepth, levels, layers);
+                        }
+                    }
+
+                    return decoded;
                 }
-
-                if (GraphicsConfig.EnableTextureRecompression)
-                {
-                    decoded = BCnEncoder.EncodeBC7(decoded, width, height, sliceDepth, levels, layers);
-                }
-
-                result = decoded;
             }
             else if (!_context.Capabilities.SupportsEtc2Compression && Format.IsEtc2())
             {
@@ -821,16 +829,22 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     case Format.Etc2RgbaSrgb:
                     case Format.Etc2RgbaUnorm:
-                        result = ETC2Decoder.DecodeRgba(result, width, height, sliceDepth, levels, layers);
-                        break;
+                        using (result)
+                        {
+                            return ETC2Decoder.DecodeRgba(result.Memory.Span, width, height, sliceDepth, levels, layers);
+                        }
                     case Format.Etc2RgbPtaSrgb:
                     case Format.Etc2RgbPtaUnorm:
-                        result = ETC2Decoder.DecodePta(result, width, height, sliceDepth, levels, layers);
-                        break;
+                        using (result)
+                        {
+                            return ETC2Decoder.DecodePta(result.Memory.Span, width, height, sliceDepth, levels, layers);
+                        }
                     case Format.Etc2RgbSrgb:
                     case Format.Etc2RgbUnorm:
-                        result = ETC2Decoder.DecodeRgb(result, width, height, sliceDepth, levels, layers);
-                        break;
+                        using (result)
+                        {
+                            return ETC2Decoder.DecodeRgb(result.Memory.Span, width, height, sliceDepth, levels, layers);
+                        }
                 }
             }
             else if (!TextureCompatibility.HostSupportsBcFormat(Format, Target, _context.Capabilities))
@@ -839,48 +853,75 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     case Format.Bc1RgbaSrgb:
                     case Format.Bc1RgbaUnorm:
-                        result = BCnDecoder.DecodeBC1(result, width, height, sliceDepth, levels, layers);
-                        break;
+                        using (result)
+                        {
+                            return BCnDecoder.DecodeBC1(result.Memory.Span, width, height, sliceDepth, levels, layers);
+                        }
                     case Format.Bc2Srgb:
                     case Format.Bc2Unorm:
-                        result = BCnDecoder.DecodeBC2(result, width, height, sliceDepth, levels, layers);
-                        break;
+                        using (result)
+                        {
+                            return BCnDecoder.DecodeBC2(result.Memory.Span, width, height, sliceDepth, levels, layers);
+                        }
                     case Format.Bc3Srgb:
                     case Format.Bc3Unorm:
-                        result = BCnDecoder.DecodeBC3(result, width, height, sliceDepth, levels, layers);
-                        break;
+                        using (result)
+                        {
+                            return BCnDecoder.DecodeBC3(result.Memory.Span, width, height, sliceDepth, levels, layers);
+                        }
                     case Format.Bc4Snorm:
                     case Format.Bc4Unorm:
-                        result = BCnDecoder.DecodeBC4(result, width, height, sliceDepth, levels, layers, Format == Format.Bc4Snorm);
-                        break;
+                        using (result)
+                        {
+                            return BCnDecoder.DecodeBC4(result.Memory.Span, width, height, sliceDepth, levels, layers, Format == Format.Bc4Snorm);
+                        }
                     case Format.Bc5Snorm:
                     case Format.Bc5Unorm:
-                        result = BCnDecoder.DecodeBC5(result, width, height, sliceDepth, levels, layers, Format == Format.Bc5Snorm);
-                        break;
+                        using (result)
+                        {
+                            return BCnDecoder.DecodeBC5(result.Memory.Span, width, height, sliceDepth, levels, layers, Format == Format.Bc5Snorm);
+                        }
                     case Format.Bc6HSfloat:
                     case Format.Bc6HUfloat:
-                        result = BCnDecoder.DecodeBC6(result, width, height, sliceDepth, levels, layers, Format == Format.Bc6HSfloat);
-                        break;
+                        using (result)
+                        {
+                            return BCnDecoder.DecodeBC6(result.Memory.Span, width, height, sliceDepth, levels, layers, Format == Format.Bc6HSfloat);
+                        }
                     case Format.Bc7Srgb:
                     case Format.Bc7Unorm:
-                        result = BCnDecoder.DecodeBC7(result, width, height, sliceDepth, levels, layers);
-                        break;
+                        using (result)
+                        {
+                            return BCnDecoder.DecodeBC7(result.Memory.Span, width, height, sliceDepth, levels, layers);
+                        }
                 }
             }
             else if (!_context.Capabilities.SupportsR4G4Format && Format == Format.R4G4Unorm)
             {
-                result = PixelConverter.ConvertR4G4ToR4G4B4A4(result, width);
-
-                if (!_context.Capabilities.SupportsR4G4B4A4Format)
+                using (result)
                 {
-                    result = PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result, width);
+                    var converted = PixelConverter.ConvertR4G4ToR4G4B4A4(result.Memory.Span, width);
+
+                    if (_context.Capabilities.SupportsR4G4B4A4Format)
+                    {
+                        return converted;
+                    }
+                    else
+                    {
+                        using (converted)
+                        {
+                            return PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(converted.Memory.Span, width);
+                        }
+                    }
                 }
             }
             else if (Format == Format.R4G4B4A4Unorm)
             {
                 if (!_context.Capabilities.SupportsR4G4B4A4Format)
                 {
-                    result = PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result, width);
+                    using (result)
+                    {
+                        return PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result.Memory.Span, width);
+                    }
                 }
             }
             else if (!_context.Capabilities.Supports5BitComponentFormat && Format.Is16BitPacked())
@@ -889,19 +930,27 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     case Format.B5G6R5Unorm:
                     case Format.R5G6B5Unorm:
-                        result = PixelConverter.ConvertR5G6B5ToR8G8B8A8(result, width);
-                        break;
+                        using (result)
+                        {
+                            return PixelConverter.ConvertR5G6B5ToR8G8B8A8(result.Memory.Span, width);
+                        }
                     case Format.B5G5R5A1Unorm:
                     case Format.R5G5B5X1Unorm:
                     case Format.R5G5B5A1Unorm:
-                        result = PixelConverter.ConvertR5G5B5ToR8G8B8A8(result, width, Format == Format.R5G5B5X1Unorm);
-                        break;
+                        using (result)
+                        {
+                            return PixelConverter.ConvertR5G5B5ToR8G8B8A8(result.Memory.Span, width, Format == Format.R5G5B5X1Unorm);
+                        }
                     case Format.A1B5G5R5Unorm:
-                        result = PixelConverter.ConvertA1B5G5R5ToR8G8B8A8(result, width);
-                        break;
+                        using (result)
+                        {
+                            return PixelConverter.ConvertA1B5G5R5ToR8G8B8A8(result.Memory.Span, width);
+                        }
                     case Format.R4G4B4A4Unorm:
-                        result = PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result, width);
-                        break;
+                        using (result)
+                        {
+                            return PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result.Memory.Span, width);
+                        }
                 }
             }
 

src/Ryujinx.Graphics.Gpu/Image/TextureBindingInfo.cs

@@ -24,6 +24,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         public int Binding { get; }
 
+        /// <summary>
+        /// For array of textures, this indicates the length of the array. A value of one indicates it is not an array.
+        /// </summary>
+        public int ArrayLength { get; }
+
         /// <summary>
         /// Constant buffer slot with the texture handle.
         /// </summary>
@@ -39,20 +44,27 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         public TextureUsageFlags Flags { get; }
 
+        /// <summary>
+        /// Indicates that the binding is for a sampler.
+        /// </summary>
+        public bool IsSamplerOnly { get; }
+
         /// <summary>
         /// Constructs the texture binding information structure.
         /// </summary>
         /// <param name="target">The shader sampler target type</param>
         /// <param name="format">Format of the image as declared on the shader</param>
         /// <param name="binding">The shader texture binding point</param>
+        /// <param name="arrayLength">For array of textures, this indicates the length of the array. A value of one indicates it is not an array</param>
         /// <param name="cbufSlot">Constant buffer slot where the texture handle is located</param>
         /// <param name="handle">The shader texture handle (read index into the texture constant buffer)</param>
         /// <param name="flags">The texture's usage flags, indicating how it is used in the shader</param>
-        public TextureBindingInfo(Target target, Format format, int binding, int cbufSlot, int handle, TextureUsageFlags flags)
+        public TextureBindingInfo(Target target, Format format, int binding, int arrayLength, int cbufSlot, int handle, TextureUsageFlags flags)
         {
             Target = target;
             Format = format;
             Binding = binding;
+            ArrayLength = arrayLength;
             CbufSlot = cbufSlot;
             Handle = handle;
             Flags = flags;
@@ -63,11 +75,21 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         /// <param name="target">The shader sampler target type</param>
         /// <param name="binding">The shader texture binding point</param>
+        /// <param name="arrayLength">For array of textures, this indicates the length of the array. A value of one indicates it is not an array</param>
         /// <param name="cbufSlot">Constant buffer slot where the texture handle is located</param>
         /// <param name="handle">The shader texture handle (read index into the texture constant buffer)</param>
         /// <param name="flags">The texture's usage flags, indicating how it is used in the shader</param>
-        public TextureBindingInfo(Target target, int binding, int cbufSlot, int handle, TextureUsageFlags flags) : this(target, (Format)0, binding, cbufSlot, handle, flags)
+        /// <param name="isSamplerOnly">Indicates that the binding is for a sampler</param>
+        public TextureBindingInfo(
+            Target target,
+            int binding,
+            int arrayLength,
+            int cbufSlot,
+            int handle,
+            TextureUsageFlags flags,
+            bool isSamplerOnly) : this(target, 0, binding, arrayLength, cbufSlot, handle, flags)
         {
+            IsSamplerOnly = isSamplerOnly;
         }
     }
 }

src/Ryujinx.Graphics.Gpu/Image/TextureBindingsManager.cs

@@ -34,6 +34,8 @@ namespace Ryujinx.Graphics.Gpu.Image
         private readonly TexturePoolCache _texturePoolCache;
         private readonly SamplerPoolCache _samplerPoolCache;
 
+        private readonly TextureBindingsArrayCache _bindingsArrayCache;
+
         private TexturePool _cachedTexturePool;
         private SamplerPool _cachedSamplerPool;
 
@@ -56,6 +58,8 @@ namespace Ryujinx.Graphics.Gpu.Image
         private TextureState[] _textureState;
         private TextureState[] _imageState;
 
+        private int[] _textureCounts;
+
         private int _texturePoolSequence;
         private int _samplerPoolSequence;
 
@@ -68,12 +72,14 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         /// <param name="context">The GPU context that the texture bindings manager belongs to</param>
         /// <param name="channel">The GPU channel that the texture bindings manager belongs to</param>
+        /// <param name="bindingsArrayCache">Cache of texture array bindings</param>
         /// <param name="texturePoolCache">Texture pools cache used to get texture pools from</param>
         /// <param name="samplerPoolCache">Sampler pools cache used to get sampler pools from</param>
         /// <param name="isCompute">True if the bindings manager is used for the compute engine</param>
         public TextureBindingsManager(
             GpuContext context,
             GpuChannel channel,
+            TextureBindingsArrayCache bindingsArrayCache,
             TexturePoolCache texturePoolCache,
             SamplerPoolCache samplerPoolCache,
             bool isCompute)
@@ -85,6 +91,8 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             _isCompute = isCompute;
 
+            _bindingsArrayCache = bindingsArrayCache;
+
             int stages = isCompute ? 1 : Constants.ShaderStages;
 
             _textureBindings = new TextureBindingInfo[stages][];
@@ -95,9 +103,11 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             for (int stage = 0; stage < stages; stage++)
             {
-                _textureBindings[stage] = new TextureBindingInfo[InitialTextureStateSize];
-                _imageBindings[stage] = new TextureBindingInfo[InitialImageStateSize];
+                _textureBindings[stage] = Array.Empty<TextureBindingInfo>();
+                _imageBindings[stage] = Array.Empty<TextureBindingInfo>();
             }
+
+            _textureCounts = Array.Empty<int>();
         }
 
         /// <summary>
@@ -109,6 +119,8 @@ namespace Ryujinx.Graphics.Gpu.Image
             _textureBindings = bindings.TextureBindings;
             _imageBindings = bindings.ImageBindings;
 
+            _textureCounts = bindings.TextureCounts;
+
             SetMaxBindings(bindings.MaxTextureBinding, bindings.MaxImageBinding);
         }
 
@@ -401,27 +413,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
         }
 
-#pragma warning disable IDE0051 // Remove unused private member
-        /// <summary>
-        /// Counts the total number of texture bindings used by all shader stages.
-        /// </summary>
-        /// <returns>The total amount of textures used</returns>
-        private int GetTextureBindingsCount()
-        {
-            int count = 0;
-
-            foreach (TextureBindingInfo[] textureInfo in _textureBindings)
-            {
-                if (textureInfo != null)
-                {
-                    count += textureInfo.Length;
-                }
-            }
-
-            return count;
-        }
-#pragma warning restore IDE0051
-
         /// <summary>
         /// Ensures that the texture bindings are visible to the host GPU.
         /// Note: this actually performs the binding using the host graphics API.
@@ -465,6 +456,13 @@ namespace Ryujinx.Graphics.Gpu.Image
                 TextureBindingInfo bindingInfo = _textureBindings[stageIndex][index];
                 TextureUsageFlags usageFlags = bindingInfo.Flags;
 
+                if (bindingInfo.ArrayLength > 1)
+                {
+                    _bindingsArrayCache.UpdateTextureArray(texturePool, samplerPool, stage, stageIndex, _textureBufferIndex, _samplerIndex, bindingInfo);
+
+                    continue;
+                }
+
                 (int textureBufferIndex, int samplerBufferIndex) = TextureHandle.UnpackSlots(bindingInfo.CbufSlot, _textureBufferIndex);
 
                 UpdateCachedBuffer(stageIndex, ref cachedTextureBufferIndex, ref cachedSamplerBufferIndex, ref cachedTextureBuffer, ref cachedSamplerBuffer, textureBufferIndex, samplerBufferIndex);
@@ -582,7 +580,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
 
             // Scales for images appear after the texture ones.
-            int baseScaleIndex = _textureBindings[stageIndex].Length;
+            int baseScaleIndex = _textureCounts[stageIndex];
 
             int cachedTextureBufferIndex = -1;
             int cachedSamplerBufferIndex = -1;
@@ -595,6 +593,14 @@ namespace Ryujinx.Graphics.Gpu.Image
             {
                 TextureBindingInfo bindingInfo = _imageBindings[stageIndex][index];
                 TextureUsageFlags usageFlags = bindingInfo.Flags;
+
+                if (bindingInfo.ArrayLength > 1)
+                {
+                    _bindingsArrayCache.UpdateImageArray(pool, stage, stageIndex, _textureBufferIndex, bindingInfo);
+
+                    continue;
+                }
+
                 int scaleIndex = baseScaleIndex + index;
 
                 (int textureBufferIndex, int samplerBufferIndex) = TextureHandle.UnpackSlots(bindingInfo.CbufSlot, _textureBufferIndex);
@@ -620,7 +626,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                     if (isStore)
                     {
-                        cachedTexture?.SignalModified();
+                        cachedTexture.SignalModified();
                     }
 
                     Format format = bindingInfo.Format == 0 ? cachedTexture.Format : bindingInfo.Format;
@@ -728,7 +734,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             ulong poolAddress = _channel.MemoryManager.Translate(poolGpuVa);
 
-            TexturePool texturePool = _texturePoolCache.FindOrCreate(_channel, poolAddress, maximumId);
+            TexturePool texturePool = _texturePoolCache.FindOrCreate(_channel, poolAddress, maximumId, _bindingsArrayCache);
 
             TextureDescriptor descriptor;
 
@@ -766,7 +772,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 ? _channel.BufferManager.GetComputeUniformBufferAddress(textureBufferIndex)
                 : _channel.BufferManager.GetGraphicsUniformBufferAddress(stageIndex, textureBufferIndex);
 
-            int handle = textureBufferAddress != 0
+            int handle = textureBufferAddress != MemoryManager.PteUnmapped
                 ? _channel.MemoryManager.Physical.Read<int>(textureBufferAddress + (uint)textureWordOffset * 4)
                 : 0;
 
@@ -786,7 +792,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                         ? _channel.BufferManager.GetComputeUniformBufferAddress(samplerBufferIndex)
                         : _channel.BufferManager.GetGraphicsUniformBufferAddress(stageIndex, samplerBufferIndex);
 
-                    samplerHandle = samplerBufferAddress != 0
+                    samplerHandle = samplerBufferAddress != MemoryManager.PteUnmapped
                         ? _channel.MemoryManager.Physical.Read<int>(samplerBufferAddress + (uint)samplerWordOffset * 4)
                         : 0;
                 }
@@ -824,7 +830,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 if (poolAddress != MemoryManager.PteUnmapped)
                 {
-                    texturePool = _texturePoolCache.FindOrCreate(_channel, poolAddress, _texturePoolMaximumId);
+                    texturePool = _texturePoolCache.FindOrCreate(_channel, poolAddress, _texturePoolMaximumId, _bindingsArrayCache);
                     _texturePool = texturePool;
                 }
             }
@@ -835,7 +841,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 if (poolAddress != MemoryManager.PteUnmapped)
                 {
-                    samplerPool = _samplerPoolCache.FindOrCreate(_channel, poolAddress, _samplerPoolMaximumId);
+                    samplerPool = _samplerPoolCache.FindOrCreate(_channel, poolAddress, _samplerPoolMaximumId, _bindingsArrayCache);
                     _samplerPool = samplerPool;
                 }
             }

src/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs

@@ -247,6 +247,10 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     return TextureMatchQuality.FormatAlias;
                 }
+                else if (lhs.FormatInfo.Format == Format.D32FloatS8Uint && rhs.FormatInfo.Format == Format.R32G32Float)
+                {
+                    return TextureMatchQuality.FormatAlias;
+                }
             }
 
             return lhs.FormatInfo.Format == rhs.FormatInfo.Format ? TextureMatchQuality.Perfect : TextureMatchQuality.NoMatch;

src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -1,4 +1,3 @@
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Texture;
@@ -6,6 +5,7 @@ using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using Ryujinx.Memory.Tracking;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
@@ -445,7 +445,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                             ReadOnlySpan<byte> data = dataSpan[(offset - spanBase)..];
 
-                            SpanOrArray<byte> result = Storage.ConvertToHostCompatibleFormat(data, info.BaseLevel + level, true);
+                            IMemoryOwner<byte> result = Storage.ConvertToHostCompatibleFormat(data, info.BaseLevel + level, true);
 
                             Storage.SetData(result, info.BaseLayer + layer, info.BaseLevel + level);
                         }

src/Ryujinx.Graphics.Gpu/Image/TextureManager.cs

@@ -15,6 +15,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
         private readonly TextureBindingsManager _cpBindingsManager;
         private readonly TextureBindingsManager _gpBindingsManager;
+        private readonly TextureBindingsArrayCache _bindingsArrayCache;
         private readonly TexturePoolCache _texturePoolCache;
         private readonly SamplerPoolCache _samplerPoolCache;
 
@@ -46,8 +47,9 @@ namespace Ryujinx.Graphics.Gpu.Image
             TexturePoolCache texturePoolCache = new(context);
             SamplerPoolCache samplerPoolCache = new(context);
 
-            _cpBindingsManager = new TextureBindingsManager(context, channel, texturePoolCache, samplerPoolCache, isCompute: true);
-            _gpBindingsManager = new TextureBindingsManager(context, channel, texturePoolCache, samplerPoolCache, isCompute: false);
+            _bindingsArrayCache = new TextureBindingsArrayCache(context, channel);
+            _cpBindingsManager = new TextureBindingsManager(context, channel, _bindingsArrayCache, texturePoolCache, samplerPoolCache, isCompute: true);
+            _gpBindingsManager = new TextureBindingsManager(context, channel, _bindingsArrayCache, texturePoolCache, samplerPoolCache, isCompute: false);
             _texturePoolCache = texturePoolCache;
             _samplerPoolCache = samplerPoolCache;
 
@@ -384,7 +386,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             ulong poolAddress = _channel.MemoryManager.Translate(poolGpuVa);
 
-            TexturePool texturePool = _texturePoolCache.FindOrCreate(_channel, poolAddress, maximumId);
+            TexturePool texturePool = _texturePoolCache.FindOrCreate(_channel, poolAddress, maximumId, _bindingsArrayCache);
 
             return texturePool;
         }

src/Ryujinx.Graphics.Gpu/Memory/BufferBounds.cs

@@ -1,12 +1,13 @@
 using Ryujinx.Graphics.Shader;
 using Ryujinx.Memory.Range;
+using System;
 
 namespace Ryujinx.Graphics.Gpu.Memory
 {
     /// <summary>
     /// Memory range used for buffers.
     /// </summary>
-    readonly struct BufferBounds
+    readonly struct BufferBounds : IEquatable<BufferBounds>
     {
         /// <summary>
         /// Physical memory ranges where the buffer is mapped.
@@ -33,5 +34,25 @@ namespace Ryujinx.Graphics.Gpu.Memory
             Range = range;
             Flags = flags;
         }
+
+        public override bool Equals(object obj)
+        {
+            return obj is BufferBounds bounds && Equals(bounds);
+        }
+
+        public bool Equals(BufferBounds bounds)
+        {
+            return Range == bounds.Range && Flags == bounds.Flags;
+        }
+
+        public bool Equals(ref BufferBounds bounds)
+        {
+            return Range == bounds.Range && Flags == bounds.Flags;
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Range, Flags);
+        }
     }
 }

src/Ryujinx.Graphics.Gpu/Memory/BufferManager.cs

@@ -27,6 +27,8 @@ namespace Ryujinx.Graphics.Gpu.Memory
         private readonly VertexBuffer[] _vertexBuffers;
         private readonly BufferBounds[] _transformFeedbackBuffers;
         private readonly List<BufferTextureBinding> _bufferTextures;
+        private readonly List<BufferTextureArrayBinding<ITextureArray>> _bufferTextureArrays;
+        private readonly List<BufferTextureArrayBinding<IImageArray>> _bufferImageArrays;
         private readonly BufferAssignment[] _ranges;
 
         /// <summary>
@@ -140,11 +142,12 @@ namespace Ryujinx.Graphics.Gpu.Memory
             }
 
             _bufferTextures = new List<BufferTextureBinding>();
+            _bufferTextureArrays = new List<BufferTextureArrayBinding<ITextureArray>>();
+            _bufferImageArrays = new List<BufferTextureArrayBinding<IImageArray>>();
 
             _ranges = new BufferAssignment[Constants.TotalGpUniformBuffers * Constants.ShaderStages];
         }
 
-
         /// <summary>
         /// Sets the memory range with the index buffer data, to be used for subsequent draw calls.
         /// </summary>
@@ -418,6 +421,16 @@ namespace Ryujinx.Graphics.Gpu.Memory
             return _cpUniformBuffers.Buffers[index].Range.GetSubRange(0).Address;
         }
 
+        /// <summary>
+        /// Gets the size of the compute uniform buffer currently bound at the given index.
+        /// </summary>
+        /// <param name="index">Index of the uniform buffer binding</param>
+        /// <returns>The uniform buffer size, or an undefined value if the buffer is not currently bound</returns>
+        public int GetComputeUniformBufferSize(int index)
+        {
+            return (int)_cpUniformBuffers.Buffers[index].Range.GetSubRange(0).Size;
+        }
+
         /// <summary>
         /// Gets the address of the graphics uniform buffer currently bound at the given index.
         /// </summary>
@@ -429,6 +442,17 @@ namespace Ryujinx.Graphics.Gpu.Memory
             return _gpUniformBuffers[stage].Buffers[index].Range.GetSubRange(0).Address;
         }
 
+        /// <summary>
+        /// Gets the size of the graphics uniform buffer currently bound at the given index.
+        /// </summary>
+        /// <param name="stage">Index of the shader stage</param>
+        /// <param name="index">Index of the uniform buffer binding</param>
+        /// <returns>The uniform buffer size, or an undefined value if the buffer is not currently bound</returns>
+        public int GetGraphicsUniformBufferSize(int stage, int index)
+        {
+            return (int)_gpUniformBuffers[stage].Buffers[index].Range.GetSubRange(0).Size;
+        }
+
         /// <summary>
         /// Gets the bounds of the uniform buffer currently bound at the given index.
         /// </summary>
@@ -459,7 +483,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
             BindBuffers(bufferCache, _cpStorageBuffers, isStorage: true);
             BindBuffers(bufferCache, _cpUniformBuffers, isStorage: false);
 
-            CommitBufferTextureBindings();
+            CommitBufferTextureBindings(bufferCache);
 
             // Force rebind after doing compute work.
             Rebind();
@@ -470,14 +494,15 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <summary>
         /// Commit any queued buffer texture bindings.
         /// </summary>
-        private void CommitBufferTextureBindings()
+        /// <param name="bufferCache">Buffer cache</param>
+        private void CommitBufferTextureBindings(BufferCache bufferCache)
         {
             if (_bufferTextures.Count > 0)
             {
                 foreach (var binding in _bufferTextures)
                 {
                     var isStore = binding.BindingInfo.Flags.HasFlag(TextureUsageFlags.ImageStore);
-                    var range = _channel.MemoryManager.Physical.BufferCache.GetBufferRange(binding.Range, isStore);
+                    var range = bufferCache.GetBufferRange(binding.Range, isStore);
                     binding.Texture.SetStorage(range);
 
                     // The texture must be rebound to use the new storage if it was updated.
@@ -494,6 +519,33 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
                 _bufferTextures.Clear();
             }
+
+            if (_bufferTextureArrays.Count > 0 || _bufferImageArrays.Count > 0)
+            {
+                ITexture[] textureArray = new ITexture[1];
+
+                foreach (var binding in _bufferTextureArrays)
+                {
+                    var range = bufferCache.GetBufferRange(binding.Range);
+                    binding.Texture.SetStorage(range);
+
+                    textureArray[0] = binding.Texture;
+                    binding.Array.SetTextures(binding.Index, textureArray);
+                }
+
+                foreach (var binding in _bufferImageArrays)
+                {
+                    var isStore = binding.BindingInfo.Flags.HasFlag(TextureUsageFlags.ImageStore);
+                    var range = bufferCache.GetBufferRange(binding.Range, isStore);
+                    binding.Texture.SetStorage(range);
+
+                    textureArray[0] = binding.Texture;
+                    binding.Array.SetImages(binding.Index, textureArray);
+                }
+
+                _bufferTextureArrays.Clear();
+                _bufferImageArrays.Clear();
+            }
         }
 
         /// <summary>
@@ -676,7 +728,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
                 UpdateBuffers(_gpUniformBuffers);
             }
 
-            CommitBufferTextureBindings();
+            CommitBufferTextureBindings(bufferCache);
 
             _rebind = false;
 
@@ -828,6 +880,50 @@ namespace Ryujinx.Graphics.Gpu.Memory
             _bufferTextures.Add(new BufferTextureBinding(stage, texture, range, bindingInfo, format, isImage));
         }
 
+        /// <summary>
+        /// Sets the buffer storage of a buffer texture array element. This will be bound when the buffer manager commits bindings.
+        /// </summary>
+        /// <param name="array">Texture array where the element will be inserted</param>
+        /// <param name="texture">Buffer texture</param>
+        /// <param name="range">Physical ranges of memory where the buffer texture data is located</param>
+        /// <param name="bindingInfo">Binding info for the buffer texture</param>
+        /// <param name="index">Index of the binding on the array</param>
+        /// <param name="format">Format of the buffer texture</param>
+        public void SetBufferTextureStorage(
+            ITextureArray array,
+            ITexture texture,
+            MultiRange range,
+            TextureBindingInfo bindingInfo,
+            int index,
+            Format format)
+        {
+            _channel.MemoryManager.Physical.BufferCache.CreateBuffer(range);
+
+            _bufferTextureArrays.Add(new BufferTextureArrayBinding<ITextureArray>(array, texture, range, bindingInfo, index, format));
+        }
+
+        /// <summary>
+        /// Sets the buffer storage of a buffer image array element. This will be bound when the buffer manager commits bindings.
+        /// </summary>
+        /// <param name="array">Image array where the element will be inserted</param>
+        /// <param name="texture">Buffer texture</param>
+        /// <param name="range">Physical ranges of memory where the buffer texture data is located</param>
+        /// <param name="bindingInfo">Binding info for the buffer texture</param>
+        /// <param name="index">Index of the binding on the array</param>
+        /// <param name="format">Format of the buffer texture</param>
+        public void SetBufferTextureStorage(
+            IImageArray array,
+            ITexture texture,
+            MultiRange range,
+            TextureBindingInfo bindingInfo,
+            int index,
+            Format format)
+        {
+            _channel.MemoryManager.Physical.BufferCache.CreateBuffer(range);
+
+            _bufferImageArrays.Add(new BufferTextureArrayBinding<IImageArray>(array, texture, range, bindingInfo, index, format));
+        }
+
         /// <summary>
         /// Force all bound textures and images to be rebound the next time CommitBindings is called.
         /// </summary>

src/Ryujinx.Graphics.Gpu/Memory/BufferTextureArrayBinding.cs

@@ -0,0 +1,66 @@
+using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Gpu.Image;
+using Ryujinx.Memory.Range;
+
+namespace Ryujinx.Graphics.Gpu.Memory
+{
+    /// <summary>
+    /// A buffer binding to apply to a buffer texture array element.
+    /// </summary>
+    readonly struct BufferTextureArrayBinding<T>
+    {
+        /// <summary>
+        /// Backend texture or image array.
+        /// </summary>
+        public T Array { get; }
+
+        /// <summary>
+        /// The buffer texture.
+        /// </summary>
+        public ITexture Texture { get; }
+
+        /// <summary>
+        /// Physical ranges of memory where the buffer texture data is located.
+        /// </summary>
+        public MultiRange Range { get; }
+
+        /// <summary>
+        /// The image or sampler binding info for the buffer texture.
+        /// </summary>
+        public TextureBindingInfo BindingInfo { get; }
+
+        /// <summary>
+        /// Index of the binding on the array.
+        /// </summary>
+        public int Index { get; }
+
+        /// <summary>
+        /// The image format for the binding.
+        /// </summary>
+        public Format Format { get; }
+
+        /// <summary>
+        /// Create a new buffer texture binding.
+        /// </summary>
+        /// <param name="texture">Buffer texture</param>
+        /// <param name="range">Physical ranges of memory where the buffer texture data is located</param>
+        /// <param name="bindingInfo">Binding info</param>
+        /// <param name="index">Index of the binding on the array</param>
+        /// <param name="format">Binding format</param>
+        public BufferTextureArrayBinding(
+            T array,
+            ITexture texture,
+            MultiRange range,
+            TextureBindingInfo bindingInfo,
+            int index,
+            Format format)
+        {
+            Array = array;
+            Texture = texture;
+            Range = range;
+            BindingInfo = bindingInfo;
+            Index = index;
+            Format = format;
+        }
+    }
+}

src/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs

@@ -1,6 +1,8 @@
+using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -240,11 +242,11 @@ namespace Ryujinx.Graphics.Gpu.Memory
             }
             else
             {
-                Memory<byte> memory = new byte[size];
+                IMemoryOwner<byte> memoryOwner = ByteMemoryPool.Rent(size);
 
-                GetSpan(va, size).CopyTo(memory.Span);
+                GetSpan(va, size).CopyTo(memoryOwner.Memory.Span);
 
-                return new WritableRegion(this, va, memory, tracked);
+                return new WritableRegion(this, va, memoryOwner, tracked);
             }
         }
 

src/Ryujinx.Graphics.Gpu/Memory/PhysicalMemory.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Memory;
 using Ryujinx.Cpu;
 using Ryujinx.Graphics.Device;
 using Ryujinx.Graphics.Gpu.Image;
@@ -6,6 +7,7 @@ using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using Ryujinx.Memory.Tracking;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -190,7 +192,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
             }
             else
             {
-                Memory<byte> memory = new byte[range.GetSize()];
+                IMemoryOwner<byte> memoryOwner = ByteMemoryPool.Rent(range.GetSize());
+
+                Memory<byte> memory = memoryOwner.Memory;
 
                 int offset = 0;
                 for (int i = 0; i < range.Count; i++)
@@ -204,7 +208,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
                     offset += size;
                 }
 
-                return new WritableRegion(new MultiRangeWritableBlock(range, this), 0, memory, tracked);
+                return new WritableRegion(new MultiRangeWritableBlock(range, this), 0, memoryOwner, tracked);
             }
         }
 

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

@@ -17,6 +17,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
         public BufferDescriptor[][] ConstantBufferBindings { get; }
         public BufferDescriptor[][] StorageBufferBindings { get; }
 
+        public int[] TextureCounts { get; }
+
         public int MaxTextureBinding { get; }
         public int MaxImageBinding { get; }
 
@@ -34,6 +36,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
             ConstantBufferBindings = new BufferDescriptor[stageCount][];
             StorageBufferBindings = new BufferDescriptor[stageCount][];
 
+            TextureCounts = new int[stageCount];
+
             int maxTextureBinding = -1;
             int maxImageBinding = -1;
             int offset = isCompute ? 0 : 1;
@@ -54,18 +58,25 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
                 TextureBindings[i] = stage.Info.Textures.Select(descriptor =>
                 {
-                    Target target = ShaderTexture.GetTarget(descriptor.Type);
+                    Target target = descriptor.Type != SamplerType.None ? ShaderTexture.GetTarget(descriptor.Type) : default;
 
                     var result = new TextureBindingInfo(
                         target,
                         descriptor.Binding,
+                        descriptor.ArrayLength,
                         descriptor.CbufSlot,
                         descriptor.HandleIndex,
-                        descriptor.Flags);
+                        descriptor.Flags,
+                        descriptor.Type == SamplerType.None);
 
-                    if (descriptor.Binding > maxTextureBinding)
+                    if (descriptor.ArrayLength <= 1)
                     {
-                        maxTextureBinding = descriptor.Binding;
+                        if (descriptor.Binding > maxTextureBinding)
+                        {
+                            maxTextureBinding = descriptor.Binding;
+                        }
+
+                        TextureCounts[i]++;
                     }
 
                     return result;
@@ -80,11 +91,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
                         target,
                         format,
                         descriptor.Binding,
+                        descriptor.ArrayLength,
                         descriptor.CbufSlot,
                         descriptor.HandleIndex,
                         descriptor.Flags);
 
-                    if (descriptor.Binding > maxImageBinding)
+                    if (descriptor.ArrayLength <= 1 && descriptor.Binding > maxImageBinding)
                     {
                         maxImageBinding = descriptor.Binding;
                     }

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

@@ -27,6 +27,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         /// <param name="cb1Data">The constant buffer 1 data of the shader</param>
         /// <param name="oldSpecState">Shader specialization state of the cached shader</param>
         /// <param name="newSpecState">Shader specialization state of the recompiled shader</param>
+        /// <param name="counts">Resource counts shared across all shader stages</param>
         /// <param name="stageIndex">Shader stage index</param>
         public DiskCacheGpuAccessor(
             GpuContext context,
@@ -109,11 +110,10 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         }
 
         /// <inheritdoc/>
-        public TextureFormat QueryTextureFormat(int handle, int cbufSlot)
+        /// <exception cref="DiskCacheLoadException">Pool length is not available on the cache</exception>
+        public int QuerySamplerArrayLengthFromPool()
         {
-            _newSpecState.RecordTextureFormat(_stageIndex, handle, cbufSlot);
-            (uint format, bool formatSrgb) = _oldSpecState.GetFormat(_stageIndex, handle, cbufSlot);
-            return ConvertToTextureFormat(format, formatSrgb);
+            return QueryArrayLengthFromPool(isSampler: true);
         }
 
         /// <inheritdoc/>
@@ -123,6 +123,36 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
             return _oldSpecState.GetTextureTarget(_stageIndex, handle, cbufSlot).ConvertSamplerType();
         }
 
+        /// <inheritdoc/>
+        /// <exception cref="DiskCacheLoadException">Constant buffer derived length is not available on the cache</exception>
+        public int QueryTextureArrayLengthFromBuffer(int slot)
+        {
+            if (!_oldSpecState.TextureArrayFromBufferRegistered(_stageIndex, 0, slot))
+            {
+                throw new DiskCacheLoadException(DiskCacheLoadResult.MissingTextureArrayLength);
+            }
+
+            int arrayLength = _oldSpecState.GetTextureArrayFromBufferLength(_stageIndex, 0, slot);
+            _newSpecState.RegisterTextureArrayLengthFromBuffer(_stageIndex, 0, slot, arrayLength);
+
+            return arrayLength;
+        }
+
+        /// <inheritdoc/>
+        /// <exception cref="DiskCacheLoadException">Pool length is not available on the cache</exception>
+        public int QueryTextureArrayLengthFromPool()
+        {
+            return QueryArrayLengthFromPool(isSampler: false);
+        }
+
+        /// <inheritdoc/>
+        public TextureFormat QueryTextureFormat(int handle, int cbufSlot)
+        {
+            _newSpecState.RecordTextureFormat(_stageIndex, handle, cbufSlot);
+            (uint format, bool formatSrgb) = _oldSpecState.GetFormat(_stageIndex, handle, cbufSlot);
+            return ConvertToTextureFormat(format, formatSrgb);
+        }
+
         /// <inheritdoc/>
         public bool QueryTextureCoordNormalized(int handle, int cbufSlot)
         {
@@ -155,6 +185,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         }
 
         /// <inheritdoc/>
+        /// <exception cref="DiskCacheLoadException">Texture information is not available on the cache</exception>
         public void RegisterTexture(int handle, int cbufSlot)
         {
             if (!_oldSpecState.TextureRegistered(_stageIndex, handle, cbufSlot))
@@ -167,5 +198,24 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
             bool coordNormalized = _oldSpecState.GetCoordNormalized(_stageIndex, handle, cbufSlot);
             _newSpecState.RegisterTexture(_stageIndex, handle, cbufSlot, format, formatSrgb, target, coordNormalized);
         }
+
+        /// <summary>
+        /// Gets the cached texture or sampler pool capacity.
+        /// </summary>
+        /// <param name="isSampler">True to get sampler pool length, false for texture pool length</param>
+        /// <returns>Pool length</returns>
+        /// <exception cref="DiskCacheLoadException">Pool length is not available on the cache</exception>
+        private int QueryArrayLengthFromPool(bool isSampler)
+        {
+            if (!_oldSpecState.TextureArrayFromPoolRegistered(isSampler))
+            {
+                throw new DiskCacheLoadException(DiskCacheLoadResult.MissingTextureArrayLength);
+            }
+
+            int arrayLength = _oldSpecState.GetTextureArrayFromPoolLength(isSampler);
+            _newSpecState.RegisterTextureArrayLengthFromPool(isSampler, arrayLength);
+
+            return arrayLength;
+        }
     }
 }

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 = 6462;
+        private const uint CodeGenVersion = 6577;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";

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

@@ -20,6 +20,11 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         /// </summary>
         InvalidCb1DataLength,
 
+        /// <summary>
+        /// The cache is missing the length of a texture array used by the shader.
+        /// </summary>
+        MissingTextureArrayLength,
+
         /// <summary>
         /// The cache is missing the descriptor of a texture used by the shader.
         /// </summary>
@@ -60,6 +65,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
                 DiskCacheLoadResult.Success => "No error.",
                 DiskCacheLoadResult.NoAccess => "Could not access the cache file.",
                 DiskCacheLoadResult.InvalidCb1DataLength => "Constant buffer 1 data length is too low.",
+                DiskCacheLoadResult.MissingTextureArrayLength => "Texture array length missing from the cache file.",
                 DiskCacheLoadResult.MissingTextureDescriptor => "Texture descriptor missing from the cache file.",
                 DiskCacheLoadResult.FileCorruptedGeneric => "The cache file is corrupted.",
                 DiskCacheLoadResult.FileCorruptedInvalidMagic => "Magic check failed, the cache file is corrupted.",

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

@@ -72,6 +72,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         public ReadOnlySpan<ulong> GetCode(ulong address, int minimumSize)
         {
             int size = Math.Max(minimumSize, 0x1000 - (int)(address & 0xfff));
+
             return MemoryMarshal.Cast<byte, ulong>(_channel.MemoryManager.GetSpan(address, size));
         }
 
@@ -119,12 +120,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
             return _state.GraphicsState.HasUnalignedStorageBuffer || _state.ComputeState.HasUnalignedStorageBuffer;
         }
 
-        //// <inheritdoc/>
-        public TextureFormat QueryTextureFormat(int handle, int cbufSlot)
+        /// <inheritdoc/>
+        public int QuerySamplerArrayLengthFromPool()
         {
-            _state.SpecializationState?.RecordTextureFormat(_stageIndex, handle, cbufSlot);
-            var descriptor = GetTextureDescriptor(handle, cbufSlot);
-            return ConvertToTextureFormat(descriptor.UnpackFormat(), descriptor.UnpackSrgb());
+            int length = _state.SamplerPoolMaximumId + 1;
+            _state.SpecializationState?.RegisterTextureArrayLengthFromPool(isSampler: true, length);
+
+            return length;
         }
 
         /// <inheritdoc/>
@@ -134,6 +136,37 @@ namespace Ryujinx.Graphics.Gpu.Shader
             return GetTextureDescriptor(handle, cbufSlot).UnpackTextureTarget().ConvertSamplerType();
         }
 
+        /// <inheritdoc/>
+        public int QueryTextureArrayLengthFromBuffer(int slot)
+        {
+            int size = _compute
+                ? _channel.BufferManager.GetComputeUniformBufferSize(slot)
+                : _channel.BufferManager.GetGraphicsUniformBufferSize(_stageIndex, slot);
+
+            int arrayLength = size / Constants.TextureHandleSizeInBytes;
+
+            _state.SpecializationState?.RegisterTextureArrayLengthFromBuffer(_stageIndex, 0, slot, arrayLength);
+
+            return arrayLength;
+        }
+
+        /// <inheritdoc/>
+        public int QueryTextureArrayLengthFromPool()
+        {
+            int length = _state.PoolState.TexturePoolMaximumId + 1;
+            _state.SpecializationState?.RegisterTextureArrayLengthFromPool(isSampler: false, length);
+
+            return length;
+        }
+
+        //// <inheritdoc/>
+        public TextureFormat QueryTextureFormat(int handle, int cbufSlot)
+        {
+            _state.SpecializationState?.RecordTextureFormat(_stageIndex, handle, cbufSlot);
+            var descriptor = GetTextureDescriptor(handle, cbufSlot);
+            return ConvertToTextureFormat(descriptor.UnpackFormat(), descriptor.UnpackSrgb());
+        }
+
         /// <inheritdoc/>
         public bool QueryTextureCoordNormalized(int handle, int cbufSlot)
         {

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

@@ -20,6 +20,9 @@ namespace Ryujinx.Graphics.Gpu.Shader
         private int _reservedTextures;
         private int _reservedImages;
 
+        private int _staticTexturesCount;
+        private int _staticImagesCount;
+
         /// <summary>
         /// Creates a new GPU accessor.
         /// </summary>
@@ -48,7 +51,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
             _reservedImages = rrc.ReservedImages;
         }
 
-        public int QueryBindingConstantBuffer(int index)
+        public int CreateConstantBufferBinding(int index)
         {
             int binding;
 
@@ -64,7 +67,39 @@ namespace Ryujinx.Graphics.Gpu.Shader
             return binding + _reservedConstantBuffers;
         }
 
-        public int QueryBindingStorageBuffer(int index)
+        public int CreateImageBinding(int count, bool isBuffer)
+        {
+            int binding;
+
+            if (_context.Capabilities.Api == TargetApi.Vulkan)
+            {
+                if (count == 1)
+                {
+                    int index = _staticImagesCount++;
+
+                    if (isBuffer)
+                    {
+                        index += (int)_context.Capabilities.MaximumImagesPerStage;
+                    }
+
+                    binding = GetBindingFromIndex(index, _context.Capabilities.MaximumImagesPerStage * 2, "Image");
+                }
+                else
+                {
+                    binding = (int)GetDynamicBaseIndexDual(_context.Capabilities.MaximumImagesPerStage) + _resourceCounts.ImagesCount++;
+                }
+            }
+            else
+            {
+                binding = _resourceCounts.ImagesCount;
+
+                _resourceCounts.ImagesCount += count;
+            }
+
+            return binding + _reservedImages;
+        }
+
+        public int CreateStorageBufferBinding(int index)
         {
             int binding;
 
@@ -80,48 +115,38 @@ namespace Ryujinx.Graphics.Gpu.Shader
             return binding + _reservedStorageBuffers;
         }
 
-        public int QueryBindingTexture(int index, bool isBuffer)
+        public int CreateTextureBinding(int count, bool isBuffer)
         {
             int binding;
 
             if (_context.Capabilities.Api == TargetApi.Vulkan)
             {
-                if (isBuffer)
+                if (count == 1)
                 {
-                    index += (int)_context.Capabilities.MaximumTexturesPerStage;
-                }
+                    int index = _staticTexturesCount++;
 
-                binding = GetBindingFromIndex(index, _context.Capabilities.MaximumTexturesPerStage * 2, "Texture");
+                    if (isBuffer)
+                    {
+                        index += (int)_context.Capabilities.MaximumTexturesPerStage;
+                    }
+
+                    binding = GetBindingFromIndex(index, _context.Capabilities.MaximumTexturesPerStage * 2, "Texture");
+                }
+                else
+                {
+                    binding = (int)GetDynamicBaseIndexDual(_context.Capabilities.MaximumTexturesPerStage) + _resourceCounts.TexturesCount++;
+                }
             }
             else
             {
-                binding = _resourceCounts.TexturesCount++;
+                binding = _resourceCounts.TexturesCount;
+
+                _resourceCounts.TexturesCount += count;
             }
 
             return binding + _reservedTextures;
         }
 
-        public int QueryBindingImage(int index, bool isBuffer)
-        {
-            int binding;
-
-            if (_context.Capabilities.Api == TargetApi.Vulkan)
-            {
-                if (isBuffer)
-                {
-                    index += (int)_context.Capabilities.MaximumImagesPerStage;
-                }
-
-                binding = GetBindingFromIndex(index, _context.Capabilities.MaximumImagesPerStage * 2, "Image");
-            }
-            else
-            {
-                binding = _resourceCounts.ImagesCount++;
-            }
-
-            return binding + _reservedImages;
-        }
-
         private int GetBindingFromIndex(int index, uint maxPerStage, string resourceName)
         {
             if ((uint)index >= maxPerStage)
@@ -148,6 +173,16 @@ namespace Ryujinx.Graphics.Gpu.Shader
             };
         }
 
+        private static uint GetDynamicBaseIndexDual(uint maxPerStage)
+        {
+            return GetDynamicBaseIndex(maxPerStage) * 2;
+        }
+
+        private static uint GetDynamicBaseIndex(uint maxPerStage)
+        {
+            return maxPerStage * Constants.ShaderStages;
+        }
+
         public int QueryHostGatherBiasPrecision() => _context.Capabilities.GatherBiasPrecision;
 
         public bool QueryHostReducedPrecision() => _context.Capabilities.ReduceShaderPrecision;
@@ -178,6 +213,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
         public bool QueryHostSupportsScaledVertexFormats() => _context.Capabilities.SupportsScaledVertexFormats;
 
+        public bool QueryHostSupportsSeparateSampler() => _context.Capabilities.SupportsSeparateSampler;
+
         public bool QueryHostSupportsShaderBallot() => _context.Capabilities.SupportsShaderBallot;
 
         public bool QueryHostSupportsShaderBarrierDivergence() => _context.Capabilities.SupportsShaderBarrierDivergence;

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

@@ -5,6 +5,11 @@ namespace Ryujinx.Graphics.Gpu.Shader
     /// </summary>
     class GpuAccessorState
     {
+        /// <summary>
+        /// Maximum ID that a sampler pool entry may have.
+        /// </summary>
+        public readonly int SamplerPoolMaximumId;
+
         /// <summary>
         /// GPU texture pool state.
         /// </summary>
@@ -38,18 +43,21 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <summary>
         /// Creates a new GPU accessor state.
         /// </summary>
+        /// <param name="samplerPoolMaximumId">Maximum ID that a sampler pool entry may have</param>
         /// <param name="poolState">GPU texture pool state</param>
         /// <param name="computeState">GPU compute state, for compute shaders</param>
         /// <param name="graphicsState">GPU graphics state, for vertex, tessellation, geometry and fragment shaders</param>
         /// <param name="specializationState">Shader specialization state (shared by all stages)</param>
         /// <param name="transformFeedbackDescriptors">Transform feedback information, if the shader uses transform feedback. Otherwise, should be null</param>
         public GpuAccessorState(
+            int samplerPoolMaximumId,
             GpuChannelPoolState poolState,
             GpuChannelComputeState computeState,
             GpuChannelGraphicsState graphicsState,
             ShaderSpecializationState specializationState,
             TransformFeedbackDescriptor[] transformFeedbackDescriptors = null)
         {
+            SamplerPoolMaximumId = samplerPoolMaximumId;
             PoolState = poolState;
             GraphicsState = graphicsState;
             ComputeState = computeState;

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

@@ -2,7 +2,6 @@ using System;
 
 namespace Ryujinx.Graphics.Gpu.Shader
 {
-#pragma warning disable CS0659 // Class overrides Object.Equals(object o) but does not override Object.GetHashCode()
     /// <summary>
     /// State used by the <see cref="GpuAccessor"/>.
     /// </summary>
@@ -52,6 +51,10 @@ namespace Ryujinx.Graphics.Gpu.Shader
         {
             return obj is GpuChannelPoolState state && Equals(state);
         }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(TexturePoolGpuVa, TexturePoolMaximumId, TextureBufferIndex);
+        }
     }
-#pragma warning restore CS0659
 }

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

@@ -192,12 +192,14 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// This automatically translates, compiles and adds the code to the cache if not present.
         /// </remarks>
         /// <param name="channel">GPU channel</param>
+        /// <param name="samplerPoolMaximumId">Maximum ID that an entry in the sampler pool may have</param>
         /// <param name="poolState">Texture pool state</param>
         /// <param name="computeState">Compute engine state</param>
         /// <param name="gpuVa">GPU virtual address of the binary shader code</param>
         /// <returns>Compiled compute shader code</returns>
         public CachedShaderProgram GetComputeShader(
             GpuChannel channel,
+            int samplerPoolMaximumId,
             GpuChannelPoolState poolState,
             GpuChannelComputeState computeState,
             ulong gpuVa)
@@ -214,7 +216,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
             }
 
             ShaderSpecializationState specState = new(ref computeState);
-            GpuAccessorState gpuAccessorState = new(poolState, computeState, default, specState);
+            GpuAccessorState gpuAccessorState = new(samplerPoolMaximumId, poolState, computeState, default, specState);
             GpuAccessor gpuAccessor = new(_context, channel, gpuAccessorState);
             gpuAccessor.InitializeReservedCounts(tfEnabled: false, vertexAsCompute: false);
 
@@ -291,6 +293,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="state">GPU state</param>
         /// <param name="pipeline">Pipeline state</param>
         /// <param name="channel">GPU channel</param>
+        /// <param name="samplerPoolMaximumId">Maximum ID that an entry in the sampler pool may have</param>
         /// <param name="poolState">Texture pool state</param>
         /// <param name="graphicsState">3D engine state</param>
         /// <param name="addresses">Addresses of the shaders for each stage</param>
@@ -299,6 +302,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
             ref ThreedClassState state,
             ref ProgramPipelineState pipeline,
             GpuChannel channel,
+            int samplerPoolMaximumId,
             ref GpuChannelPoolState poolState,
             ref GpuChannelGraphicsState graphicsState,
             ShaderAddresses addresses)
@@ -319,7 +323,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
             UpdatePipelineInfo(ref state, ref pipeline, graphicsState, channel);
 
             ShaderSpecializationState specState = new(ref graphicsState, ref pipeline, transformFeedbackDescriptors);
-            GpuAccessorState gpuAccessorState = new(poolState, default, graphicsState, specState, transformFeedbackDescriptors);
+            GpuAccessorState gpuAccessorState = new(samplerPoolMaximumId, poolState, default, graphicsState, specState, transformFeedbackDescriptors);
 
             ReadOnlySpan<ulong> addressesSpan = addresses.AsSpan();
 

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

@@ -132,6 +132,9 @@ namespace Ryujinx.Graphics.Gpu.Shader
             AddDualDescriptor(stages, ResourceType.TextureAndSampler, ResourceType.BufferTexture, TextureSetIndex, textureBinding, texturesPerStage);
             AddDualDescriptor(stages, ResourceType.Image, ResourceType.BufferImage, ImageSetIndex, imageBinding, imagesPerStage);
 
+            AddArrayDescriptors(info.Textures, stages, TextureSetIndex, isImage: false);
+            AddArrayDescriptors(info.Images, stages, TextureSetIndex, isImage: true);
+
             AddUsage(info.CBuffers, stages, UniformSetIndex, isStorage: false);
             AddUsage(info.SBuffers, stages, StorageSetIndex, isStorage: true);
             AddUsage(info.Textures, stages, TextureSetIndex, isImage: false);
@@ -169,6 +172,26 @@ namespace Ryujinx.Graphics.Gpu.Shader
             AddDescriptor(stages, type2, setIndex, binding + count, count);
         }
 
+        /// <summary>
+        /// Adds all array descriptors (those with an array length greater than one).
+        /// </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 AddArrayDescriptors(IEnumerable<TextureDescriptor> textures, ResourceStages stages, int setIndex, bool isImage)
+        {
+            foreach (TextureDescriptor texture in textures)
+            {
+                if (texture.ArrayLength > 1)
+                {
+                    ResourceType type = GetTextureResourceType(texture, isImage);
+
+                    _resourceDescriptors[setIndex].Add(new ResourceDescriptor(texture.Binding, texture.ArrayLength, type, stages));
+                }
+            }
+        }
+
         /// <summary>
         /// Adds buffer usage information to the list of usages.
         /// </summary>
@@ -181,7 +204,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         {
             for (int index = 0; index < count; index++)
             {
-                _resourceUsages[setIndex].Add(new ResourceUsage(binding + index, type, stages));
+                _resourceUsages[setIndex].Add(new ResourceUsage(binding + index, 1, type, stages));
             }
         }
 
@@ -198,6 +221,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
             {
                 _resourceUsages[setIndex].Add(new ResourceUsage(
                     buffer.Binding,
+                    1,
                     isStorage ? ResourceType.StorageBuffer : ResourceType.UniformBuffer,
                     stages));
             }
@@ -214,16 +238,35 @@ namespace Ryujinx.Graphics.Gpu.Shader
         {
             foreach (TextureDescriptor texture in textures)
             {
-                bool isBuffer = (texture.Type & SamplerType.Mask) == SamplerType.TextureBuffer;
+                ResourceType type = GetTextureResourceType(texture, isImage);
 
-                ResourceType type = isBuffer
-                    ? (isImage ? ResourceType.BufferImage : ResourceType.BufferTexture)
-                    : (isImage ? ResourceType.Image : ResourceType.TextureAndSampler);
+                _resourceUsages[setIndex].Add(new ResourceUsage(texture.Binding, texture.ArrayLength, type, stages));
+            }
+        }
 
-                _resourceUsages[setIndex].Add(new ResourceUsage(
-                    texture.Binding,
-                    type,
-                    stages));
+        private static ResourceType GetTextureResourceType(TextureDescriptor texture, bool isImage)
+        {
+            bool isBuffer = (texture.Type & SamplerType.Mask) == SamplerType.TextureBuffer;
+
+            if (isBuffer)
+            {
+                return isImage ? ResourceType.BufferImage : ResourceType.BufferTexture;
+            }
+            else if (isImage)
+            {
+                return ResourceType.Image;
+            }
+            else if (texture.Type == SamplerType.None)
+            {
+                return ResourceType.Sampler;
+            }
+            else if (texture.Separate)
+            {
+                return ResourceType.Texture;
+            }
+            else
+            {
+                return ResourceType.TextureAndSampler;
             }
         }
 

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

@@ -30,6 +30,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
         {
             PrimitiveTopology = 1 << 1,
             TransformFeedback = 1 << 3,
+            TextureArrayFromBuffer = 1 << 4,
+            TextureArrayFromPool = 1 << 5,
         }
 
         private QueriedStateFlags _queriedState;
@@ -153,6 +155,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
         }
 
         private readonly Dictionary<TextureKey, Box<TextureSpecializationState>> _textureSpecialization;
+        private readonly Dictionary<TextureKey, int> _textureArrayFromBufferSpecialization;
+        private readonly Dictionary<bool, int> _textureArrayFromPoolSpecialization;
         private KeyValuePair<TextureKey, Box<TextureSpecializationState>>[] _allTextures;
         private Box<TextureSpecializationState>[][] _textureByBinding;
         private Box<TextureSpecializationState>[][] _imageByBinding;
@@ -163,6 +167,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
         private ShaderSpecializationState()
         {
             _textureSpecialization = new Dictionary<TextureKey, Box<TextureSpecializationState>>();
+            _textureArrayFromBufferSpecialization = new Dictionary<TextureKey, int>();
+            _textureArrayFromPoolSpecialization = new Dictionary<bool, int>();
         }
 
         /// <summary>
@@ -323,6 +329,30 @@ namespace Ryujinx.Graphics.Gpu.Shader
             state.Value.CoordNormalized = coordNormalized;
         }
 
+        /// <summary>
+        /// Registers the length of a texture array calculated from a constant buffer size.
+        /// </summary>
+        /// <param name="stageIndex">Shader stage where the texture is used</param>
+        /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
+        /// <param name="cbufSlot">Slot of the texture buffer constant buffer</param>
+        /// <param name="length">Number of elements in the texture array</param>
+        public void RegisterTextureArrayLengthFromBuffer(int stageIndex, int handle, int cbufSlot, int length)
+        {
+            _textureArrayFromBufferSpecialization[new TextureKey(stageIndex, handle, cbufSlot)] = length;
+            _queriedState |= QueriedStateFlags.TextureArrayFromBuffer;
+        }
+
+        /// <summary>
+        /// Registers the length of a texture array calculated from a texture or sampler pool capacity.
+        /// </summary>
+        /// <param name="isSampler">True for sampler pool, false for texture pool</param>
+        /// <param name="length">Number of elements in the texture array</param>
+        public void RegisterTextureArrayLengthFromPool(bool isSampler, int length)
+        {
+            _textureArrayFromPoolSpecialization[isSampler] = length;
+            _queriedState |= QueriedStateFlags.TextureArrayFromPool;
+        }
+
         /// <summary>
         /// Indicates that the format of a given texture was used during the shader translation process.
         /// </summary>
@@ -369,7 +399,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         }
 
         /// <summary>
-        /// Checks if a given texture was registerd on this specialization state.
+        /// Checks if a given texture was registered on this specialization state.
         /// </summary>
         /// <param name="stageIndex">Shader stage where the texture is used</param>
         /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
@@ -379,12 +409,35 @@ namespace Ryujinx.Graphics.Gpu.Shader
             return GetTextureSpecState(stageIndex, handle, cbufSlot) != null;
         }
 
+        /// <summary>
+        /// Checks if a given texture array (from constant buffer) was registered on this specialization state.
+        /// </summary>
+        /// <param name="stageIndex">Shader stage where the texture is used</param>
+        /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
+        /// <param name="cbufSlot">Slot of the texture buffer constant buffer</param>
+        /// <returns>True if the length for the given buffer and stage exists, false otherwise</returns>
+        public bool TextureArrayFromBufferRegistered(int stageIndex, int handle, int cbufSlot)
+        {
+            return _textureArrayFromBufferSpecialization.ContainsKey(new TextureKey(stageIndex, handle, cbufSlot));
+        }
+
+        /// <summary>
+        /// Checks if a given texture array (from a sampler pool or texture pool) was registered on this specialization state.
+        /// </summary>
+        /// <param name="isSampler">True for sampler pool, false for texture pool</param>
+        /// <returns>True if the length for the given pool, false otherwise</returns>
+        public bool TextureArrayFromPoolRegistered(bool isSampler)
+        {
+            return _textureArrayFromPoolSpecialization.ContainsKey(isSampler);
+        }
+
         /// <summary>
         /// Gets the recorded format of a given texture.
         /// </summary>
         /// <param name="stageIndex">Shader stage where the texture is used</param>
         /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
         /// <param name="cbufSlot">Slot of the texture buffer constant buffer</param>
+        /// <returns>Format and sRGB tuple</returns>
         public (uint, bool) GetFormat(int stageIndex, int handle, int cbufSlot)
         {
             TextureSpecializationState state = GetTextureSpecState(stageIndex, handle, cbufSlot).Value;
@@ -397,6 +450,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="stageIndex">Shader stage where the texture is used</param>
         /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
         /// <param name="cbufSlot">Slot of the texture buffer constant buffer</param>
+        /// <returns>Texture target</returns>
         public TextureTarget GetTextureTarget(int stageIndex, int handle, int cbufSlot)
         {
             return GetTextureSpecState(stageIndex, handle, cbufSlot).Value.TextureTarget;
@@ -408,11 +462,34 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="stageIndex">Shader stage where the texture is used</param>
         /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
         /// <param name="cbufSlot">Slot of the texture buffer constant buffer</param>
+        /// <returns>True if coordinates are normalized, false otherwise</returns>
         public bool GetCoordNormalized(int stageIndex, int handle, int cbufSlot)
         {
             return GetTextureSpecState(stageIndex, handle, cbufSlot).Value.CoordNormalized;
         }
 
+        /// <summary>
+        /// Gets the recorded length of a given texture array (from constant buffer).
+        /// </summary>
+        /// <param name="stageIndex">Shader stage where the texture is used</param>
+        /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
+        /// <param name="cbufSlot">Slot of the texture buffer constant buffer</param>
+        /// <returns>Texture array length</returns>
+        public int GetTextureArrayFromBufferLength(int stageIndex, int handle, int cbufSlot)
+        {
+            return _textureArrayFromBufferSpecialization[new TextureKey(stageIndex, handle, cbufSlot)];
+        }
+
+        /// <summary>
+        /// Gets the recorded length of a given texture array (from a sampler or texture pool).
+        /// </summary>
+        /// <param name="isSampler">True to get the sampler pool length, false to get the texture pool length</param>
+        /// <returns>Texture array length</returns>
+        public int GetTextureArrayFromPoolLength(bool isSampler)
+        {
+            return _textureArrayFromPoolSpecialization[isSampler];
+        }
+
         /// <summary>
         /// Gets texture specialization state for a given texture, or create a new one if not present.
         /// </summary>
@@ -548,6 +625,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
             return Matches(channel, ref poolState, checkTextures, isCompute: false);
         }
 
+        /// <summary>
+        /// Converts special vertex attribute groups to their generic equivalents, for comparison purposes.
+        /// </summary>
+        /// <param name="channel">GPU channel</param>
+        /// <param name="type">Vertex attribute type</param>
+        /// <returns>Filtered attribute</returns>
         private static AttributeType FilterAttributeType(GpuChannel channel, AttributeType type)
         {
             type &= ~(AttributeType.Packed | AttributeType.PackedRgb10A2Signed);
@@ -838,6 +921,38 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 specState._textureSpecialization[textureKey] = textureState;
             }
 
+            if (specState._queriedState.HasFlag(QueriedStateFlags.TextureArrayFromBuffer))
+            {
+                dataReader.Read(ref count);
+
+                for (int index = 0; index < count; index++)
+                {
+                    TextureKey textureKey = default;
+                    int length = 0;
+
+                    dataReader.ReadWithMagicAndSize(ref textureKey, TexkMagic);
+                    dataReader.Read(ref length);
+
+                    specState._textureArrayFromBufferSpecialization[textureKey] = length;
+                }
+            }
+
+            if (specState._queriedState.HasFlag(QueriedStateFlags.TextureArrayFromPool))
+            {
+                dataReader.Read(ref count);
+
+                for (int index = 0; index < count; index++)
+                {
+                    bool textureKey = default;
+                    int length = 0;
+
+                    dataReader.ReadWithMagicAndSize(ref textureKey, TexkMagic);
+                    dataReader.Read(ref length);
+
+                    specState._textureArrayFromPoolSpecialization[textureKey] = length;
+                }
+            }
+
             return specState;
         }
 
@@ -902,6 +1017,36 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 dataWriter.WriteWithMagicAndSize(ref textureKey, TexkMagic);
                 dataWriter.WriteWithMagicAndSize(ref textureState.Value, TexsMagic);
             }
+
+            if (_queriedState.HasFlag(QueriedStateFlags.TextureArrayFromBuffer))
+            {
+                count = (ushort)_textureArrayFromBufferSpecialization.Count;
+                dataWriter.Write(ref count);
+
+                foreach (var kv in _textureArrayFromBufferSpecialization)
+                {
+                    var textureKey = kv.Key;
+                    var length = kv.Value;
+
+                    dataWriter.WriteWithMagicAndSize(ref textureKey, TexkMagic);
+                    dataWriter.Write(ref length);
+                }
+            }
+
+            if (_queriedState.HasFlag(QueriedStateFlags.TextureArrayFromPool))
+            {
+                count = (ushort)_textureArrayFromPoolSpecialization.Count;
+                dataWriter.Write(ref count);
+
+                foreach (var kv in _textureArrayFromPoolSpecialization)
+                {
+                    var textureKey = kv.Key;
+                    var length = kv.Value;
+
+                    dataWriter.WriteWithMagicAndSize(ref textureKey, TexkMagic);
+                    dataWriter.Write(ref length);
+                }
+            }
         }
     }
 }

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

@@ -33,7 +33,8 @@ namespace Ryujinx.Graphics.OpenGL.Effects.Smaa
 
         public int Quality
         {
-            get => _quality; set
+            get => _quality;
+            set
             {
                 _quality = Math.Clamp(value, 0, _qualities.Length - 1);
             }
@@ -150,8 +151,8 @@ namespace Ryujinx.Graphics.OpenGL.Effects.Smaa
             _areaTexture = new TextureStorage(_renderer, areaInfo);
             _searchTexture = new TextureStorage(_renderer, searchInfo);
 
-            var areaTexture = EmbeddedResources.Read("Ryujinx.Graphics.OpenGL/Effects/Textures/SmaaAreaTexture.bin");
-            var searchTexture = EmbeddedResources.Read("Ryujinx.Graphics.OpenGL/Effects/Textures/SmaaSearchTexture.bin");
+            var areaTexture = EmbeddedResources.ReadFileToRentedMemory("Ryujinx.Graphics.OpenGL/Effects/Textures/SmaaAreaTexture.bin");
+            var searchTexture = EmbeddedResources.ReadFileToRentedMemory("Ryujinx.Graphics.OpenGL/Effects/Textures/SmaaSearchTexture.bin");
 
             var areaView = _areaTexture.CreateDefaultView();
             var searchView = _searchTexture.CreateDefaultView();

src/Ryujinx.Graphics.OpenGL/Image/FormatConverter.cs

@@ -1,4 +1,6 @@
+using Ryujinx.Common.Memory;
 using System;
+using System.Buffers;
 using System.Numerics;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -8,9 +10,11 @@ namespace Ryujinx.Graphics.OpenGL.Image
 {
     static class FormatConverter
     {
-        public unsafe static byte[] ConvertS8D24ToD24S8(ReadOnlySpan<byte> data)
+        public unsafe static IMemoryOwner<byte> ConvertS8D24ToD24S8(ReadOnlySpan<byte> data)
         {
-            byte[] output = new byte[data.Length];
+            IMemoryOwner<byte> outputMemory = ByteMemoryPool.Rent(data.Length);
+
+            Span<byte> output = outputMemory.Memory.Span;
 
             int start = 0;
 
@@ -74,7 +78,7 @@ namespace Ryujinx.Graphics.OpenGL.Image
                 outSpan[i] = BitOperations.RotateLeft(dataSpan[i], 8);
             }
 
-            return output;
+            return outputMemory;
         }
 
         public unsafe static byte[] ConvertD24S8ToS8D24(ReadOnlySpan<byte> data)

src/Ryujinx.Graphics.OpenGL/Image/ImageArray.cs

@@ -0,0 +1,67 @@
+using OpenTK.Graphics.OpenGL;
+using Ryujinx.Graphics.GAL;
+using System;
+
+namespace Ryujinx.Graphics.OpenGL.Image
+{
+    class ImageArray : IImageArray
+    {
+        private record struct TextureRef
+        {
+            public int Handle;
+            public Format Format;
+        }
+
+        private readonly TextureRef[] _images;
+
+        public ImageArray(int size)
+        {
+            _images = new TextureRef[size];
+        }
+
+        public void SetFormats(int index, GAL.Format[] imageFormats)
+        {
+            for (int i = 0; i < imageFormats.Length; i++)
+            {
+                _images[index + i].Format = imageFormats[i];
+            }
+        }
+
+        public void SetImages(int index, ITexture[] images)
+        {
+            for (int i = 0; i < images.Length; i++)
+            {
+                ITexture image = images[i];
+
+                if (image is TextureBase imageBase)
+                {
+                    _images[index + i].Handle = imageBase.Handle;
+                }
+                else
+                {
+                    _images[index + i].Handle = 0;
+                }
+            }
+        }
+
+        public void Bind(int baseBinding)
+        {
+            for (int i = 0; i < _images.Length; i++)
+            {
+                if (_images[i].Handle == 0)
+                {
+                    GL.BindImageTexture(baseBinding + i, 0, 0, true, 0, TextureAccess.ReadWrite, SizedInternalFormat.Rgba8);
+                }
+                else
+                {
+                    SizedInternalFormat format = FormatTable.GetImageFormat(_images[i].Format);
+
+                    if (format != 0)
+                    {
+                        GL.BindImageTexture(baseBinding + i, _images[i].Handle, 0, true, 0, TextureAccess.ReadWrite, format);
+                    }
+                }
+            }
+        }
+    }
+}

src/Ryujinx.Graphics.OpenGL/Image/TextureArray.cs

@@ -0,0 +1,52 @@
+using Ryujinx.Graphics.GAL;
+
+namespace Ryujinx.Graphics.OpenGL.Image
+{
+    class TextureArray : ITextureArray
+    {
+        private record struct TextureRef
+        {
+            public TextureBase Texture;
+            public Sampler Sampler;
+        }
+
+        private readonly TextureRef[] _textureRefs;
+
+        public TextureArray(int size)
+        {
+            _textureRefs = new TextureRef[size];
+        }
+
+        public void SetSamplers(int index, ISampler[] samplers)
+        {
+            for (int i = 0; i < samplers.Length; i++)
+            {
+                _textureRefs[index + i].Sampler = samplers[i] as Sampler;
+            }
+        }
+
+        public void SetTextures(int index, ITexture[] textures)
+        {
+            for (int i = 0; i < textures.Length; i++)
+            {
+                _textureRefs[index + i].Texture = textures[i] as TextureBase;
+            }
+        }
+
+        public void Bind(int baseBinding)
+        {
+            for (int i = 0; i < _textureRefs.Length; i++)
+            {
+                if (_textureRefs[i].Texture != null)
+                {
+                    _textureRefs[i].Texture.Bind(baseBinding + i);
+                    _textureRefs[i].Sampler?.Bind(baseBinding + i);
+                }
+                else
+                {
+                    TextureBase.ClearBinding(baseBinding + i);
+                }
+            }
+        }
+    }
+}

src/Ryujinx.Graphics.OpenGL/Image/TextureBuffer.cs

@@ -1,7 +1,7 @@
 using OpenTK.Graphics.OpenGL;
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using System;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.OpenGL.Image
 {
@@ -54,19 +54,24 @@ namespace Ryujinx.Graphics.OpenGL.Image
             throw new NotImplementedException();
         }
 
-        public void SetData(SpanOrArray<byte> data)
+        /// <inheritdoc/>
+        public void SetData(IMemoryOwner<byte> data)
         {
-            var dataSpan = data.AsSpan();
+            var dataSpan = data.Memory.Span;
 
             Buffer.SetData(_buffer, _bufferOffset, dataSpan[..Math.Min(dataSpan.Length, _bufferSize)]);
+
+            data.Dispose();
         }
 
-        public void SetData(SpanOrArray<byte> data, int layer, int level)
+        /// <inheritdoc/>
+        public void SetData(IMemoryOwner<byte> data, int layer, int level)
         {
             throw new NotSupportedException();
         }
 
-        public void SetData(SpanOrArray<byte> data, int layer, int level, Rectangle<int> region)
+        /// <inheritdoc/>
+        public void SetData(IMemoryOwner<byte> data, int layer, int level, Rectangle<int> region)
         {
             throw new NotSupportedException();
         }

src/Ryujinx.Graphics.OpenGL/Image/TextureView.cs

@@ -1,8 +1,8 @@
 using OpenTK.Graphics.OpenGL;
 using Ryujinx.Common;
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using System;
+using System.Buffers;
 using System.Diagnostics;
 
 namespace Ryujinx.Graphics.OpenGL.Image
@@ -448,70 +448,59 @@ namespace Ryujinx.Graphics.OpenGL.Image
             }
         }
 
-        public void SetData(SpanOrArray<byte> data)
+        public void SetData(IMemoryOwner<byte> data)
         {
-            var dataSpan = data.AsSpan();
-
-            if (Format == Format.S8UintD24Unorm)
+            using (data = EnsureDataFormat(data))
             {
-                dataSpan = FormatConverter.ConvertS8D24ToD24S8(dataSpan);
-            }
-
-            unsafe
-            {
-                fixed (byte* ptr = dataSpan)
+                unsafe
                 {
-                    ReadFrom((IntPtr)ptr, dataSpan.Length);
+                    var dataSpan = data.Memory.Span;
+                    fixed (byte* ptr = dataSpan)
+                    {
+                        ReadFrom((IntPtr)ptr, dataSpan.Length);
+                    }
                 }
             }
         }
 
-        public void SetData(SpanOrArray<byte> data, int layer, int level)
+        public void SetData(IMemoryOwner<byte> data, int layer, int level)
         {
-            var dataSpan = data.AsSpan();
-
-            if (Format == Format.S8UintD24Unorm)
+            using (data = EnsureDataFormat(data))
             {
-                dataSpan = FormatConverter.ConvertS8D24ToD24S8(dataSpan);
-            }
-
-            unsafe
-            {
-                fixed (byte* ptr = dataSpan)
+                unsafe
                 {
-                    int width = Math.Max(Info.Width >> level, 1);
-                    int height = Math.Max(Info.Height >> level, 1);
+                    fixed (byte* ptr = data.Memory.Span)
+                    {
+                        int width = Math.Max(Info.Width >> level, 1);
+                        int height = Math.Max(Info.Height >> level, 1);
 
-                    ReadFrom2D((IntPtr)ptr, layer, level, 0, 0, width, height);
+                        ReadFrom2D((IntPtr)ptr, layer, level, 0, 0, width, height);
+                    }
                 }
             }
         }
 
-        public void SetData(SpanOrArray<byte> data, int layer, int level, Rectangle<int> region)
+        public void SetData(IMemoryOwner<byte> data, int layer, int level, Rectangle<int> region)
         {
-            var dataSpan = data.AsSpan();
-
-            if (Format == Format.S8UintD24Unorm)
+            using (data = EnsureDataFormat(data))
             {
-                dataSpan = FormatConverter.ConvertS8D24ToD24S8(dataSpan);
-            }
+                int wInBlocks = BitUtils.DivRoundUp(region.Width, Info.BlockWidth);
+                int hInBlocks = BitUtils.DivRoundUp(region.Height, Info.BlockHeight);
 
-            int wInBlocks = BitUtils.DivRoundUp(region.Width, Info.BlockWidth);
-            int hInBlocks = BitUtils.DivRoundUp(region.Height, Info.BlockHeight);
-
-            unsafe
-            {
-                fixed (byte* ptr = dataSpan)
+                unsafe
                 {
-                    ReadFrom2D(
-                        (IntPtr)ptr,
-                        layer,
-                        level,
-                        region.X,
-                        region.Y,
-                        region.Width,
-                        region.Height,
-                        BitUtils.AlignUp(wInBlocks * Info.BytesPerPixel, 4) * hInBlocks);
+                    fixed (byte* ptr = data.Memory.Span)
+                    {
+                        ReadFrom2D(
+                            (IntPtr)ptr,
+                            layer,
+                            level,
+                            region.X,
+                            region.Y,
+                            region.Width,
+                            region.Height,
+                            BitUtils.AlignUp(wInBlocks * Info.BytesPerPixel, 4) * hInBlocks);
+                    }
                 }
             }
         }
@@ -533,6 +522,19 @@ namespace Ryujinx.Graphics.OpenGL.Image
             ReadFrom2D(data, layer, level, x, y, width, height, mipSize);
         }
 
+        private IMemoryOwner<byte> EnsureDataFormat(IMemoryOwner<byte> data)
+        {
+            if (Format == Format.S8UintD24Unorm)
+            {
+                using (data)
+                {
+                    return FormatConverter.ConvertS8D24ToD24S8(data.Memory.Span);
+                }
+            }
+
+            return data;
+        }
+
         private void ReadFrom2D(IntPtr data, int layer, int level, int x, int y, int width, int height, int mipSize)
         {
             TextureTarget target = Target.Convert();

src/Ryujinx.Graphics.OpenGL/OpenGLRenderer.cs

@@ -90,6 +90,11 @@ namespace Ryujinx.Graphics.OpenGL
             throw new NotSupportedException();
         }
 
+        public IImageArray CreateImageArray(int size, bool isBuffer)
+        {
+            return new ImageArray(size);
+        }
+
         public IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info)
         {
             return new Program(shaders, info.FragmentOutputMap);
@@ -112,6 +117,11 @@ namespace Ryujinx.Graphics.OpenGL
             }
         }
 
+        public ITextureArray CreateTextureArray(int size, bool isBuffer)
+        {
+            return new TextureArray(size);
+        }
+
         public void DeleteBuffer(BufferHandle buffer)
         {
             PersistentBuffers.Unmap(buffer);
@@ -166,6 +176,7 @@ namespace Ryujinx.Graphics.OpenGL
                 supportsCubemapView: true,
                 supportsNonConstantTextureOffset: HwCapabilities.SupportsNonConstantTextureOffset,
                 supportsScaledVertexFormats: true,
+                supportsSeparateSampler: false,
                 supportsShaderBallot: HwCapabilities.SupportsShaderBallot,
                 supportsShaderBarrierDivergence: !(intelWindows || intelUnix),
                 supportsShaderFloat64: true,

src/Ryujinx.Graphics.OpenGL/Pipeline.cs

@@ -958,6 +958,11 @@ namespace Ryujinx.Graphics.OpenGL
             }
         }
 
+        public void SetImageArray(ShaderStage stage, int binding, IImageArray array)
+        {
+            (array as ImageArray).Bind(binding);
+        }
+
         public void SetIndexBuffer(BufferRange buffer, IndexType type)
         {
             _elementsType = type.Convert();
@@ -1302,6 +1307,10 @@ namespace Ryujinx.Graphics.OpenGL
             }
         }
 
+        public void SetTextureArray(ShaderStage stage, int binding, ITextureArray array)
+        {
+            (array as TextureArray).Bind(binding);
+        }
 
         public void SetTransformFeedbackBuffers(ReadOnlySpan<BufferRange> buffers)
         {

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

@@ -6,7 +6,6 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Numerics;
 
 namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
 {
@@ -339,27 +338,20 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
 
         private static void DeclareSamplers(CodeGenContext context, IEnumerable<TextureDefinition> definitions)
         {
-            int arraySize = 0;
-
             foreach (var definition in definitions)
             {
-                string indexExpr = string.Empty;
+                string arrayDecl = string.Empty;
 
-                if (definition.Type.HasFlag(SamplerType.Indexed))
+                if (definition.ArrayLength > 1)
                 {
-                    if (arraySize == 0)
-                    {
-                        arraySize = ResourceManager.SamplerArraySize;
-                    }
-                    else if (--arraySize != 0)
-                    {
-                        continue;
-                    }
-
-                    indexExpr = $"[{NumberFormatter.FormatInt(arraySize)}]";
+                    arrayDecl = $"[{NumberFormatter.FormatInt(definition.ArrayLength)}]";
+                }
+                else if (definition.ArrayLength == 0)
+                {
+                    arrayDecl = "[]";
                 }
 
-                string samplerTypeName = definition.Type.ToGlslSamplerType();
+                string samplerTypeName = definition.Separate ? definition.Type.ToGlslTextureType() : definition.Type.ToGlslSamplerType();
 
                 string layout = string.Empty;
 
@@ -368,30 +360,23 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
                     layout = $", set = {definition.Set}";
                 }
 
-                context.AppendLine($"layout (binding = {definition.Binding}{layout}) uniform {samplerTypeName} {definition.Name}{indexExpr};");
+                context.AppendLine($"layout (binding = {definition.Binding}{layout}) uniform {samplerTypeName} {definition.Name}{arrayDecl};");
             }
         }
 
         private static void DeclareImages(CodeGenContext context, IEnumerable<TextureDefinition> definitions)
         {
-            int arraySize = 0;
-
             foreach (var definition in definitions)
             {
-                string indexExpr = string.Empty;
+                string arrayDecl = string.Empty;
 
-                if (definition.Type.HasFlag(SamplerType.Indexed))
+                if (definition.ArrayLength > 1)
                 {
-                    if (arraySize == 0)
-                    {
-                        arraySize = ResourceManager.SamplerArraySize;
-                    }
-                    else if (--arraySize != 0)
-                    {
-                        continue;
-                    }
-
-                    indexExpr = $"[{NumberFormatter.FormatInt(arraySize)}]";
+                    arrayDecl = $"[{NumberFormatter.FormatInt(definition.ArrayLength)}]";
+                }
+                else if (definition.ArrayLength == 0)
+                {
+                    arrayDecl = "[]";
                 }
 
                 string imageTypeName = definition.Type.ToGlslImageType(definition.Format.GetComponentType());
@@ -413,7 +398,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
                     layout = $", set = {definition.Set}{layout}";
                 }
 
-                context.AppendLine($"layout (binding = {definition.Binding}{layout}) uniform {imageTypeName} {definition.Name}{indexExpr};");
+                context.AppendLine($"layout (binding = {definition.Binding}{layout}) uniform {imageTypeName} {definition.Name}{arrayDecl};");
             }
         }
 

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

@@ -38,7 +38,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 
             AggregateType type = GetSrcVarType(operation.Inst, 0);
 
-            string srcExpr = GetSoureExpr(context, src, type);
+            string srcExpr = GetSourceExpr(context, src, type);
             string zero;
 
             if (type == AggregateType.FP64)
@@ -80,7 +80,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 
                     for (int argIndex = operation.SourcesCount - arity + 2; argIndex < operation.SourcesCount; argIndex++)
                     {
-                        builder.Append($", {GetSoureExpr(context, operation.GetSource(argIndex), dstType)}");
+                        builder.Append($", {GetSourceExpr(context, operation.GetSource(argIndex), dstType)}");
                     }
                 }
                 else
@@ -94,7 +94,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 
                         AggregateType dstType = GetSrcVarType(inst, argIndex);
 
-                        builder.Append(GetSoureExpr(context, operation.GetSource(argIndex), dstType));
+                        builder.Append(GetSourceExpr(context, operation.GetSource(argIndex), dstType));
                     }
                 }
 
@@ -107,7 +107,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 // Return may optionally have a return value (and in this case it is unary).
                 if (inst == Instruction.Return && operation.SourcesCount != 0)
                 {
-                    return $"{op} {GetSoureExpr(context, operation.GetSource(0), context.CurrentFunction.ReturnType)}";
+                    return $"{op} {GetSourceExpr(context, operation.GetSource(0), context.CurrentFunction.ReturnType)}";
                 }
 
                 int arity = (int)(info.Type & InstType.ArityMask);
@@ -118,7 +118,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 {
                     IAstNode src = operation.GetSource(index);
 
-                    string srcExpr = GetSoureExpr(context, src, GetSrcVarType(inst, index));
+                    string srcExpr = GetSourceExpr(context, src, GetSrcVarType(inst, index));
 
                     bool isLhs = arity == 2 && index == 0;
 

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

@@ -12,7 +12,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
         {
             AggregateType dstType = GetSrcVarType(operation.Inst, 0);
 
-            string arg = GetSoureExpr(context, operation.GetSource(0), dstType);
+            string arg = GetSourceExpr(context, operation.GetSource(0), dstType);
             char component = "xyzw"[operation.Index];
 
             if (context.HostCapabilities.SupportsShaderBallot)

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

@@ -20,7 +20,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 
             for (int i = 0; i < args.Length; i++)
             {
-                args[i] = GetSoureExpr(context, operation.GetSource(i + 1), function.GetArgumentType(i));
+                args[i] = GetSourceExpr(context, operation.GetSource(i + 1), function.GetArgumentType(i));
             }
 
             return $"{function.Name}({string.Join(", ", args)})";

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

@@ -140,7 +140,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             return _infoTable[(int)(inst & Instruction.Mask)];
         }
 
-        public static string GetSoureExpr(CodeGenContext context, IAstNode node, AggregateType dstType)
+        public static string GetSourceExpr(CodeGenContext context, IAstNode node, AggregateType dstType)
         {
             return ReinterpretCast(context, node, OperandManager.GetNodeDestType(context, node), dstType);
         }

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

@@ -14,35 +14,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            // TODO: Bindless texture support. For now we just return 0/do nothing.
-            if (isBindless)
-            {
-                switch (texOp.Inst)
-                {
-                    case Instruction.ImageStore:
-                        return "// imageStore(bindless)";
-                    case Instruction.ImageLoad:
-                        AggregateType componentType = texOp.Format.GetComponentType();
-
-                        NumberFormatter.TryFormat(0, componentType, out string imageConst);
-
-                        AggregateType outputType = texOp.GetVectorType(componentType);
-
-                        if ((outputType & AggregateType.ElementCountMask) != 0)
-                        {
-                            return $"{Declarations.GetVarTypeName(context, outputType, precise: false)}({imageConst})";
-                        }
-
-                        return imageConst;
-                    default:
-                        return NumberFormatter.FormatInt(0);
-                }
-            }
-
             bool isArray = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
 
             var texCallBuilder = new StringBuilder();
 
@@ -70,21 +42,14 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 texCallBuilder.Append(texOp.Inst == Instruction.ImageLoad ? "imageLoad" : "imageStore");
             }
 
-            int srcIndex = isBindless ? 1 : 0;
+            int srcIndex = 0;
 
             string Src(AggregateType type)
             {
-                return GetSoureExpr(context, texOp.GetSource(srcIndex++), type);
+                return GetSourceExpr(context, texOp.GetSource(srcIndex++), type);
             }
 
-            string indexExpr = null;
-
-            if (isIndexed)
-            {
-                indexExpr = Src(AggregateType.S32);
-            }
-
-            string imageName = GetImageName(context.Properties, texOp, indexExpr);
+            string imageName = GetImageName(context, texOp, ref srcIndex);
 
             texCallBuilder.Append('(');
             texCallBuilder.Append(imageName);
@@ -198,27 +163,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
             int coordsCount = texOp.Type.GetDimensions();
+            int coordsIndex = 0;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return NumberFormatter.FormatFloat(0);
-            }
-
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            string indexExpr = null;
-
-            if (isIndexed)
-            {
-                indexExpr = GetSoureExpr(context, texOp.GetSource(0), AggregateType.S32);
-            }
-
-            string samplerName = GetSamplerName(context.Properties, texOp, indexExpr);
-
-            int coordsIndex = isBindless || isIndexed ? 1 : 0;
+            string samplerName = GetSamplerName(context, texOp, ref coordsIndex);
 
             string coordsExpr;
 
@@ -228,14 +175,14 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 
                 for (int index = 0; index < coordsCount; index++)
                 {
-                    elems[index] = GetSoureExpr(context, texOp.GetSource(coordsIndex + index), AggregateType.FP32);
+                    elems[index] = GetSourceExpr(context, texOp.GetSource(coordsIndex + index), AggregateType.FP32);
                 }
 
                 coordsExpr = "vec" + coordsCount + "(" + string.Join(", ", elems) + ")";
             }
             else
             {
-                coordsExpr = GetSoureExpr(context, texOp.GetSource(coordsIndex), AggregateType.FP32);
+                coordsExpr = GetSourceExpr(context, texOp.GetSource(coordsIndex), AggregateType.FP32);
             }
 
             return $"textureQueryLod({samplerName}, {coordsExpr}){GetMask(texOp.Index)}";
@@ -250,7 +197,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
             bool isGather = (texOp.Flags & TextureFlags.Gather) != 0;
             bool hasDerivatives = (texOp.Flags & TextureFlags.Derivatives) != 0;
             bool intCoords = (texOp.Flags & TextureFlags.IntCoords) != 0;
@@ -260,12 +206,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0;
 
             bool isArray = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
             bool isMultisample = (texOp.Type & SamplerType.Multisample) != 0;
             bool isShadow = (texOp.Type & SamplerType.Shadow) != 0;
 
-            bool colorIsVector = isGather || !isShadow;
-
             SamplerType type = texOp.Type & SamplerType.Mask;
 
             bool is2D = type == SamplerType.Texture2D;
@@ -286,24 +229,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 hasLodLevel = false;
             }
 
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                string scalarValue = NumberFormatter.FormatFloat(0);
-
-                if (colorIsVector)
-                {
-                    AggregateType outputType = texOp.GetVectorType(AggregateType.FP32);
-
-                    if ((outputType & AggregateType.ElementCountMask) != 0)
-                    {
-                        return $"{Declarations.GetVarTypeName(context, outputType, precise: false)}({scalarValue})";
-                    }
-                }
-
-                return scalarValue;
-            }
-
             string texCall = intCoords ? "texelFetch" : "texture";
 
             if (isGather)
@@ -328,21 +253,14 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 texCall += "Offsets";
             }
 
-            int srcIndex = isBindless ? 1 : 0;
+            int srcIndex = 0;
 
             string Src(AggregateType type)
             {
-                return GetSoureExpr(context, texOp.GetSource(srcIndex++), type);
+                return GetSourceExpr(context, texOp.GetSource(srcIndex++), type);
             }
 
-            string indexExpr = null;
-
-            if (isIndexed)
-            {
-                indexExpr = Src(AggregateType.S32);
-            }
-
-            string samplerName = GetSamplerName(context.Properties, texOp, indexExpr);
+            string samplerName = GetSamplerName(context, texOp, ref srcIndex);
 
             texCall += "(" + samplerName;
 
@@ -512,6 +430,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 Append(Src(AggregateType.S32));
             }
 
+            bool colorIsVector = isGather || !isShadow;
+
             texCall += ")" + (colorIsVector ? GetMaskMultiDest(texOp.Index) : "");
 
             return texCall;
@@ -521,24 +441,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
+            int srcIndex = 0;
 
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return NumberFormatter.FormatInt(0);
-            }
-
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            string indexExpr = null;
-
-            if (isIndexed)
-            {
-                indexExpr = GetSoureExpr(context, texOp.GetSource(0), AggregateType.S32);
-            }
-
-            string samplerName = GetSamplerName(context.Properties, texOp, indexExpr);
+            string samplerName = GetSamplerName(context, texOp, ref srcIndex);
 
             return $"textureSamples({samplerName})";
         }
@@ -547,24 +452,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
+            int srcIndex = 0;
 
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return NumberFormatter.FormatInt(0);
-            }
-
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            string indexExpr = null;
-
-            if (isIndexed)
-            {
-                indexExpr = GetSoureExpr(context, texOp.GetSource(0), AggregateType.S32);
-            }
-
-            string samplerName = GetSamplerName(context.Properties, texOp, indexExpr);
+            string samplerName = GetSamplerName(context, texOp, ref srcIndex);
 
             if (texOp.Index == 3)
             {
@@ -578,9 +468,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 
                 if (hasLod)
                 {
-                    int lodSrcIndex = isBindless || isIndexed ? 1 : 0;
-                    IAstNode lod = operation.GetSource(lodSrcIndex);
-                    string lodExpr = GetSoureExpr(context, lod, GetSrcVarType(operation.Inst, lodSrcIndex));
+                    IAstNode lod = operation.GetSource(srcIndex);
+                    string lodExpr = GetSourceExpr(context, lod, GetSrcVarType(operation.Inst, srcIndex));
 
                     texCall = $"textureSize({samplerName}, {lodExpr}){GetMask(texOp.Index)}";
                 }
@@ -697,12 +586,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 
                         if (storageKind == StorageKind.Input)
                         {
-                            string expr = GetSoureExpr(context, operation.GetSource(srcIndex++), AggregateType.S32);
+                            string expr = GetSourceExpr(context, operation.GetSource(srcIndex++), AggregateType.S32);
                             varName = $"gl_in[{expr}].{varName}";
                         }
                         else if (storageKind == StorageKind.Output)
                         {
-                            string expr = GetSoureExpr(context, operation.GetSource(srcIndex++), AggregateType.S32);
+                            string expr = GetSourceExpr(context, operation.GetSource(srcIndex++), AggregateType.S32);
                             varName = $"gl_out[{expr}].{varName}";
                         }
                     }
@@ -735,38 +624,53 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
                 }
                 else
                 {
-                    varName += $"[{GetSoureExpr(context, src, AggregateType.S32)}]";
+                    varName += $"[{GetSourceExpr(context, src, AggregateType.S32)}]";
                 }
             }
 
             if (isStore)
             {
                 varType &= AggregateType.ElementTypeMask;
-                varName = $"{varName} = {GetSoureExpr(context, operation.GetSource(srcIndex), varType)}";
+                varName = $"{varName} = {GetSourceExpr(context, operation.GetSource(srcIndex), varType)}";
             }
 
             return varName;
         }
 
-        private static string GetSamplerName(ShaderProperties resourceDefinitions, AstTextureOperation texOp, string indexExpr)
+        private static string GetSamplerName(CodeGenContext context, AstTextureOperation texOp, ref int srcIndex)
         {
-            string name = resourceDefinitions.Textures[texOp.Binding].Name;
+            TextureDefinition textureDefinition = context.Properties.Textures[texOp.Binding];
+            string name = textureDefinition.Name;
 
-            if (texOp.Type.HasFlag(SamplerType.Indexed))
+            if (textureDefinition.ArrayLength != 1)
             {
-                name = $"{name}[{indexExpr}]";
+                name = $"{name}[{GetSourceExpr(context, texOp.GetSource(srcIndex++), AggregateType.S32)}]";
+            }
+
+            if (texOp.IsSeparate)
+            {
+                TextureDefinition samplerDefinition = context.Properties.Textures[texOp.SamplerBinding];
+                string samplerName = samplerDefinition.Name;
+
+                if (samplerDefinition.ArrayLength != 1)
+                {
+                    samplerName = $"{samplerName}[{GetSourceExpr(context, texOp.GetSource(srcIndex++), AggregateType.S32)}]";
+                }
+
+                name = $"{texOp.Type.ToGlslSamplerType()}({name}, {samplerName})";
             }
 
             return name;
         }
 
-        private static string GetImageName(ShaderProperties resourceDefinitions, AstTextureOperation texOp, string indexExpr)
+        private static string GetImageName(CodeGenContext context, AstTextureOperation texOp, ref int srcIndex)
         {
-            string name = resourceDefinitions.Images[texOp.Binding].Name;
+            TextureDefinition definition = context.Properties.Images[texOp.Binding];
+            string name = definition.Name;
 
-            if (texOp.Type.HasFlag(SamplerType.Indexed))
+            if (definition.ArrayLength != 1)
             {
-                name = $"{name}[{indexExpr}]";
+                name = $"{name}[{GetSourceExpr(context, texOp.GetSource(srcIndex++), AggregateType.S32)}]";
             }
 
             return name;

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

@@ -13,8 +13,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             IAstNode src0 = operation.GetSource(0);
             IAstNode src1 = operation.GetSource(1);
 
-            string src0Expr = GetSoureExpr(context, src0, GetSrcVarType(operation.Inst, 0));
-            string src1Expr = GetSoureExpr(context, src1, GetSrcVarType(operation.Inst, 1));
+            string src0Expr = GetSourceExpr(context, src0, GetSrcVarType(operation.Inst, 0));
+            string src1Expr = GetSourceExpr(context, src1, GetSrcVarType(operation.Inst, 1));
 
             return $"packDouble2x32(uvec2({src0Expr}, {src1Expr}))";
         }
@@ -24,8 +24,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             IAstNode src0 = operation.GetSource(0);
             IAstNode src1 = operation.GetSource(1);
 
-            string src0Expr = GetSoureExpr(context, src0, GetSrcVarType(operation.Inst, 0));
-            string src1Expr = GetSoureExpr(context, src1, GetSrcVarType(operation.Inst, 1));
+            string src0Expr = GetSourceExpr(context, src0, GetSrcVarType(operation.Inst, 0));
+            string src1Expr = GetSourceExpr(context, src1, GetSrcVarType(operation.Inst, 1));
 
             return $"packHalf2x16(vec2({src0Expr}, {src1Expr}))";
         }
@@ -34,7 +34,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
         {
             IAstNode src = operation.GetSource(0);
 
-            string srcExpr = GetSoureExpr(context, src, GetSrcVarType(operation.Inst, 0));
+            string srcExpr = GetSourceExpr(context, src, GetSrcVarType(operation.Inst, 0));
 
             return $"unpackDouble2x32({srcExpr}){GetMask(operation.Index)}";
         }
@@ -43,7 +43,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
         {
             IAstNode src = operation.GetSource(0);
 
-            string srcExpr = GetSoureExpr(context, src, GetSrcVarType(operation.Inst, 0));
+            string srcExpr = GetSourceExpr(context, src, GetSrcVarType(operation.Inst, 0));
 
             return $"unpackHalf2x16({srcExpr}){GetMask(operation.Index)}";
         }

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

@@ -9,8 +9,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
     {
         public static string Shuffle(CodeGenContext context, AstOperation operation)
         {
-            string value = GetSoureExpr(context, operation.GetSource(0), AggregateType.FP32);
-            string index = GetSoureExpr(context, operation.GetSource(1), AggregateType.U32);
+            string value = GetSourceExpr(context, operation.GetSource(0), AggregateType.FP32);
+            string index = GetSourceExpr(context, operation.GetSource(1), AggregateType.U32);
 
             if (context.HostCapabilities.SupportsShaderBallot)
             {

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

@@ -13,7 +13,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             IAstNode vector = operation.GetSource(0);
             IAstNode index = operation.GetSource(1);
 
-            string vectorExpr = GetSoureExpr(context, vector, OperandManager.GetNodeDestType(context, vector));
+            string vectorExpr = GetSourceExpr(context, vector, OperandManager.GetNodeDestType(context, vector));
 
             if (index is AstOperand indexOperand && indexOperand.Type == OperandType.Constant)
             {
@@ -23,7 +23,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
             }
             else
             {
-                string indexExpr = GetSoureExpr(context, index, GetSrcVarType(operation.Inst, 1));
+                string indexExpr = GetSourceExpr(context, index, GetSrcVarType(operation.Inst, 1));
 
                 return $"{vectorExpr}[{indexExpr}]";
             }

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

@@ -146,9 +146,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
                 }
                 else if (operation is AstTextureOperation texOp)
                 {
-                    if (texOp.Inst == Instruction.ImageLoad ||
-                        texOp.Inst == Instruction.ImageStore ||
-                        texOp.Inst == Instruction.ImageAtomic)
+                    if (texOp.Inst.IsImage())
                     {
                         return texOp.GetVectorType(texOp.Format.GetComponentType());
                     }

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

@@ -34,8 +34,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         public Dictionary<int, Instruction> SharedMemories { get; } = new();
 
         public Dictionary<int, SamplerType> SamplersTypes { get; } = new();
-        public Dictionary<int, (Instruction, Instruction, Instruction)> Samplers { get; } = new();
-        public Dictionary<int, (Instruction, Instruction)> Images { get; } = new();
+        public Dictionary<int, SamplerDeclaration> Samplers { get; } = new();
+        public Dictionary<int, ImageDeclaration> Images { get; } = new();
 
         public Dictionary<IoDefinition, Instruction> Inputs { get; } = new();
         public Dictionary<IoDefinition, Instruction> Outputs { get; } = new();

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

@@ -160,30 +160,60 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             {
                 int setIndex = context.TargetApi == TargetApi.Vulkan ? sampler.Set : 0;
 
-                var dim = (sampler.Type & SamplerType.Mask) switch
+                SpvInstruction imageType;
+                SpvInstruction sampledImageType;
+
+                if (sampler.Type != SamplerType.None)
                 {
-                    SamplerType.Texture1D => Dim.Dim1D,
-                    SamplerType.Texture2D => Dim.Dim2D,
-                    SamplerType.Texture3D => Dim.Dim3D,
-                    SamplerType.TextureCube => Dim.Cube,
-                    SamplerType.TextureBuffer => Dim.Buffer,
-                    _ => throw new InvalidOperationException($"Invalid sampler type \"{sampler.Type & SamplerType.Mask}\"."),
-                };
+                    var dim = (sampler.Type & SamplerType.Mask) switch
+                    {
+                        SamplerType.Texture1D => Dim.Dim1D,
+                        SamplerType.Texture2D => Dim.Dim2D,
+                        SamplerType.Texture3D => Dim.Dim3D,
+                        SamplerType.TextureCube => Dim.Cube,
+                        SamplerType.TextureBuffer => Dim.Buffer,
+                        _ => throw new InvalidOperationException($"Invalid sampler type \"{sampler.Type & SamplerType.Mask}\"."),
+                    };
 
-                var imageType = context.TypeImage(
-                    context.TypeFP32(),
-                    dim,
-                    sampler.Type.HasFlag(SamplerType.Shadow),
-                    sampler.Type.HasFlag(SamplerType.Array),
-                    sampler.Type.HasFlag(SamplerType.Multisample),
-                    1,
-                    ImageFormat.Unknown);
+                    imageType = context.TypeImage(
+                        context.TypeFP32(),
+                        dim,
+                        sampler.Type.HasFlag(SamplerType.Shadow),
+                        sampler.Type.HasFlag(SamplerType.Array),
+                        sampler.Type.HasFlag(SamplerType.Multisample),
+                        1,
+                        ImageFormat.Unknown);
 
-                var sampledImageType = context.TypeSampledImage(imageType);
-                var sampledImagePointerType = context.TypePointer(StorageClass.UniformConstant, sampledImageType);
-                var sampledImageVariable = context.Variable(sampledImagePointerType, StorageClass.UniformConstant);
+                    sampledImageType = context.TypeSampledImage(imageType);
+                }
+                else
+                {
+                    imageType = sampledImageType = context.TypeSampler();
+                }
 
-                context.Samplers.Add(sampler.Binding, (imageType, sampledImageType, sampledImageVariable));
+                var sampledOrSeparateImageType = sampler.Separate ? imageType : sampledImageType;
+                var sampledImagePointerType = context.TypePointer(StorageClass.UniformConstant, sampledOrSeparateImageType);
+                var sampledImageArrayPointerType = sampledImagePointerType;
+
+                if (sampler.ArrayLength == 0)
+                {
+                    var sampledImageArrayType = context.TypeRuntimeArray(sampledOrSeparateImageType);
+                    sampledImageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, sampledImageArrayType);
+                }
+                else if (sampler.ArrayLength != 1)
+                {
+                    var sampledImageArrayType = context.TypeArray(sampledOrSeparateImageType, context.Constant(context.TypeU32(), sampler.ArrayLength));
+                    sampledImageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, sampledImageArrayType);
+                }
+
+                var sampledImageVariable = context.Variable(sampledImageArrayPointerType, StorageClass.UniformConstant);
+
+                context.Samplers.Add(sampler.Binding, new SamplerDeclaration(
+                    imageType,
+                    sampledImageType,
+                    sampledImagePointerType,
+                    sampledImageVariable,
+                    sampler.ArrayLength != 1));
                 context.SamplersTypes.Add(sampler.Binding, sampler.Type);
 
                 context.Name(sampledImageVariable, sampler.Name);
@@ -211,9 +241,22 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                     GetImageFormat(image.Format));
 
                 var imagePointerType = context.TypePointer(StorageClass.UniformConstant, imageType);
-                var imageVariable = context.Variable(imagePointerType, StorageClass.UniformConstant);
+                var imageArrayPointerType = imagePointerType;
 
-                context.Images.Add(image.Binding, (imageType, imageVariable));
+                if (image.ArrayLength == 0)
+                {
+                    var imageArrayType = context.TypeRuntimeArray(imageType);
+                    imageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, imageArrayType);
+                }
+                else if (image.ArrayLength != 1)
+                {
+                    var imageArrayType = context.TypeArray(imageType, context.Constant(context.TypeU32(), image.ArrayLength));
+                    imageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, imageArrayType);
+                }
+
+                var imageVariable = context.Variable(imageArrayPointerType, StorageClass.UniformConstant);
+
+                context.Images.Add(image.Binding, new ImageDeclaration(imageType, imagePointerType, imageVariable, image.ArrayLength != 1));
 
                 context.Name(imageVariable, image.Name);
                 context.Decorate(imageVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);

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

@@ -0,0 +1,20 @@
+using Spv.Generator;
+
+namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
+{
+    readonly struct ImageDeclaration
+    {
+        public readonly Instruction ImageType;
+        public readonly Instruction ImagePointerType;
+        public readonly Instruction Image;
+        public readonly bool IsIndexed;
+
+        public ImageDeclaration(Instruction imageType, Instruction imagePointerType, Instruction image, bool isIndexed)
+        {
+            ImageType = imageType;
+            ImagePointerType = imagePointerType;
+            Image = image;
+            IsIndexed = isIndexed;
+        }
+    }
+}

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

@@ -591,34 +591,28 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
             var componentType = texOp.Format.GetComponentType();
 
-            // TODO: Bindless texture support. For now we just return 0/do nothing.
-            if (isBindless)
-            {
-                return new OperationResult(componentType, componentType switch
-                {
-                    AggregateType.S32 => context.Constant(context.TypeS32(), 0),
-                    AggregateType.U32 => context.Constant(context.TypeU32(), 0u),
-                    _ => context.Constant(context.TypeFP32(), 0f),
-                });
-            }
-
             bool isArray = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
 
-            int srcIndex = isBindless ? 1 : 0;
+            int srcIndex = 0;
 
             SpvInstruction Src(AggregateType type)
             {
                 return context.Get(type, texOp.GetSource(srcIndex++));
             }
 
-            if (isIndexed)
+            ImageDeclaration declaration = context.Images[texOp.Binding];
+            SpvInstruction image = declaration.Image;
+
+            SpvInstruction resultType = context.GetType(componentType);
+            SpvInstruction imagePointerType = context.TypePointer(StorageClass.Image, resultType);
+
+            if (declaration.IsIndexed)
             {
-                Src(AggregateType.S32);
+                SpvInstruction textureIndex = Src(AggregateType.S32);
+
+                image = context.AccessChain(imagePointerType, image, textureIndex);
             }
 
             int coordsCount = texOp.Type.GetDimensions();
@@ -646,14 +640,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
             SpvInstruction value = Src(componentType);
 
-            (var imageType, var imageVariable) = context.Images[texOp.Binding];
-
-            context.Load(imageType, imageVariable);
-
-            SpvInstruction resultType = context.GetType(componentType);
-            SpvInstruction imagePointerType = context.TypePointer(StorageClass.Image, resultType);
-
-            var pointer = context.ImageTexelPointer(imagePointerType, imageVariable, pCoords, context.Constant(context.TypeU32(), 0));
+            var pointer = context.ImageTexelPointer(imagePointerType, image, pCoords, context.Constant(context.TypeU32(), 0));
             var one = context.Constant(context.TypeU32(), 1);
             var zero = context.Constant(context.TypeU32(), 0);
 
@@ -683,31 +670,29 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
             var componentType = texOp.Format.GetComponentType();
 
-            // TODO: Bindless texture support. For now we just return 0/do nothing.
-            if (isBindless)
-            {
-                return GetZeroOperationResult(context, texOp, componentType, isVector: true);
-            }
-
             bool isArray = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
 
-            int srcIndex = isBindless ? 1 : 0;
+            int srcIndex = 0;
 
             SpvInstruction Src(AggregateType type)
             {
                 return context.Get(type, texOp.GetSource(srcIndex++));
             }
 
-            if (isIndexed)
+            ImageDeclaration declaration = context.Images[texOp.Binding];
+            SpvInstruction image = declaration.Image;
+
+            if (declaration.IsIndexed)
             {
-                Src(AggregateType.S32);
+                SpvInstruction textureIndex = Src(AggregateType.S32);
+
+                image = context.AccessChain(declaration.ImagePointerType, image, textureIndex);
             }
 
+            image = context.Load(declaration.ImageType, image);
+
             int coordsCount = texOp.Type.GetDimensions();
 
             int pCount = coordsCount + (isArray ? 1 : 0);
@@ -731,9 +716,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                 pCoords = Src(AggregateType.S32);
             }
 
-            (var imageType, var imageVariable) = context.Images[texOp.Binding];
-
-            var image = context.Load(imageType, imageVariable);
             var imageComponentType = context.GetType(componentType);
             var swizzledResultType = texOp.GetVectorType(componentType);
 
@@ -747,29 +729,27 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            // TODO: Bindless texture support. For now we just return 0/do nothing.
-            if (isBindless)
-            {
-                return OperationResult.Invalid;
-            }
-
             bool isArray = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
 
-            int srcIndex = isBindless ? 1 : 0;
+            int srcIndex = 0;
 
             SpvInstruction Src(AggregateType type)
             {
                 return context.Get(type, texOp.GetSource(srcIndex++));
             }
 
-            if (isIndexed)
+            ImageDeclaration declaration = context.Images[texOp.Binding];
+            SpvInstruction image = declaration.Image;
+
+            if (declaration.IsIndexed)
             {
-                Src(AggregateType.S32);
+                SpvInstruction textureIndex = Src(AggregateType.S32);
+
+                image = context.AccessChain(declaration.ImagePointerType, image, textureIndex);
             }
 
+            image = context.Load(declaration.ImageType, image);
+
             int coordsCount = texOp.Type.GetDimensions();
 
             int pCount = coordsCount + (isArray ? 1 : 0);
@@ -818,10 +798,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
             var texel = context.CompositeConstruct(context.TypeVector(context.GetType(componentType), ComponentsCount), cElems);
 
-            (var imageType, var imageVariable) = context.Images[texOp.Binding];
-
-            var image = context.Load(imageType, imageVariable);
-
             context.ImageWrite(image, pCoords, texel, ImageOperandsMask.MaskNone);
 
             return OperationResult.Invalid;
@@ -854,16 +830,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return new OperationResult(AggregateType.S32, context.Constant(context.TypeS32(), 0));
-            }
-
             int srcIndex = 0;
 
             SpvInstruction Src(AggregateType type)
@@ -871,10 +837,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                 return context.Get(type, texOp.GetSource(srcIndex++));
             }
 
-            if (isIndexed)
-            {
-                Src(AggregateType.S32);
-            }
+            SamplerDeclaration declaration = context.Samplers[texOp.Binding];
+            SpvInstruction image = GenerateSampledImageLoad(context, texOp, declaration, ref srcIndex);
 
             int pCount = texOp.Type.GetDimensions();
 
@@ -897,10 +861,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                 pCoords = Src(AggregateType.FP32);
             }
 
-            (_, var sampledImageType, var sampledImageVariable) = context.Samplers[texOp.Binding];
-
-            var image = context.Load(sampledImageType, sampledImageVariable);
-
             var resultType = context.TypeVector(context.TypeFP32(), 2);
             var packed = context.ImageQueryLod(resultType, image, pCoords);
             var result = context.CompositeExtract(context.TypeFP32(), packed, (SpvLiteralInteger)texOp.Index);
@@ -1182,7 +1142,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
             bool isGather = (texOp.Flags & TextureFlags.Gather) != 0;
             bool hasDerivatives = (texOp.Flags & TextureFlags.Derivatives) != 0;
             bool intCoords = (texOp.Flags & TextureFlags.IntCoords) != 0;
@@ -1192,29 +1151,18 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0;
 
             bool isArray = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
             bool isMultisample = (texOp.Type & SamplerType.Multisample) != 0;
             bool isShadow = (texOp.Type & SamplerType.Shadow) != 0;
 
-            bool colorIsVector = isGather || !isShadow;
-
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return GetZeroOperationResult(context, texOp, AggregateType.FP32, colorIsVector);
-            }
-
-            int srcIndex = isBindless ? 1 : 0;
+            int srcIndex = 0;
 
             SpvInstruction Src(AggregateType type)
             {
                 return context.Get(type, texOp.GetSource(srcIndex++));
             }
 
-            if (isIndexed)
-            {
-                Src(AggregateType.S32);
-            }
+            SamplerDeclaration declaration = context.Samplers[texOp.Binding];
+            SpvInstruction image = GenerateSampledImageLoad(context, texOp, declaration, ref srcIndex);
 
             int coordsCount = texOp.Type.GetDimensions();
 
@@ -1419,15 +1367,13 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                 operandsList.Add(sample);
             }
 
+            bool colorIsVector = isGather || !isShadow;
+
             var resultType = colorIsVector ? context.TypeVector(context.TypeFP32(), 4) : context.TypeFP32();
 
-            (var imageType, var sampledImageType, var sampledImageVariable) = context.Samplers[texOp.Binding];
-
-            var image = context.Load(sampledImageType, sampledImageVariable);
-
             if (intCoords)
             {
-                image = context.Image(imageType, image);
+                image = context.Image(declaration.ImageType, image);
             }
 
             var operands = operandsList.ToArray();
@@ -1485,25 +1431,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
+            int srcIndex = 0;
 
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return new OperationResult(AggregateType.S32, context.Constant(context.TypeS32(), 0));
-            }
+            SamplerDeclaration declaration = context.Samplers[texOp.Binding];
+            SpvInstruction image = GenerateSampledImageLoad(context, texOp, declaration, ref srcIndex);
 
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            if (isIndexed)
-            {
-                context.GetS32(texOp.GetSource(0));
-            }
-
-            (var imageType, var sampledImageType, var sampledImageVariable) = context.Samplers[texOp.Binding];
-
-            var image = context.Load(sampledImageType, sampledImageVariable);
-            image = context.Image(imageType, image);
+            image = context.Image(declaration.ImageType, image);
 
             SpvInstruction result = context.ImageQuerySamples(context.TypeS32(), image);
 
@@ -1514,25 +1447,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
         {
             AstTextureOperation texOp = (AstTextureOperation)operation;
 
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
+            int srcIndex = 0;
 
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return new OperationResult(AggregateType.S32, context.Constant(context.TypeS32(), 0));
-            }
+            SamplerDeclaration declaration = context.Samplers[texOp.Binding];
+            SpvInstruction image = GenerateSampledImageLoad(context, texOp, declaration, ref srcIndex);
 
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            if (isIndexed)
-            {
-                context.GetS32(texOp.GetSource(0));
-            }
-
-            (var imageType, var sampledImageType, var sampledImageVariable) = context.Samplers[texOp.Binding];
-
-            var image = context.Load(sampledImageType, sampledImageVariable);
-            image = context.Image(imageType, image);
+            image = context.Image(declaration.ImageType, image);
 
             if (texOp.Index == 3)
             {
@@ -1556,8 +1476,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
                 if (hasLod)
                 {
-                    int lodSrcIndex = isBindless || isIndexed ? 1 : 0;
-                    var lod = context.GetS32(operation.GetSource(lodSrcIndex));
+                    var lod = context.GetS32(operation.GetSource(srcIndex));
                     result = context.ImageQuerySizeLod(resultType, image, lod);
                 }
                 else
@@ -1929,38 +1848,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             return context.Load(context.GetType(varType), context.Inputs[ioDefinition]);
         }
 
-        private static OperationResult GetZeroOperationResult(
-            CodeGenContext context,
-            AstTextureOperation texOp,
-            AggregateType scalarType,
-            bool isVector)
-        {
-            var zero = scalarType switch
-            {
-                AggregateType.S32 => context.Constant(context.TypeS32(), 0),
-                AggregateType.U32 => context.Constant(context.TypeU32(), 0u),
-                _ => context.Constant(context.TypeFP32(), 0f),
-            };
-
-            if (isVector)
-            {
-                AggregateType outputType = texOp.GetVectorType(scalarType);
-
-                if ((outputType & AggregateType.ElementCountMask) != 0)
-                {
-                    int componentsCount = BitOperations.PopCount((uint)texOp.Index);
-
-                    SpvInstruction[] values = new SpvInstruction[componentsCount];
-
-                    values.AsSpan().Fill(zero);
-
-                    return new OperationResult(outputType, context.ConstantComposite(context.GetType(outputType), values));
-                }
-            }
-
-            return new OperationResult(scalarType, zero);
-        }
-
         private static SpvInstruction GetSwizzledResult(CodeGenContext context, SpvInstruction vector, AggregateType swizzledResultType, int mask)
         {
             if ((swizzledResultType & AggregateType.ElementCountMask) != 0)
@@ -1987,6 +1874,43 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             }
         }
 
+        private static SpvInstruction GenerateSampledImageLoad(CodeGenContext context, AstTextureOperation texOp, SamplerDeclaration declaration, ref int srcIndex)
+        {
+            SpvInstruction image = declaration.Image;
+
+            if (declaration.IsIndexed)
+            {
+                SpvInstruction textureIndex = context.Get(AggregateType.S32, texOp.GetSource(srcIndex++));
+
+                image = context.AccessChain(declaration.SampledImagePointerType, image, textureIndex);
+            }
+
+            if (texOp.IsSeparate)
+            {
+                image = context.Load(declaration.ImageType, image);
+
+                SamplerDeclaration samplerDeclaration = context.Samplers[texOp.SamplerBinding];
+
+                SpvInstruction sampler = samplerDeclaration.Image;
+
+                if (samplerDeclaration.IsIndexed)
+                {
+                    SpvInstruction samplerIndex = context.Get(AggregateType.S32, texOp.GetSource(srcIndex++));
+
+                    sampler = context.AccessChain(samplerDeclaration.SampledImagePointerType, sampler, samplerIndex);
+                }
+
+                sampler = context.Load(samplerDeclaration.ImageType, sampler);
+                image = context.SampledImage(declaration.SampledImageType, image, sampler);
+            }
+            else
+            {
+                image = context.Load(declaration.SampledImageType, image);
+            }
+
+            return image;
+        }
+
         private static OperationResult GenerateUnary(
             CodeGenContext context,
             AstOperation operation,

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

@@ -0,0 +1,27 @@
+using Spv.Generator;
+
+namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
+{
+    readonly struct SamplerDeclaration
+    {
+        public readonly Instruction ImageType;
+        public readonly Instruction SampledImageType;
+        public readonly Instruction SampledImagePointerType;
+        public readonly Instruction Image;
+        public readonly bool IsIndexed;
+
+        public SamplerDeclaration(
+            Instruction imageType,
+            Instruction sampledImageType,
+            Instruction sampledImagePointerType,
+            Instruction image,
+            bool isIndexed)
+        {
+            ImageType = imageType;
+            SampledImageType = sampledImageType;
+            SampledImagePointerType = sampledImagePointerType;
+            Image = image;
+            IsIndexed = isIndexed;
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/IGpuAccessor.cs

@@ -31,42 +31,30 @@ namespace Ryujinx.Graphics.Shader
         /// </summary>
         /// <param name="index">Constant buffer index</param>
         /// <returns>Binding number</returns>
-        int QueryBindingConstantBuffer(int index)
-        {
-            return index + 1;
-        }
+        int CreateConstantBufferBinding(int index);
+
+        /// <summary>
+        /// Queries the binding number of an image.
+        /// </summary>
+        /// <param name="count">For array of images, the number of elements of the array, otherwise it should be 1</param>
+        /// <param name="isBuffer">Indicates if the image is a buffer image</param>
+        /// <returns>Binding number</returns>
+        int CreateImageBinding(int count, bool isBuffer);
 
         /// <summary>
         /// Queries the binding number of a storage buffer.
         /// </summary>
         /// <param name="index">Storage buffer index</param>
         /// <returns>Binding number</returns>
-        int QueryBindingStorageBuffer(int index)
-        {
-            return index;
-        }
+        int CreateStorageBufferBinding(int index);
 
         /// <summary>
         /// Queries the binding number of a texture.
         /// </summary>
-        /// <param name="index">Texture index</param>
+        /// <param name="count">For array of textures, the number of elements of the array, otherwise it should be 1</param>
         /// <param name="isBuffer">Indicates if the texture is a buffer texture</param>
         /// <returns>Binding number</returns>
-        int QueryBindingTexture(int index, bool isBuffer)
-        {
-            return index;
-        }
-
-        /// <summary>
-        /// Queries the binding number of an image.
-        /// </summary>
-        /// <param name="index">Image index</param>
-        /// <param name="isBuffer">Indicates if the image is a buffer image</param>
-        /// <returns>Binding number</returns>
-        int QueryBindingImage(int index, bool isBuffer)
-        {
-            return index;
-        }
+        int CreateTextureBinding(int count, bool isBuffer);
 
         /// <summary>
         /// Queries Local Size X for compute shaders.
@@ -303,6 +291,15 @@ namespace Ryujinx.Graphics.Shader
             return true;
         }
 
+        /// <summary>
+        /// Queries host API support for separate textures and samplers.
+        /// </summary>
+        /// <returns>True if the API supports samplers and textures to be combined on the shader, false otherwise</returns>
+        bool QueryHostSupportsSeparateSampler()
+        {
+            return true;
+        }
+
         /// <summary>
         /// Queries host GPU shader ballot support.
         /// </summary>
@@ -393,6 +390,12 @@ namespace Ryujinx.Graphics.Shader
             return true;
         }
 
+        /// <summary>
+        /// Gets the maximum number of samplers that the bound texture pool may have.
+        /// </summary>
+        /// <returns>Maximum amount of samplers that the pool may have</returns>
+        int QuerySamplerArrayLengthFromPool();
+
         /// <summary>
         /// Queries sampler type information.
         /// </summary>
@@ -404,6 +407,19 @@ namespace Ryujinx.Graphics.Shader
             return SamplerType.Texture2D;
         }
 
+        /// <summary>
+        /// Gets the size in bytes of a bound constant buffer for the current shader stage.
+        /// </summary>
+        /// <param name="slot">The number of the constant buffer to get the size from</param>
+        /// <returns>Size in bytes</returns>
+        int QueryTextureArrayLengthFromBuffer(int slot);
+
+        /// <summary>
+        /// Gets the maximum number of textures that the bound texture pool may have.
+        /// </summary>
+        /// <returns>Maximum amount of textures that the pool may have</returns>
+        int QueryTextureArrayLengthFromPool();
+
         /// <summary>
         /// Queries texture coordinate normalization information.
         /// </summary>

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

@@ -161,5 +161,17 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
             inst &= Instruction.Mask;
             return inst == Instruction.Lod || inst == Instruction.TextureQuerySamples || inst == Instruction.TextureQuerySize;
         }
+
+        public static bool IsImage(this Instruction inst)
+        {
+            inst &= Instruction.Mask;
+            return inst == Instruction.ImageAtomic || inst == Instruction.ImageLoad || inst == Instruction.ImageStore;
+        }
+
+        public static bool IsImageStore(this Instruction inst)
+        {
+            inst &= Instruction.Mask;
+            return inst == Instruction.ImageAtomic || inst == Instruction.ImageStore;
+        }
     }
 }

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

@@ -20,13 +20,13 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
             }
             set
             {
-                if (value != null && value.Type == OperandType.LocalVariable)
-                {
-                    value.AsgOp = this;
-                }
-
                 if (value != null)
                 {
+                    if (value.Type == OperandType.LocalVariable)
+                    {
+                        value.AsgOp = this;
+                    }
+
                     _dests = new[] { value };
                 }
                 else
@@ -216,6 +216,11 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
 
             newSources[index] = source;
 
+            if (source != null && source.Type == OperandType.LocalVariable)
+            {
+                source.UseOps.Add(this);
+            }
+
             _sources = newSources;
         }