src/Ryujinx.Graphics.Metal/EncoderState.cs

@@ -54,10 +54,10 @@ namespace Ryujinx.Graphics.Metal
     record struct TextureRef
     {
         public ShaderStage Stage;
-        public TextureBase Storage;
+        public Texture Storage;
         public Sampler Sampler;
 
-        public TextureRef(ShaderStage stage, TextureBase storage, Sampler sampler)
+        public TextureRef(ShaderStage stage, Texture storage, Sampler sampler)
         {
             Stage = stage;
             Storage = storage;

src/Ryujinx.Graphics.Metal/EncoderStateManager.cs

@@ -805,9 +805,13 @@ namespace Ryujinx.Graphics.Metal
 
         public readonly void UpdateTextureAndSampler(ShaderStage stage, ulong binding, TextureBase texture, Sampler sampler)
         {
-            if (texture != null)
+            if (texture is TextureBuffer)
             {
-                _currentState.TextureRefs[binding] = new(stage, texture, sampler);
+                // TODO: Texture buffers
+            }
+            else if (texture is Texture view)
+            {
+                _currentState.TextureRefs[binding] = new(stage, view, sampler);
             }
             else
             {
@@ -1120,52 +1124,59 @@ namespace Ryujinx.Graphics.Metal
                     case MetalRenderer.TextureSetIndex:
                         if (!segment.IsArray)
                         {
-                            for (int i = 0; i < count; i++)
+                            if (segment.Type != ResourceType.BufferTexture)
                             {
-                                int index = binding + i;
+                                for (int i = 0; i < count; i++)
-
-                                ref var texture = ref _currentState.TextureRefs[index];
-
-                                var storage = texture.Storage;
-
-                                if (storage == null)
                                 {
-                                    continue;
+                                    int index = binding + i;
-                                }
 
-                                var mtlTexture = storage.GetHandle();
+                                    ref var texture = ref _currentState.TextureRefs[index];
 
-                                MTLRenderStages renderStages = 0;
+                                    var storage = texture.Storage;
 
-                                if ((segment.Stages & ResourceStages.Vertex) != 0)
+                                    if (storage == null)
-                                {
-                                    vertResourceIds[vertResourceIdIndex] = mtlTexture.GpuResourceID._impl;
-                                    vertResourceIdIndex++;
-
-                                    if (texture.Sampler != null)
                                     {
-                                        vertResourceIds[vertResourceIdIndex] = texture.Sampler.GetSampler().GpuResourceID._impl;
+                                        continue;
+                                    }
+
+                                    var mtlTexture = storage.GetHandle();
+
+                                    MTLRenderStages renderStages = 0;
+
+                                    if ((segment.Stages & ResourceStages.Vertex) != 0)
+                                    {
+                                        vertResourceIds[vertResourceIdIndex] = mtlTexture.GpuResourceID._impl;
                                         vertResourceIdIndex++;
+
+                                        if (texture.Sampler != null)
+                                        {
+                                            vertResourceIds[vertResourceIdIndex] = texture.Sampler.GetSampler().GpuResourceID._impl;
+                                            vertResourceIdIndex++;
+                                        }
+
+                                        renderStages |= MTLRenderStages.RenderStageVertex;
                                     }
 
-                                    renderStages |= MTLRenderStages.RenderStageVertex;
+                                    if ((segment.Stages & ResourceStages.Fragment) != 0)
-                                }
-
-                                if ((segment.Stages & ResourceStages.Fragment) != 0)
-                                {
-                                    fragResourceIds[fragResourceIdIndex] = mtlTexture.GpuResourceID._impl;
-                                    fragResourceIdIndex++;
-
-                                    if (texture.Sampler != null)
                                     {
-                                        fragResourceIds[fragResourceIdIndex] = texture.Sampler.GetSampler().GpuResourceID._impl;
+                                        fragResourceIds[fragResourceIdIndex] = mtlTexture.GpuResourceID._impl;
                                         fragResourceIdIndex++;
+
+                                        if (texture.Sampler != null)
+                                        {
+                                            fragResourceIds[fragResourceIdIndex] = texture.Sampler.GetSampler().GpuResourceID._impl;
+                                            fragResourceIdIndex++;
+                                        }
+
+                                        renderStages |= MTLRenderStages.RenderStageFragment;
                                     }
 
-                                    renderStages |= MTLRenderStages.RenderStageFragment;
+                                    renderCommandEncoder.UseResource(new MTLResource(mtlTexture.NativePtr), MTLResourceUsage.Read, renderStages);
                                 }
-
+                            }
-                                renderCommandEncoder.UseResource(new MTLResource(mtlTexture.NativePtr), MTLResourceUsage.Read, renderStages);
+                            else
+                            {
+                                // TODO: Buffer textures
                             }
                         }
                         else
@@ -1332,34 +1343,41 @@ namespace Ryujinx.Graphics.Metal
                     case MetalRenderer.TextureSetIndex:
                         if (!segment.IsArray)
                         {
-                            for (int i = 0; i < count; i++)
+                            if (segment.Type != ResourceType.BufferTexture)
                             {
-                                int index = binding + i;
+                                for (int i = 0; i < count; i++)
-
-                                ref var texture = ref _currentState.TextureRefs[index];
-
-                                var storage = texture.Storage;
-
-                                if (storage == null)
                                 {
-                                    continue;
+                                    int index = binding + i;
-                                }
 
-                                var mtlTexture = storage.GetHandle();
+                                    ref var texture = ref _currentState.TextureRefs[index];
 
-                                if (segment.Stages.HasFlag(ResourceStages.Compute))
+                                    var storage = texture.Storage;
-                                {
-                                    computeCommandEncoder.UseResource(new MTLResource(mtlTexture.NativePtr), MTLResourceUsage.Read);
-                                    resourceIds[resourceIdIndex] = mtlTexture.GpuResourceID._impl;
-                                    resourceIdIndex++;
 
-                                    if (texture.Sampler != null)
+                                    if (storage == null)
                                     {
-                                        resourceIds[resourceIdIndex] = texture.Sampler.GetSampler().GpuResourceID._impl;
+                                        continue;
+                                    }
+
+                                    var mtlTexture = storage.GetHandle();
+
+                                    if (segment.Stages.HasFlag(ResourceStages.Compute))
+                                    {
+                                        computeCommandEncoder.UseResource(new MTLResource(mtlTexture.NativePtr), MTLResourceUsage.Read);
+                                        resourceIds[resourceIdIndex] = mtlTexture.GpuResourceID._impl;
                                         resourceIdIndex++;
+
+                                        if (texture.Sampler != null)
+                                        {
+                                            resourceIds[resourceIdIndex] = texture.Sampler.GetSampler().GpuResourceID._impl;
+                                            resourceIdIndex++;
+                                        }
                                     }
                                 }
                             }
+                            else
+                            {
+                                // TODO: Buffer textures
+                            }
                         }
                         else
                         {

src/Ryujinx.Graphics.Metal/Program.cs

@@ -28,6 +28,7 @@ namespace Ryujinx.Graphics.Metal
         private MTLComputePipelineState? _computePipelineCache;
         private bool _firstBackgroundUse;
 
+        public ResourceBindingSegment[][] ClearSegments { get; }
         public ResourceBindingSegment[][] BindingSegments { get; }
         // Argument buffer sizes for Vertex or Compute stages
         public int[] ArgumentBufferSizes { get; }
@@ -52,6 +53,7 @@ namespace Ryujinx.Graphics.Metal
                 _handles[i] = device.NewLibrary(StringHelper.NSString(shader.Code), compileOptions, (library, error) => CompilationResultHandler(library, error, index));
             }
 
+            ClearSegments = BuildClearSegments(resourceLayout.Sets);
             (BindingSegments, ArgumentBufferSizes, FragArgumentBufferSizes) = BuildBindingSegments(resourceLayout.SetUsages);
         }
 
@@ -96,6 +98,62 @@ namespace Ryujinx.Graphics.Metal
             }
         }
 
+        private static ResourceBindingSegment[][] BuildClearSegments(ReadOnlyCollection<ResourceDescriptorCollection> sets)
+        {
+            ResourceBindingSegment[][] segments = new ResourceBindingSegment[sets.Count][];
+
+            for (int setIndex = 0; setIndex < sets.Count; setIndex++)
+            {
+                List<ResourceBindingSegment> currentSegments = new();
+
+                ResourceDescriptor currentDescriptor = default;
+                int currentCount = 0;
+
+                for (int index = 0; index < sets[setIndex].Descriptors.Count; index++)
+                {
+                    ResourceDescriptor descriptor = sets[setIndex].Descriptors[index];
+
+                    if (currentDescriptor.Binding + currentCount != descriptor.Binding ||
+                        currentDescriptor.Type != descriptor.Type ||
+                        currentDescriptor.Stages != descriptor.Stages ||
+                        currentDescriptor.Count > 1 ||
+                        descriptor.Count > 1)
+                    {
+                        if (currentCount != 0)
+                        {
+                            currentSegments.Add(new ResourceBindingSegment(
+                                currentDescriptor.Binding,
+                                currentCount,
+                                currentDescriptor.Type,
+                                currentDescriptor.Stages,
+                                currentDescriptor.Count > 1));
+                        }
+
+                        currentDescriptor = descriptor;
+                        currentCount = descriptor.Count;
+                    }
+                    else
+                    {
+                        currentCount += descriptor.Count;
+                    }
+                }
+
+                if (currentCount != 0)
+                {
+                    currentSegments.Add(new ResourceBindingSegment(
+                        currentDescriptor.Binding,
+                        currentCount,
+                        currentDescriptor.Type,
+                        currentDescriptor.Stages,
+                        currentDescriptor.Count > 1));
+                }
+
+                segments[setIndex] = currentSegments.ToArray();
+            }
+
+            return segments;
+        }
+
         private static (ResourceBindingSegment[][], int[], int[]) BuildBindingSegments(ReadOnlyCollection<ResourceUsageCollection> setUsages)
         {
             ResourceBindingSegment[][] segments = new ResourceBindingSegment[setUsages.Count][];