Support VK_EXT_extended_dynamic_state and VK_EXT_extended_dynamic_state2

src/Ryujinx.Graphics.Vulkan/PipelineBase.cs

@@ -1,3 +1,5 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Shader;
 using Silk.NET.Vulkan;
@@ -74,6 +76,7 @@ namespace Ryujinx.Graphics.Vulkan
         private readonly BufferState[] _transformFeedbackBuffers;
         private readonly VertexBufferState[] _vertexBuffers;
         private ulong _vertexBuffersDirty;
+        private bool _bindingsSet;
         protected Rectangle<int> ClearScissor;
 
         private readonly VertexBufferUpdater _vertexBufferUpdater;
@@ -87,6 +90,9 @@ namespace Ryujinx.Graphics.Vulkan
         private bool _tfEnabled;
         private bool _tfActive;
 
+        private readonly bool _supportExtDynamic;
+        private readonly bool _supportExtDynamic2;
+
         private FeedbackLoopAspects _feedbackLoop;
         private bool _passWritesDepthStencil;
 
@@ -94,6 +100,8 @@ namespace Ryujinx.Graphics.Vulkan
         public ulong DrawCount { get; private set; }
         public bool RenderPassActive { get; private set; }
 
+        private readonly int[] _vertexBufferBindings;
+
         public unsafe PipelineBase(VulkanRenderer gd, Device device)
         {
             Gd = gd;
@@ -126,7 +134,19 @@ namespace Ryujinx.Graphics.Vulkan
 
             _storedBlend = new PipelineColorBlendAttachmentState[Constants.MaxRenderTargets];
 
-            _newState.Initialize();
+            _supportExtDynamic = gd.Capabilities.SupportsExtendedDynamicState;
+
+            _supportExtDynamic2 = gd.Capabilities.SupportsExtendedDynamicState2.ExtendedDynamicState2;
+
+            _bindingsSet = false;
+
+            _vertexBufferBindings = new int[Constants.MaxVertexBuffers];
+            for (int i = 0; i < Constants.MaxVertexBuffers; i++)
+            {
+                _vertexBufferBindings[i] = i + 1;
+            }
+
+            _newState.Initialize(gd.Capabilities);
         }
 
         public void Initialize()
@@ -632,19 +652,46 @@ namespace Ryujinx.Graphics.Vulkan
         {
             if (texture is TextureView srcTexture)
             {
-                var oldCullMode = _newState.CullMode;
-                var oldStencilTestEnable = _newState.StencilTestEnable;
-                var oldDepthTestEnable = _newState.DepthTestEnable;
-                var oldDepthWriteEnable = _newState.DepthWriteEnable;
-                var oldViewports = DynamicState.Viewports;
-                var oldViewportsCount = _newState.ViewportsCount;
-                var oldTopology = _topology;
+                CullModeFlags oldCullMode;
+                bool oldStencilTestEnable;
+                bool oldDepthTestEnable;
+                bool oldDepthWriteEnable;
+                PrimitiveTopology oldTopology;
+                Array16<Silk.NET.Vulkan.Viewport> oldViewports = DynamicState.Viewports;
+                uint oldViewportsCount;
 
-                _newState.CullMode = CullModeFlags.None;
-                _newState.StencilTestEnable = false;
-                _newState.DepthTestEnable = false;
-                _newState.DepthWriteEnable = false;
-                SignalStateChange();
+                if (_supportExtDynamic)
+                {
+                    oldCullMode = DynamicState.CullMode;
+                    oldStencilTestEnable = DynamicState.StencilTestEnable;
+                    oldDepthTestEnable = DynamicState.DepthTestEnable;
+                    oldDepthWriteEnable = DynamicState.DepthWriteEnable;
+                    oldTopology = _topology;
+                    oldViewportsCount = DynamicState.ViewportsCount;
+                }
+                else
+                {
+                    oldCullMode = _newState.CullMode;
+                    oldStencilTestEnable = _newState.StencilTestEnable;
+                    oldDepthTestEnable = _newState.DepthTestEnable;
+                    oldDepthWriteEnable = _newState.DepthWriteEnable;
+                    oldTopology = _topology;
+                    oldViewportsCount = _newState.ViewportsCount;
+                }
+
+                if (_supportExtDynamic)
+                {
+                    DynamicState.SetCullMode(CullModeFlags.None);
+                    DynamicState.SetDepthTestBool(false, false);
+                    DynamicState.SetStencilTest(false);
+                }
+                else
+                {
+                    _newState.CullMode = CullModeFlags.None;
+                    _newState.StencilTestEnable = false;
+                    _newState.DepthTestEnable = false;
+                    _newState.DepthWriteEnable = false;
+                }
 
                 Gd.HelperShader.DrawTexture(
                     Gd,
@@ -654,16 +701,24 @@ namespace Ryujinx.Graphics.Vulkan
                     srcRegion,
                     dstRegion);
 
-                _newState.CullMode = oldCullMode;
-                _newState.StencilTestEnable = oldStencilTestEnable;
-                _newState.DepthTestEnable = oldDepthTestEnable;
-                _newState.DepthWriteEnable = oldDepthWriteEnable;
+                if (_supportExtDynamic)
+                {
+                    DynamicState.SetCullMode(oldCullMode);
+                    DynamicState.SetStencilTest(oldStencilTestEnable);
+                    DynamicState.SetDepthTestBool(oldDepthTestEnable, oldDepthWriteEnable);
+                }
+                else
+                {
+                    _newState.CullMode = oldCullMode;
+                    _newState.StencilTestEnable = oldStencilTestEnable;
+                    _newState.DepthTestEnable = oldDepthTestEnable;
+                    _newState.DepthWriteEnable = oldDepthWriteEnable;
+                    _newState.ViewportsCount = oldViewportsCount;
+                }
+
                 SetPrimitiveTopology(oldTopology);
 
                 DynamicState.SetViewports(ref oldViewports, oldViewportsCount);
-
-                _newState.ViewportsCount = oldViewportsCount;
-                SignalStateChange();
             }
         }
 
