True bindless

src/Ryujinx.Graphics.GAL/Capabilities.cs

@@ -8,6 +8,7 @@ public readonly struct Capabilities
         public readonly string VendorName;
 
         public readonly bool HasFrontFacingBug;
+        public readonly bool HasUnsizedDescriptorArrayBug;
         public readonly bool HasVectorIndexingBug;
         public readonly bool NeedsFragmentOutputSpecialization;
         public readonly bool ReduceShaderPrecision;
@@ -24,6 +25,7 @@ public readonly struct Capabilities
         public readonly bool SupportsScaledVertexFormats;
         public readonly bool SupportsSnormBufferTextureFormat;
         public readonly bool Supports5BitComponentFormat;
+        public readonly bool SupportsBindlessTextures;
         public readonly bool SupportsBlendEquationAdvanced;
         public readonly bool SupportsFragmentShaderInterlock;
         public readonly bool SupportsFragmentShaderOrderingIntel;
@@ -64,6 +66,7 @@ public Capabilities(
             TargetApi api,
             string vendorName,
             bool hasFrontFacingBug,
+            bool hasUnsizedDescriptorArrayBug,
             bool hasVectorIndexingBug,
             bool needsFragmentOutputSpecialization,
             bool reduceShaderPrecision,
@@ -79,6 +82,7 @@ public Capabilities(
             bool supportsScaledVertexFormats,
             bool supportsSnormBufferTextureFormat,
             bool supports5BitComponentFormat,
+            bool supportsBindlessTextures,
             bool supportsBlendEquationAdvanced,
             bool supportsFragmentShaderInterlock,
             bool supportsFragmentShaderOrderingIntel,
@@ -115,6 +119,7 @@ public Capabilities(
             Api = api;
             VendorName = vendorName;
             HasFrontFacingBug = hasFrontFacingBug;
+            HasUnsizedDescriptorArrayBug = hasUnsizedDescriptorArrayBug;
             HasVectorIndexingBug = hasVectorIndexingBug;
             NeedsFragmentOutputSpecialization = needsFragmentOutputSpecialization;
             ReduceShaderPrecision = reduceShaderPrecision;
@@ -130,6 +135,7 @@ public Capabilities(
             SupportsScaledVertexFormats = supportsScaledVertexFormats;
             SupportsSnormBufferTextureFormat = supportsSnormBufferTextureFormat;
             Supports5BitComponentFormat = supports5BitComponentFormat;
+            SupportsBindlessTextures = supportsBindlessTextures;
             SupportsBlendEquationAdvanced = supportsBlendEquationAdvanced;
             SupportsFragmentShaderInterlock = supportsFragmentShaderInterlock;
             SupportsFragmentShaderOrderingIntel = supportsFragmentShaderOrderingIntel;

src/Ryujinx.Graphics.GAL/IPipeline.cs

@@ -42,6 +42,10 @@ void DrawIndexed(
 
         void EndTransformFeedback();
 
+        void RegisterBindlessSampler(int samplerId, ISampler sampler);
+        void RegisterBindlessTexture(int textureId, ITexture texture, float textureScale);
+        void RegisterBindlessTextureAndSampler(int textureId, ITexture texture, float textureScale, int samplerId, ISampler sampler);
+
         void SetAlphaTest(bool enable, float reference, CompareOp op);
 
         void SetBlendState(AdvancedBlendDescriptor blend);

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

@@ -100,6 +100,9 @@ void Register<T>(CommandType commandType) where T : unmanaged, IGALCommand, IGAL
             Register<DrawTextureCommand>(CommandType.DrawTexture);
             Register<EndHostConditionalRenderingCommand>(CommandType.EndHostConditionalRendering);
             Register<EndTransformFeedbackCommand>(CommandType.EndTransformFeedback);
+            Register<RegisterBindlessSamplerCommand>(CommandType.RegisterBindlessSampler);
+            Register<RegisterBindlessTextureCommand>(CommandType.RegisterBindlessTexture);
+            Register<RegisterBindlessTextureAndSamplerCommand>(CommandType.RegisterBindlessTextureAndSampler);
             Register<SetAlphaTestCommand>(CommandType.SetAlphaTest);
             Register<SetBlendStateAdvancedCommand>(CommandType.SetBlendStateAdvanced);
             Register<SetBlendStateCommand>(CommandType.SetBlendState);

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

@@ -62,6 +62,9 @@ enum CommandType : byte
         DrawTexture,
         EndHostConditionalRendering,
         EndTransformFeedback,
+        RegisterBindlessSampler,
+        RegisterBindlessTexture,
+        RegisterBindlessTextureAndSampler,
         SetAlphaTest,
         SetBlendStateAdvanced,
         SetBlendState,

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

@@ -0,0 +1,23 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct RegisterBindlessSamplerCommand : IGALCommand, IGALCommand<RegisterBindlessSamplerCommand>
+    {
+        public readonly CommandType CommandType => CommandType.RegisterBindlessSampler;
+        private int _samplerId;
+        private TableRef<ISampler> _sampler;
+
+        public void Set(int samplerId, TableRef<ISampler> sampler)
+        {
+            _samplerId = samplerId;
+            _sampler = sampler;
+        }
+
+        public static void Run(ref RegisterBindlessSamplerCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.RegisterBindlessSampler(command._samplerId, command._sampler.GetAs<ThreadedSampler>(threaded)?.Base);
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct RegisterBindlessTextureAndSamplerCommand : IGALCommand, IGALCommand<RegisterBindlessTextureAndSamplerCommand>
+    {
+        public readonly CommandType CommandType => CommandType.RegisterBindlessTextureAndSampler;
+        private int _textureId;
+        private int _samplerId;
+        private TableRef<ITexture> _texture;
+        private TableRef<ISampler> _sampler;
+        private float _textureScale;
+
+        public void Set(int textureId, TableRef<ITexture> texture, float textureScale, int samplerId, TableRef<ISampler> sampler)
+        {
+            _textureId = textureId;
+            _samplerId = samplerId;
+            _textureScale = textureScale;
+            _texture = texture;
+            _sampler = sampler;
+        }
+
+        public static void Run(ref RegisterBindlessTextureAndSamplerCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.RegisterBindlessTextureAndSampler(
+                command._textureId,
+                command._texture.GetAs<ThreadedTexture>(threaded)?.Base,
+                command._textureScale,
+                command._samplerId,
+                command._sampler.GetAs<ThreadedSampler>(threaded)?.Base);
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct RegisterBindlessTextureCommand : IGALCommand, IGALCommand<RegisterBindlessTextureCommand>
+    {
+        public readonly CommandType CommandType => CommandType.RegisterBindlessTexture;
+        private int _textureId;
+        private TableRef<ITexture> _texture;
+        private float _textureScale;
+
+        public void Set(int textureId, TableRef<ITexture> texture, float textureScale)
+        {
+            _textureId = textureId;
+            _texture = texture;
+            _textureScale = textureScale;
+        }
+
+        public static void Run(ref RegisterBindlessTextureCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.RegisterBindlessTexture(command._textureId, command._texture.GetAs<ThreadedTexture>(threaded)?.Base, command._textureScale);
+        }
+    }
+}

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

@@ -123,6 +123,24 @@ public void EndTransformFeedback()
             _renderer.QueueCommand();
         }
 
+        public void RegisterBindlessSampler(int samplerId, ISampler sampler)
+        {
+            _renderer.New<RegisterBindlessSamplerCommand>().Set(samplerId, Ref(sampler));
+            _renderer.QueueCommand();
+        }
+
+        public void RegisterBindlessTexture(int textureId, ITexture texture, float textureScale)
+        {
+            _renderer.New<RegisterBindlessTextureCommand>().Set(textureId, Ref(texture), textureScale);
+            _renderer.QueueCommand();
+        }
+
+        public void RegisterBindlessTextureAndSampler(int textureId, ITexture texture, float textureScale, int samplerId, ISampler sampler)
+        {
+            _renderer.New<RegisterBindlessTextureAndSamplerCommand>().Set(textureId, Ref(texture), textureScale, samplerId, Ref(sampler));
+            _renderer.QueueCommand();
+        }
+
         public void SetAlphaTest(bool enable, float reference, CompareOp op)
         {
             _renderer.New<SetAlphaTestCommand>().Set(enable, reference, op);

src/Ryujinx.Graphics.GAL/ShaderInfo.cs

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

src/Ryujinx.Graphics.Gpu/Constants.cs

@@ -85,9 +85,39 @@ static class Constants
         /// </summary>
         public const int DriverReservedUniformBuffer = 0;
 
+        /// <summary>
+        /// Number of the uniform buffer reserved by the driver to store texture binding handles.
+        /// </summary>
+        public const int DriverReserveTextureBindingsBuffer = 2;
+
         /// <summary>
         /// Maximum size that an storage buffer is assumed to have when the correct size is unknown.
         /// </summary>
         public const ulong MaxUnknownStorageSize = 0x100000;
+
+        /// <summary>
+        /// Maximum width and height for 1D, 2D and cube textures, including array and multisample variants.
+        /// </summary>
+        public const int MaxTextureSize = 0x4000;
+
+        /// <summary>
+        /// Maximum width, height and depth for 3D textures.
+        /// </summary>
+        public const int Max3DTextureSize = 0x800;
+
+        /// <summary>
+        /// Maximum layers for array textures.
+        /// </summary>
+        public const int MaxArrayTextureLayers = 0x800;
+
+        /// <summary>
+        /// Maximum width (effectively the size in pixels) for buffer textures.
+        /// </summary>
+        public const int MaxBufferTextureSize = 0x8000000;
+
+        /// <summary>
+        /// Alignment in bytes for pitch linear textures.
+        /// </summary>
+        public const int LinearStrideAlignment = 0x20;
     }
 }

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

@@ -195,7 +195,6 @@ private void SendSignalingPcasB(int argument)
 
             // Should never return false for mismatching spec state, since the shader was fetched above.
             _channel.TextureManager.CommitComputeBindings(cs.SpecializationState);
-
             _channel.BufferManager.CommitComputeBindings();
 
             _context.Renderer.Pipeline.DispatchCompute(qmd.CtaRasterWidth, qmd.CtaRasterHeight, qmd.CtaRasterDepth);

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

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