@@ -792,48 +847,102 @@ namespace Ryujinx.Graphics.Vulkan
 
         public void SetDepthBias(PolygonModeMask enables, float factor, float units, float clamp)
         {
-            DynamicState.SetDepthBias(factor, units, clamp);
+            bool depthBiasEnable = (enables != 0) && (factor != 0 && units != 0);
+            bool changed = false;
 
-            _newState.DepthBiasEnable = enables != 0;
-            SignalStateChange();
-        }
+            if (_supportExtDynamic2)
+            {
+                DynamicState.SetDepthBiasEnable(depthBiasEnable);
+            }
+            else if (_newState.DepthBiasEnable != depthBiasEnable)
+            {
+                _newState.DepthBiasEnable = depthBiasEnable;
+                changed = true;
+            }
 
-        public void SetDepthClamp(bool clamp)
-        {
-            _newState.DepthClampEnable = clamp;
-            SignalStateChange();
-        }
+            if (depthBiasEnable)
+            {
+                DynamicState.SetDepthBias(factor, units, clamp);
+            }
 
-        public void SetDepthMode(DepthMode mode)
-        {
-            bool oldMode = _newState.DepthMode;
-            _newState.DepthMode = mode == DepthMode.MinusOneToOne;
-            if (_newState.DepthMode != oldMode)
+            if (changed)
             {
                 SignalStateChange();
             }
         }
 
-        public void SetDepthTest(DepthTestDescriptor depthTest)
+        public void SetDepthClamp(bool clamp)
         {
-            _newState.DepthTestEnable = depthTest.TestEnable;
-            _newState.DepthWriteEnable = depthTest.WriteEnable;
-            _newState.DepthCompareOp = depthTest.Func.Convert();
+            _newState.DepthClampEnable = clamp;
 
-            UpdatePassDepthStencil();
             SignalStateChange();
         }
 
-        public void SetFaceCulling(bool enable, Face face)
+        public void SetDepthMode(DepthMode mode)
         {
-            _newState.CullMode = enable ? face.Convert() : CullModeFlags.None;
+            bool newMode = mode == DepthMode.MinusOneToOne;
+
+            if (_newState.DepthMode == newMode)
+            {
+                return;
+            }
+
+            _newState.DepthMode = newMode;
+
             SignalStateChange();
         }
 
+        public void SetDepthTest(DepthTestDescriptor depthTest, bool signalChange = true)
+        {
+            if (_supportExtDynamic)
+            {
+                DynamicState.SetDepthTestBool(depthTest.TestEnable, depthTest.WriteEnable);
+                if (depthTest.TestEnable)
+                {
+                    DynamicState.SetDepthTestCompareOp(depthTest.Func.Convert());
+                }
+            }
+            else
+            {
+                _newState.DepthTestEnable = depthTest.TestEnable;
+                _newState.DepthWriteEnable = depthTest.WriteEnable;
+                _newState.DepthCompareOp = depthTest.Func.Convert();
+
+                if (signalChange)
+                {
+                    SignalStateChange();
+                }
+            }
+
+            UpdatePassDepthStencil();
+        }
+
+        public void SetFaceCulling(Face face)
+        {
+            if (_supportExtDynamic)
+            {
+                DynamicState.SetCullMode(face.Convert());
+            }
+            else
+            {
+                _newState.CullMode = face.Convert();
+
+                SignalStateChange();
+            }
+        }
+
         public void SetFrontFace(FrontFace frontFace)
         {
-            _newState.FrontFace = frontFace.Convert();
-            SignalStateChange();
+            if (_supportExtDynamic)
+            {
+                DynamicState.SetFrontFace(frontFace.Convert());
+            }
+            else
+            {
+                _newState.FrontFace = frontFace.Convert();
+
+                SignalStateChange();
+            }
         }
 
         public void SetImage(ShaderStage stage, int binding, ITexture image)
@@ -872,28 +981,56 @@ namespace Ryujinx.Graphics.Vulkan
 
         public void SetLineParameters(float width, bool smooth)
         {
-            _newState.LineWidth = width;
-            SignalStateChange();
+            if (!Gd.IsMoltenVk)
+            {
+                DynamicState.SetLineWidth(Gd.Capabilities.SupportsWideLines ? width : 1.0f);
+            }
         }
 
         public void SetLogicOpState(bool enable, LogicalOp op)
         {
+            // Vendors other than NVIDIA have a bug where it enables logical operations even for float formats,
+            // so we need to force disable them here.
+            bool logicOpEnable = enable && (Gd.Vendor == Vendor.Nvidia || _newState.Internal.LogicOpsAllowed);
+
             _newState.LogicOpEnable = enable;
-            _newState.LogicOp = op.Convert();
+
+            if (Gd.Capabilities.SupportsExtendedDynamicState2.ExtendedDynamicState2LogicOp)
+            {
+                if (logicOpEnable)
+                {
+                    DynamicState.SetLogicOp(op.Convert());
+                }
+            }
+            else
+            {
+                _newState.LogicOp = op.Convert();
+            }
+
             SignalStateChange();
         }
 
         public void SetMultisampleState(MultisampleDescriptor multisample)
         {
             _newState.AlphaToCoverageEnable = multisample.AlphaToCoverageEnable;
+
             _newState.AlphaToOneEnable = multisample.AlphaToOneEnable;
+
             SignalStateChange();
         }
 
         public void SetPatchParameters(int vertices, ReadOnlySpan<float> defaultOuterLevel, ReadOnlySpan<float> defaultInnerLevel)
         {
-            _newState.PatchControlPoints = (uint)vertices;
-            SignalStateChange();
+            if (Gd.Capabilities.SupportsExtendedDynamicState2.ExtendedDynamicState2PatchControlPoints)
+            {
+                DynamicState.SetPatchControlPoints((uint)vertices);
+            }
+            else
+            {
+                _newState.PatchControlPoints = (uint)vertices;
+
+                SignalStateChange();
+            }
 
             // TODO: Default levels (likely needs emulation on shaders?)
         }
@@ -910,12 +1047,21 @@ namespace Ryujinx.Graphics.Vulkan
 
         public void SetPrimitiveRestart(bool enable, int index)
         {
-            _newState.PrimitiveRestartEnable = enable;
+            if (_supportExtDynamic2)
+            {
+                DynamicState.SetPrimitiveRestartEnable(enable);
+            }
+            else
+            {
+                _newState.PrimitiveRestartEnable = enable;
+
+                SignalStateChange();
+            }
+
             // TODO: What to do about the index?
-            SignalStateChange();
         }
 
-        public void SetPrimitiveTopology(PrimitiveTopology topology)
+        public void SetPrimitiveTopology(PrimitiveTopology topology, bool signalChange = true)
         {
             _topology = topology;
 
@@ -923,10 +1069,18 @@ namespace Ryujinx.Graphics.Vulkan
 
             _newState.Topology = vkTopology;
 
-            SignalStateChange();
+            if (_supportExtDynamic)
+            {
+                DynamicState.SetPrimitiveTopology(vkTopology);
+            }
+
+            if (signalChange)
+            {
+                SignalStateChange();
+            }
         }
 
-        public void SetProgram(IProgram program)
+        public void SetProgram(IProgram program, bool signalChange = true)
         {
             var internalProgram = (ShaderCollection)program;
             var stages = internalProgram.GetInfos();
@@ -942,7 +1096,10 @@ namespace Ryujinx.Graphics.Vulkan
 
             stages.CopyTo(_newState.Stages.AsSpan()[..stages.Length]);
 
-            SignalStateChange();
+            if (signalChange)
+            {
+                SignalStateChange();
+            }
 
             if (internalProgram.IsCompute)
             {
@@ -968,18 +1125,26 @@ namespace Ryujinx.Graphics.Vulkan
 
         public void SetRasterizerDiscard(bool discard)
         {
-            _newState.RasterizerDiscardEnable = discard;
-            SignalStateChange();
+            if (_supportExtDynamic2)
+            {
+                DynamicState.SetRasterizerDiscard(discard);
+            }
+            else
+            {
+                _newState.RasterizerDiscardEnable = discard;
+
+                SignalStateChange();
+            }
 
             if (!discard && Gd.IsQualcommProprietary)
             {
                 // On Adreno, enabling rasterizer discard somehow corrupts the viewport state.
                 // Force it to be updated on next use to work around this bug.
-                DynamicState.ForceAllDirty();
+                DynamicState.ForceAllDirty(Gd);
             }
         }
 
-        public void SetRenderTargetColorMasks(ReadOnlySpan<uint> componentMask)
+        public void SetRenderTargetColorMasks(ReadOnlySpan<uint> componentMask, bool signalChange = true)
         {
             int count = Math.Min(Constants.MaxRenderTargets, componentMask.Length);
             int writtenAttachments = 0;
@@ -1019,7 +1184,10 @@ namespace Ryujinx.Graphics.Vulkan
             }
             else
             {
-                SignalStateChange();
+                if (signalChange)
+                {
+                    SignalStateChange();
+                }
 
                 if (writtenAttachments != _writtenAttachmentCount)
                 {
@@ -1043,7 +1211,7 @@ namespace Ryujinx.Graphics.Vulkan
             SetRenderTargetsInternal(colors, depthStencil, Gd.IsTBDR);
         }
 
-        public void SetScissors(ReadOnlySpan<Rectangle<int>> regions)
+        public void SetScissors(ReadOnlySpan<Rectangle<int>> regions, bool signalChange = true)
         {
             int maxScissors = Gd.Capabilities.SupportsMultiView ? Constants.MaxViewports : 1;
             int count = Math.Min(maxScissors, regions.Length);
@@ -1052,6 +1220,8 @@ namespace Ryujinx.Graphics.Vulkan
                 ClearScissor = regions[0];
             }
 
+            DynamicState.ScissorsCount = count;
+
             for (int i = 0; i < count; i++)
             {
                 var region = regions[i];
@@ -1061,34 +1231,56 @@ namespace Ryujinx.Graphics.Vulkan
                 DynamicState.SetScissor(i, new Rect2D(offset, extent));
             }
 
-            DynamicState.ScissorsCount = count;
+            if (!_supportExtDynamic)
+            {
+                _newState.ScissorsCount = (uint)count;
 
-            _newState.ScissorsCount = (uint)count;
-            SignalStateChange();
+                if (signalChange)
+                {
+                    SignalStateChange();
+                }
+            }
         }
 
         public void SetStencilTest(StencilTestDescriptor stencilTest)
         {
-            DynamicState.SetStencilMasks(
-                (uint)stencilTest.BackFuncMask,
+            if (_supportExtDynamic)
+            {
+                DynamicState.SetStencilTestandOp(
+                    stencilTest.BackSFail.Convert(),
+                    stencilTest.BackDpPass.Convert(),
+                    stencilTest.BackDpFail.Convert(),
+                    stencilTest.BackFunc.Convert(),
+                    stencilTest.FrontSFail.Convert(),
+                    stencilTest.FrontDpPass.Convert(),
+                    stencilTest.FrontDpFail.Convert(),
+                    stencilTest.FrontFunc.Convert(),
+                    stencilTest.TestEnable);
+
+                UpdatePassDepthStencil();
+            }
+            else
+            {
+                _newState.StencilBackFailOp = stencilTest.BackSFail.Convert();
+                _newState.StencilBackPassOp = stencilTest.BackDpPass.Convert();
+                _newState.StencilBackDepthFailOp = stencilTest.BackDpFail.Convert();
+                _newState.StencilBackCompareOp = stencilTest.BackFunc.Convert();
+                _newState.StencilFrontFailOp = stencilTest.FrontSFail.Convert();
+                _newState.StencilFrontPassOp = stencilTest.FrontDpPass.Convert();
+                _newState.StencilFrontDepthFailOp = stencilTest.FrontDpFail.Convert();
+                _newState.StencilFrontCompareOp = stencilTest.FrontFunc.Convert();
+                _newState.StencilTestEnable = stencilTest.TestEnable;
+
+                UpdatePassDepthStencil();
+                SignalStateChange();
+            }
+
+            DynamicState.SetStencilMask((uint)stencilTest.BackFuncMask,
                 (uint)stencilTest.BackMask,
                 (uint)stencilTest.BackFuncRef,
                 (uint)stencilTest.FrontFuncMask,
                 (uint)stencilTest.FrontMask,
                 (uint)stencilTest.FrontFuncRef);
-
-            _newState.StencilTestEnable = stencilTest.TestEnable;
-            _newState.StencilBackFailOp = stencilTest.BackSFail.Convert();
-            _newState.StencilBackPassOp = stencilTest.BackDpPass.Convert();
-            _newState.StencilBackDepthFailOp = stencilTest.BackDpFail.Convert();
-            _newState.StencilBackCompareOp = stencilTest.BackFunc.Convert();
-            _newState.StencilFrontFailOp = stencilTest.FrontSFail.Convert();
-            _newState.StencilFrontPassOp = stencilTest.FrontDpPass.Convert();
-            _newState.StencilFrontDepthFailOp = stencilTest.FrontDpFail.Convert();
-            _newState.StencilFrontCompareOp = stencilTest.FrontFunc.Convert();
-
-            UpdatePassDepthStencil();
-            SignalStateChange();
         }
 
         public void SetStorageBuffers(ReadOnlySpan<BufferAssignment> buffers)
@@ -1207,12 +1399,24 @@ namespace Ryujinx.Graphics.Vulkan
         {
             int count = Math.Min(Constants.MaxVertexBuffers, vertexBuffers.Length);
 
-            _newState.Internal.VertexBindingDescriptions[0] = new VertexInputBindingDescription(0, 0, VertexInputRate.Vertex);
-
             int validCount = 1;
 
+            if (!_bindingsSet)
+            {
+                _newState.Internal.VertexBindingDescriptions[0] = new VertexInputBindingDescription(0, _supportExtDynamic && (!Gd.IsMoltenVk || Gd.SupportsMTL31) ? null : 0, VertexInputRate.Vertex);
+
+                for (int i = 1; i < count; i++)
+                {
+                    _newState.Internal.VertexBindingDescriptions[i] = new VertexInputBindingDescription((uint)i);
+                }
+
+                _bindingsSet = true;
+            }
+
             BufferHandle lastHandle = default;
             Auto<DisposableBuffer> lastBuffer = default;
+            bool vertexBindingDescriptionChanged = false;
+            bool vertexDescriptionCountChanged = false;
 
             for (int i = 0; i < count; i++)
             {
@@ -1231,13 +1435,32 @@ namespace Ryujinx.Graphics.Vulkan
 
                     if (vb != null)
                     {
-                        int binding = i + 1;
                         int descriptorIndex = validCount++;
 
-                        _newState.Internal.VertexBindingDescriptions[descriptorIndex] = new VertexInputBindingDescription(
-                            (uint)binding,
-                            (uint)vertexBuffer.Stride,
-                            inputRate);
+                        if (_supportExtDynamic && (!Gd.IsMoltenVk || Gd.SupportsMTL31))
+                        {
+                            if (_newState.Internal.VertexBindingDescriptions[descriptorIndex].InputRate != inputRate ||
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].Binding != _vertexBufferBindings[i])
+                            {
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].InputRate = inputRate;
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].Binding = (uint)_vertexBufferBindings[i];
+
+                                vertexBindingDescriptionChanged = true;
+                            }
+                        }
+                        else
+                        {
+                            if (_newState.Internal.VertexBindingDescriptions[descriptorIndex].InputRate != inputRate ||
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].Stride != vertexBuffer.Stride ||
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].Binding != _vertexBufferBindings[i])
+                            {
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].Binding = (uint)_vertexBufferBindings[i];
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].Stride = (uint)vertexBuffer.Stride;
+                                _newState.Internal.VertexBindingDescriptions[descriptorIndex].InputRate = inputRate;
+
+                                vertexBindingDescriptionChanged = true;
+                            }
+                        }
 
                         int vbSize = vertexBuffer.Buffer.Size;
 
@@ -1253,7 +1476,7 @@ namespace Ryujinx.Graphics.Vulkan
                             }
                         }
 
-                        ref var buffer = ref _vertexBuffers[binding];
+                        ref var buffer = ref _vertexBuffers[_vertexBufferBindings[i]];
                         int oldScalarAlign = buffer.AttributeScalarAlignment;
 
                         if (Gd.Capabilities.VertexBufferAlignment < 2 &&
@@ -1270,7 +1493,7 @@ namespace Ryujinx.Graphics.Vulkan
                                     vbSize,
                                     vertexBuffer.Stride);
 
-                                buffer.BindVertexBuffer(Gd, Cbs, (uint)binding, ref _newState, _vertexBufferUpdater);
+                                buffer.BindVertexBuffer(Gd, Cbs, (uint)_vertexBufferBindings[i], ref _newState, _vertexBufferUpdater);
                             }
                         }
                         else
@@ -1286,7 +1509,7 @@ namespace Ryujinx.Graphics.Vulkan
                                 vbSize,
                                 vertexBuffer.Stride);
 
-                            _vertexBuffersDirty |= 1UL << binding;
+                            _vertexBuffersDirty |= 1UL << _vertexBufferBindings[i];
                         }
 
                         buffer.AttributeScalarAlignment = oldScalarAlign;
@@ -1296,11 +1519,19 @@ namespace Ryujinx.Graphics.Vulkan
 
             _vertexBufferUpdater.Commit(Cbs);
 
-            _newState.VertexBindingDescriptionsCount = (uint)validCount;
-            SignalStateChange();
+            if (_newState.VertexBindingDescriptionsCount != validCount)
+            {
+                _newState.VertexBindingDescriptionsCount = (uint)validCount;
+                vertexDescriptionCountChanged = true;
+            }
+
+            if (vertexDescriptionCountChanged || vertexBindingDescriptionChanged)
+            {
+                SignalStateChange();
+            }
         }
 
-        public void SetViewports(ReadOnlySpan<Viewport> viewports)
+        public void SetViewports(ReadOnlySpan<Viewport> viewports, bool signalChange = true)
         {
             int maxViewports = Gd.Capabilities.SupportsMultiView ? Constants.MaxViewports : 1;
             int count = Math.Min(maxViewports, viewports.Length);
@@ -1325,8 +1556,15 @@ namespace Ryujinx.Graphics.Vulkan
                     Clamp(viewport.DepthFar)));
             }
 
-            _newState.ViewportsCount = (uint)count;
-            SignalStateChange();
+            if (!_supportExtDynamic)
+            {
+                _newState.ViewportsCount = (uint)count;
+
+                if (signalChange)
+                {
+                    SignalStateChange();
+                }
+            }
         }
 
         public void SwapBuffer(Auto<DisposableBuffer> from, Auto<DisposableBuffer> to)
@@ -1375,7 +1613,7 @@ namespace Ryujinx.Graphics.Vulkan
             _vertexBuffersDirty = ulong.MaxValue >> (64 - _vertexBuffers.Length);
 
             _descriptorSetUpdater.SignalCommandBufferChange();
-            DynamicState.ForceAllDirty();
+            DynamicState.ForceAllDirty(Gd);
             _currentPipelineHandle = 0;
         }
 
@@ -1529,9 +1767,10 @@ namespace Ryujinx.Graphics.Vulkan
             {
                 if (Gd.Capabilities.SupportsDynamicAttachmentFeedbackLoop)
                 {
+                    _newState.FeedbackLoopDynamicState = true;
                     DynamicState.SetFeedbackLoop(aspects);
                 }
-                else
+                else if (Gd.Capabilities.SupportsAttachmentFeedbackLoop)
                 {
                     _newState.FeedbackLoopAspects = aspects;
                 }
@@ -1591,7 +1830,14 @@ namespace Ryujinx.Graphics.Vulkan
             }
 
             // Stencil test being enabled doesn't necessarily mean a write, but it's not critical to check.
-            _passWritesDepthStencil |= (_newState.DepthTestEnable && _newState.DepthWriteEnable) || _newState.StencilTestEnable;
+            if (_supportExtDynamic)
+            {
+                _passWritesDepthStencil |= (DynamicState.DepthTestEnable && DynamicState.DepthWriteEnable) || DynamicState.StencilTestEnable;
+            }
+            else
+            {
+                _passWritesDepthStencil |= (_newState.DepthTestEnable && _newState.DepthWriteEnable) || _newState.StencilTestEnable;
+            }
         }
 
         private bool RecreateGraphicsPipelineIfNeeded()