fixes vulkan issues and android settings (#105)

- removes provoking vertex, vertex input, dynamic state if not supported
- moves dynamic state to be a 0-3 slider and vertex input its own checkbox
- the rich presence was disabled on linux.
- there were duplicate settings in "edens veil"?
- weird behavior of the vertex input checkbox on per game setting
- adds xenoblade 2 to the d24 conversion control function
- adds the flush logs by line setting to android.
- adds the memory layout setting to android
- Adds the option to show building shaders on the android overlay.

Signed-off-by: Aleksandr Popovich <alekpopo@pm.me>
Co-authored-by: swurl <swurl@swurl.xyz>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/105
Co-authored-by: Aleksandr Popovich <alekpopo@pm.me>
Co-committed-by: Aleksandr Popovich <alekpopo@pm.me>

6 files changed, 241 insertions, 196 deletions

diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
index 4b4331d2f4..c2ed3a5719 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -803,6 +803,9 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE,
         VK_DYNAMIC_STATE_LINE_WIDTH,         VK_DYNAMIC_STATE_LINE_STIPPLE,
     };
+    if (key.state.dynamic_vertex_input) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
+    }
     if (key.state.extended_dynamic_state) {
         static constexpr std::array extended{
             VK_DYNAMIC_STATE_CULL_MODE_EXT,
@@ -815,9 +818,6 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
             VK_DYNAMIC_STATE_STENCIL_OP_EXT,
         };
-        if (key.state.dynamic_vertex_input) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
-        }
         dynamic_states.insert(dynamic_states.end(), extended.begin(), extended.end());
         if (key.state.extended_dynamic_state_2) {
             static constexpr std::array extended2{
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index 27efc02e69..82d68e59f4 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -128,7 +128,8 @@ Shader::AttributeType CastAttributeType(const FixedPipelineState::VertexAttribut
     return Shader::AttributeType::Float;
 }
 
-Shader::AttributeType AttributeType(const FixedPipelineState& state, size_t index) {
+Shader::AttributeType AttributeType(const FixedPipelineState& state, size_t index)
+{
     switch (state.DynamicAttributeType(index)) {
     case 0:
         return Shader::AttributeType::Disabled;
@@ -179,7 +180,8 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
                 info.generic_input_types[index] = AttributeType(key.state, index);
             }
         } else {
-            std::ranges::transform(key.state.attributes, info.generic_input_types.begin(),
+            std::ranges::transform(key.state.attributes,
+                                   info.generic_input_types.begin(),
                                    &CastAttributeType);
         }
         break;
@@ -403,17 +405,23 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
     }
 
     const u8 dynamic_state = Settings::values.dyna_state.GetValue();
-    const bool dynamic_state3 = dynamic_state == 2 && Settings::values.dyna_state3.GetValue();
+
+    const bool vertex_input = Settings::values.vertex_input.GetValue();
 
     LOG_INFO(Render_Vulkan, "DynamicState value is set to {}", (u32) dynamic_state);
-    LOG_INFO(Render_Vulkan, "DynamicState3 value is set to {}", dynamic_state3);
+
     dynamic_features = DynamicFeatures{
-        .has_extended_dynamic_state =           device.IsExtExtendedDynamicStateSupported() && dynamic_state > 0,
-        .has_extended_dynamic_state_2 =         device.IsExtExtendedDynamicState2Supported() && dynamic_state > 1,
-        .has_extended_dynamic_state_2_extra =   device.IsExtExtendedDynamicState2ExtrasSupported() && dynamic_state > 1,
-        .has_extended_dynamic_state_3_blend =   device.IsExtExtendedDynamicState3BlendingSupported() && dynamic_state3,
-        .has_extended_dynamic_state_3_enables = device.IsExtExtendedDynamicState3EnablesSupported() && dynamic_state3,
-        .has_dynamic_vertex_input = device.IsExtVertexInputDynamicStateSupported(),// && dynamic_state3,
+        .has_extended_dynamic_state = device.IsExtExtendedDynamicStateSupported()
+                                      && dynamic_state > 0,
+        .has_extended_dynamic_state_2 = device.IsExtExtendedDynamicState2Supported()
+                                        && dynamic_state > 1,
+        .has_extended_dynamic_state_2_extra = device.IsExtExtendedDynamicState2ExtrasSupported()
+                                              && dynamic_state > 1,
+        .has_extended_dynamic_state_3_blend = device.IsExtExtendedDynamicState3BlendingSupported()
+                                              && dynamic_state > 2,
+        .has_extended_dynamic_state_3_enables = device.IsExtExtendedDynamicState3EnablesSupported()
+                                                && dynamic_state > 2,
+        .has_dynamic_vertex_input = device.IsExtVertexInputDynamicStateSupported() && vertex_input,
     };
 
     LOG_INFO(Render_Vulkan, "DynamicState1: {}", dynamic_features.has_extended_dynamic_state);
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index d0cff37f61..62c057bfb4 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -952,28 +952,28 @@ void RasterizerVulkan::UpdateDynamicStates() {
                 UpdateDepthBiasEnable(regs);
             }
             if (device.IsExtExtendedDynamicState3EnablesSupported()) {
-                using namespace Tegra::Engines;

-

-                if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE

-                    || device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {

-                    struct In {

-                        const Maxwell3D::Regs::VertexAttribute::Type d;

-                        In(Maxwell3D::Regs::VertexAttribute::Type n) : d(n) {}

-                        bool operator()(Maxwell3D::Regs::VertexAttribute n) const {

-                            return n.type == d;

-                        }

-                    };

-

-                    auto has_float = std::any_of(

-                        regs.vertex_attrib_format.begin(), regs.vertex_attrib_format.end(),

-                        In(Maxwell3D::Regs::VertexAttribute::Type::Float));

-

-                    if (regs.logic_op.enable)

-                        regs.logic_op.enable = static_cast<u32>(!has_float);

-

-                    UpdateLogicOpEnable(regs);

-                } else

-                    UpdateLogicOpEnable(regs);

+                using namespace Tegra::Engines;
+
+                if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE
+                    || device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {
+                    struct In {
+                        const Maxwell3D::Regs::VertexAttribute::Type d;
+                        In(Maxwell3D::Regs::VertexAttribute::Type n) : d(n) {}
+                        bool operator()(Maxwell3D::Regs::VertexAttribute n) const {
+                            return n.type == d;
+                        }
+                    };
+
+                    auto has_float = std::any_of(
+                        regs.vertex_attrib_format.begin(), regs.vertex_attrib_format.end(),
+                        In(Maxwell3D::Regs::VertexAttribute::Type::Float));
+
+                    if (regs.logic_op.enable)
+                        regs.logic_op.enable = static_cast<u32>(!has_float);
+
+                    UpdateLogicOpEnable(regs);
+                } else
+                    UpdateLogicOpEnable(regs);
                 UpdateDepthClampEnable(regs);
             }
         }
@@ -1103,12 +1103,21 @@ void RasterizerVulkan::UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs) {
                         regs.zeta.format == Tegra::DepthFormat::X8Z24_UNORM ||
                         regs.zeta.format == Tegra::DepthFormat::S8Z24_UNORM ||
                         regs.zeta.format == Tegra::DepthFormat::V8Z24_UNORM;
-    if (is_d24 && !device.SupportsD24DepthBuffer() && program_id == 0x1006A800016E000ULL) {
-        // Only activate this in Super Smash Brothers Ultimate
+
+    size_t length = sizeof(NEEDS_D24) / sizeof(u64);
+    bool needs_convert = false;
+    for (size_t i = 0; i < length; ++i) {
+        if (NEEDS_D24[i] == program_id) {
+            needs_convert = true;
+            break;
+        }
+    }
+
+    if (is_d24 && !device.SupportsD24DepthBuffer() && needs_convert) {
         // the base formulas can be obtained from here:
         //   https://docs.microsoft.com/en-us/windows/win32/direct3d11/d3d10-graphics-programming-guide-output-merger-stage-depth-bias
-        const double rescale_factor =
-            static_cast<double>(1ULL << (32 - 24)) / (static_cast<double>(0x1.ep+127));
+        const double rescale_factor = static_cast<double>(1ULL << (32 - 24))
+                                      / (static_cast<double>(0x1.ep+127));
         units = static_cast<float>(static_cast<double>(units) * rescale_factor);
     }
     scheduler.Record([constant = units, clamp = regs.depth_bias_clamp,
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.h b/src/video_core/renderer_vulkan/vk_rasterizer.h
index 0617b37f05..33bc6cd8e4 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.h
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.h
@@ -144,6 +144,10 @@ private:
     static constexpr size_t MAX_IMAGE_VIEWS = MAX_TEXTURES + MAX_IMAGES;
 
     static constexpr VkDeviceSize DEFAULT_BUFFER_SIZE = 4 * sizeof(float);
+    static constexpr u64 NEEDS_D24[] = {
+        0x1006A800016E000ULL,  // SSBU
+        0x0100E95004038000ULL, // XC2
+    };
 
     template <typename Func>
     void PrepareDraw(bool is_indexed, Func&&);
diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp
index f0b3ed4e6b..9607487a50 100644
--- a/src/video_core/vulkan_common/vulkan_device.cpp
+++ b/src/video_core/vulkan_common/vulkan_device.cpp
@@ -459,6 +459,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         first_next = &diagnostics_nv;
     }
 
+    // TODO(alekpop): impl is incomplete, needs the settings to be assigned.
     VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing{
         .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT,
         .pNext = use_diagnostics_nv ? static_cast<void*>(&diagnostics_nv) : static_cast<void*>(&features2),
@@ -491,17 +492,20 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     CollectPhysicalMemoryInfo();
     CollectToolingInfo();
 
+    // TODO(alekpop): many things here are still applying and need to be changed to match the real behaviors.
+
     if (is_qualcomm || is_turnip) {
         LOG_WARNING(Render_Vulkan,
                     "Qualcomm and Turnip drivers have broken VK_EXT_custom_border_color");
-        //RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
-        //VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.custom_border_color,
+                               features.custom_border_color,
+                               VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
     }
 
     if (is_qualcomm) {
         LOG_WARNING(Render_Vulkan,
                     "Qualcomm drivers have a slow VK_KHR_push_descriptor implementation");
-        //RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
+        RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
 
 #if defined(ANDROID) && defined(ARCHITECTURE_arm64)
         // Patch the driver to enable BCn textures.
@@ -535,7 +539,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         } else if (arch <= NvidiaArchitecture::Arch_Volta) {
             if (nv_major_version < 527) {
                 LOG_WARNING(Render_Vulkan, "Volta and older have broken VK_KHR_push_descriptor");
-                //RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
+                RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
             }
         }
         if (nv_major_version >= 510) {
@@ -543,15 +547,16 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             cant_blit_msaa = true;
         }
     }
+
     if (extensions.extended_dynamic_state && is_radv) {
         // Mask driver version variant
         const u32 version = (properties.properties.driverVersion << 3) >> 3;
         if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
             LOG_WARNING(Render_Vulkan,
                         "RADV versions older than 21.2 have broken VK_EXT_extended_dynamic_state");
-            //RemoveExtensionFeature(extensions.extended_dynamic_state,
-            //features.extended_dynamic_state,
-            //VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+            RemoveExtensionFeature(extensions.extended_dynamic_state,
+                                   features.extended_dynamic_state,
+                                   VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
         }
     }
     if (extensions.extended_dynamic_state2 && is_radv) {
@@ -560,9 +565,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             LOG_WARNING(
                 Render_Vulkan,
                 "RADV versions older than 22.3.1 have broken VK_EXT_extended_dynamic_state2");
-            // RemoveExtensionFeature(extensions.extended_dynamic_state2,
-            //        features.extended_dynamic_state2,
-            //      VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+            RemoveExtensionFeature(extensions.extended_dynamic_state2,
+                                   features.extended_dynamic_state2,
+                                   VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
         }
     }
     if (extensions.extended_dynamic_state2 && is_qualcomm) {
@@ -572,53 +577,54 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             // Qualcomm Adreno 7xx drivers do not properly support extended_dynamic_state2.
             LOG_WARNING(Render_Vulkan,
                         "Qualcomm Adreno 7xx drivers have broken VK_EXT_extended_dynamic_state2");
-            //RemoveExtensionFeature(extensions.extended_dynamic_state2,
-            //features.extended_dynamic_state2,
-            //VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+            RemoveExtensionFeature(extensions.extended_dynamic_state2,
+                                   features.extended_dynamic_state2,
+                                   VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
         }
     }
     if (extensions.extended_dynamic_state3 && is_radv) {
         LOG_WARNING(Render_Vulkan, "RADV has broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = true;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = true;
-        dynamic_state3_blending = true;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+        dynamic_state3_blending = false;
 
         const u32 version = (properties.properties.driverVersion << 3) >> 3;
         if (version < VK_MAKE_API_VERSION(0, 23, 1, 0)) {
             LOG_WARNING(Render_Vulkan,
                         "RADV versions older than 23.1.0 have broken depth clamp dynamic state");
-            features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = true;
-            dynamic_state3_enables = true;
+            features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = false;
+            dynamic_state3_enables = false;
         }
     }
     if (extensions.extended_dynamic_state3 && (is_amd_driver || driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY)) {
         // AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation
         LOG_WARNING(Render_Vulkan,
                     "AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = true;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = true;
-        dynamic_state3_blending = true;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+        dynamic_state3_blending = false;
     }
     if (extensions.vertex_input_dynamic_state && is_radv) {
-        // TODO(ameerj): Blacklist only offending driver versions
-        // TODO(ameerj): Confirm if RDNA1 is affected
+        // TODO(alekpop): Blacklist only offending driver versions
+        // NOTE(alekpop): It still affects the latest RADV.
+        // TODO(alekpop): Confirm if RDNA1 is affected
         const bool is_rdna2 =
             supported_extensions.contains(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
         if (is_rdna2) {
             LOG_WARNING(Render_Vulkan,
                         "RADV has broken VK_EXT_vertex_input_dynamic_state on RDNA2 hardware");
-            //  RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-            //      features.vertex_input_dynamic_state,
-            //    VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                                   features.vertex_input_dynamic_state,
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
         }
     }
     if (extensions.vertex_input_dynamic_state && is_qualcomm) {
         // Qualcomm drivers do not properly support vertex_input_dynamic_state.
         LOG_WARNING(Render_Vulkan,
                     "Qualcomm drivers have broken VK_EXT_vertex_input_dynamic_state");
-        //RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-        //  features.vertex_input_dynamic_state,
-        //     VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                               features.vertex_input_dynamic_state,
+                               VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
     }
 
     sets_per_pool = 64;
@@ -652,9 +658,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         const u32 version = (properties.properties.driverVersion << 3) >> 3;
         if (version < VK_MAKE_API_VERSION(27, 20, 100, 0)) {
             LOG_WARNING(Render_Vulkan, "Intel has broken VK_EXT_vertex_input_dynamic_state");
-            //RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-            //features.vertex_input_dynamic_state,
-            //VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                                   features.vertex_input_dynamic_state,
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
         }
     }
     if (features.shader_float16_int8.shaderFloat16 && is_intel_windows) {
@@ -681,14 +687,14 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             // mesa/mesa/-/commit/ff91c5ca42bc80aa411cb3fd8f550aa6fdd16bdc
             LOG_WARNING(Render_Vulkan,
                         "ANV drivers 22.3.0 to 23.1.0 have broken VK_KHR_push_descriptor");
-            //RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
+            RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
         }
     } else if (extensions.push_descriptor && is_nvidia) {
         const auto arch = GetNvidiaArch();
         if (arch <= NvidiaArchitecture::Arch_Pascal) {
             LOG_WARNING(Render_Vulkan,
                         "Pascal and older architectures have broken VK_KHR_push_descriptor");
-            //RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
+            RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
         }
     }
 
@@ -722,33 +728,8 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         dynamic_state3_enables = true;
     }
 
-    if (Settings::values.dyna_state.GetValue() == 0) {
-        must_emulate_scaled_formats = true;
-        LOG_INFO(Render_Vulkan, "Dynamic state is disabled (dyna_state = 0), forcing scaled format emulation ON");
-
-        // Disable dynamic state 1-3 and all extensions
-        RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
-                            VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
-
-        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state,
-                            VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-
-        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
-                            VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-
-        RemoveExtensionFeature(extensions.vertex_input_dynamic_state, features.vertex_input_dynamic_state,
-                            VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
-
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
-                            VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-        dynamic_state3_blending = false;
-        dynamic_state3_enables = false;
-
-        LOG_INFO(Render_Vulkan, "All dynamic state extensions and features have been disabled");
-    } else {
-        must_emulate_scaled_formats = false;
-        LOG_INFO(Render_Vulkan, "Dynamic state is enabled (dyna_state = 1-3), disabling scaled format emulation");
-    }
+    must_emulate_scaled_formats = !Settings::values.dyna_state.GetValue();
+    LOG_INFO(Render_Vulkan, "Scaled format emulation: {}", must_emulate_scaled_formats);
 
     logical = vk::Device::Create(physical, queue_cis, ExtensionListForVulkan(loaded_extensions),
                                  first_next, dld);
@@ -1206,85 +1187,120 @@ void Device::RemoveUnsuitableExtensions() {
     RemoveExtensionFeatureIfUnsuitable(extensions.depth_clip_control, features.depth_clip_control,
                                        VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME);
 
-    /* */ // VK_EXT_extended_dynamic_state
-    extensions.extended_dynamic_state = features.extended_dynamic_state.extendedDynamicState;
-    RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state,
-                                       features.extended_dynamic_state,
-                                       VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+    int dynamic_state = Settings::values.dyna_state.GetValue();
+
+    // VK_EXT_extended_dynamic_state
+    if (dynamic_state < 1) {
+        extensions.extended_dynamic_state = features.extended_dynamic_state.extendedDynamicState;
+        RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state,
+                                           features.extended_dynamic_state,
+                                           VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+    } else {
+        RemoveExtensionFeature(extensions.extended_dynamic_state,
+                               features.extended_dynamic_state,
+                               VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+    }
 
     // VK_EXT_extended_dynamic_state2
-    extensions.extended_dynamic_state2 = features.extended_dynamic_state2.extendedDynamicState2;
-    RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state2,
-                                       features.extended_dynamic_state2,
-                                       VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+    if (dynamic_state < 2) {
+        extensions.extended_dynamic_state2 = features.extended_dynamic_state2.extendedDynamicState2;
+        RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state2,
+                                           features.extended_dynamic_state2,
+                                           VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+    } else {
+        RemoveExtensionFeature(extensions.extended_dynamic_state2,
+                               features.extended_dynamic_state2,
+                               VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+    }
 
     // VK_EXT_extended_dynamic_state3
-    dynamic_state3_blending =
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable &&
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation &&
-        features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask;
-    dynamic_state3_enables =
-        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable &&
-        features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable;
-
-    extensions.extended_dynamic_state3 = dynamic_state3_blending || dynamic_state3_enables;
-    dynamic_state3_blending = dynamic_state3_blending && extensions.extended_dynamic_state3;
-    dynamic_state3_enables = dynamic_state3_enables && extensions.extended_dynamic_state3;
-    RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state3,
-                                       features.extended_dynamic_state3,
-                                       VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-
+    if (dynamic_state < 3) {
+        dynamic_state3_blending
+            = features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable
+              && features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation
+              && features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask;
+        dynamic_state3_enables
+            = features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable
+              && features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable;
+
+        extensions.extended_dynamic_state3 = dynamic_state3_blending || dynamic_state3_enables;
+        dynamic_state3_blending = dynamic_state3_blending && extensions.extended_dynamic_state3;
+        dynamic_state3_enables = dynamic_state3_enables && extensions.extended_dynamic_state3;
+        RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state3,
+                                           features.extended_dynamic_state3,
+                                           VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+    } else {
+        RemoveExtensionFeature(extensions.extended_dynamic_state3,
+                               features.extended_dynamic_state3,
+                               VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+    }
     // VK_EXT_provoking_vertex
-    extensions.provoking_vertex =
-        features.provoking_vertex.provokingVertexLast &&
-        features.provoking_vertex.transformFeedbackPreservesProvokingVertex;
-    // RemoveExtensionFeatureIfUnsuitable(extensions.provoking_vertex, features.provoking_vertex,
-    //                                    VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
+    if (Settings::values.provoking_vertex.GetValue()) {
+        extensions.provoking_vertex = features.provoking_vertex.provokingVertexLast
+                                      && features.provoking_vertex
+                                             .transformFeedbackPreservesProvokingVertex;
+        RemoveExtensionFeatureIfUnsuitable(extensions.provoking_vertex,
+                                           features.provoking_vertex,
+                                           VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
+    } else {
+        RemoveExtensionFeature(extensions.provoking_vertex,
+                               features.provoking_vertex,
+                               VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
+    }
 
     // VK_KHR_shader_atomic_int64
-    extensions.shader_atomic_int64 = features.shader_atomic_int64.shaderBufferInt64Atomics &&
-                                     features.shader_atomic_int64.shaderSharedInt64Atomics;
-    RemoveExtensionFeatureIfUnsuitable(extensions.shader_atomic_int64, features.shader_atomic_int64,
+    extensions.shader_atomic_int64 = features.shader_atomic_int64.shaderBufferInt64Atomics
+                                     && features.shader_atomic_int64.shaderSharedInt64Atomics;
+    RemoveExtensionFeatureIfUnsuitable(extensions.shader_atomic_int64,
+                                       features.shader_atomic_int64,
                                        VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
 
     // VK_EXT_shader_demote_to_helper_invocation
-    extensions.shader_demote_to_helper_invocation =
-        features.shader_demote_to_helper_invocation.shaderDemoteToHelperInvocation;
+    extensions.shader_demote_to_helper_invocation = features.shader_demote_to_helper_invocation
+                                                        .shaderDemoteToHelperInvocation;
     RemoveExtensionFeatureIfUnsuitable(extensions.shader_demote_to_helper_invocation,
                                        features.shader_demote_to_helper_invocation,
                                        VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME);
 
     // VK_EXT_subgroup_size_control
-    extensions.subgroup_size_control =
-        features.subgroup_size_control.subgroupSizeControl &&
-        properties.subgroup_size_control.minSubgroupSize <= GuestWarpSize &&
-        properties.subgroup_size_control.maxSubgroupSize >= GuestWarpSize;
+    extensions.subgroup_size_control = features.subgroup_size_control.subgroupSizeControl
+                                       && properties.subgroup_size_control.minSubgroupSize
+                                              <= GuestWarpSize
+                                       && properties.subgroup_size_control.maxSubgroupSize
+                                              >= GuestWarpSize;
     RemoveExtensionFeatureIfUnsuitable(extensions.subgroup_size_control,
                                        features.subgroup_size_control,
                                        VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
 
     // VK_EXT_transform_feedback
-    extensions.transform_feedback =
-        features.transform_feedback.transformFeedback &&
-        features.transform_feedback.geometryStreams &&
-        properties.transform_feedback.maxTransformFeedbackStreams >= 4 &&
-        properties.transform_feedback.maxTransformFeedbackBuffers > 0 &&
-        properties.transform_feedback.transformFeedbackQueries &&
-        properties.transform_feedback.transformFeedbackDraw;
-    RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback, features.transform_feedback,
+    extensions.transform_feedback = features.transform_feedback.transformFeedback
+                                    && features.transform_feedback.geometryStreams
+                                    && properties.transform_feedback.maxTransformFeedbackStreams
+                                           >= 4
+                                    && properties.transform_feedback.maxTransformFeedbackBuffers > 0
+                                    && properties.transform_feedback.transformFeedbackQueries
+                                    && properties.transform_feedback.transformFeedbackDraw;
+    RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback,
+                                       features.transform_feedback,
                                        VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
 
     // VK_EXT_vertex_input_dynamic_state
-    extensions.vertex_input_dynamic_state =
-        features.vertex_input_dynamic_state.vertexInputDynamicState;
-    //RemoveExtensionFeatureIfUnsuitable(extensions.vertex_input_dynamic_state,
-    //features.vertex_input_dynamic_state,
-    //VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+    if (Settings::values.vertex_input.GetValue()) {
+        extensions.vertex_input_dynamic_state = features.vertex_input_dynamic_state
+                                                    .vertexInputDynamicState;
+        RemoveExtensionFeatureIfUnsuitable(extensions.vertex_input_dynamic_state,
+                                           features.vertex_input_dynamic_state,
+                                           VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+    } else {
+        RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                               features.vertex_input_dynamic_state,
+                               VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+    }
 
     // VK_KHR_pipeline_executable_properties
     if (Settings::values.renderer_shader_feedback.GetValue()) {
-        extensions.pipeline_executable_properties =
-            features.pipeline_executable_properties.pipelineExecutableInfo;
+        extensions.pipeline_executable_properties = features.pipeline_executable_properties
+                                                        .pipelineExecutableInfo;
         RemoveExtensionFeatureIfUnsuitable(extensions.pipeline_executable_properties,
                                            features.pipeline_executable_properties,
                                            VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
@@ -1295,12 +1311,12 @@ void Device::RemoveUnsuitableExtensions() {
     }
 
     // VK_KHR_workgroup_memory_explicit_layout
-    extensions.workgroup_memory_explicit_layout =
-        features.features.shaderInt16 &&
-        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout &&
-        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout8BitAccess &&
-        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout16BitAccess &&
-        features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayoutScalarBlockLayout;
+    extensions.workgroup_memory_explicit_layout
+        = features.features.shaderInt16
+          && features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout
+          && features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout8BitAccess
+          && features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayout16BitAccess
+          && features.workgroup_memory_explicit_layout.workgroupMemoryExplicitLayoutScalarBlockLayout;
     RemoveExtensionFeatureIfUnsuitable(extensions.workgroup_memory_explicit_layout,
                                        features.workgroup_memory_explicit_layout,
                                        VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.h
index ddc9451a7e..01d0eb52f7 100644
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -39,27 +39,35 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)
 
 // Define all features which may be used by the implementation and require an extension here.
-#define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
-    FEATURE(EXT, CustomBorderColor, CUSTOM_BORDER_COLOR, custom_border_color)                      \
-    FEATURE(EXT, DepthBiasControl, DEPTH_BIAS_CONTROL, depth_bias_control)                         \
-    FEATURE(EXT, DepthClipControl, DEPTH_CLIP_CONTROL, depth_clip_control)                         \
-    FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state)             \
-    FEATURE(EXT, ExtendedDynamicState2, EXTENDED_DYNAMIC_STATE_2, extended_dynamic_state2)         \
-    FEATURE(EXT, ExtendedDynamicState3, EXTENDED_DYNAMIC_STATE_3, extended_dynamic_state3)         \
-    FEATURE(EXT, 4444Formats, 4444_FORMATS, format_a4b4g4r4)                                       \
-    FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8)                               \
-    FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization)                        \
-    FEATURE(EXT, PrimitiveTopologyListRestart, PRIMITIVE_TOPOLOGY_LIST_RESTART,                    \
-            primitive_topology_list_restart)                                                       \
-    FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex)                              \
-    FEATURE(EXT, Robustness2, ROBUSTNESS_2, robustness2)                                           \
-    FEATURE(EXT, TransformFeedback, TRANSFORM_FEEDBACK, transform_feedback)                        \
-    FEATURE(EXT, VertexInputDynamicState, VERTEX_INPUT_DYNAMIC_STATE, vertex_input_dynamic_state)  \
-    FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
-            pipeline_executable_properties)                                                        \
-    FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
+#define FOR_EACH_VK_FEATURE_EXT(FEATURE) \
+    FEATURE(EXT, CustomBorderColor, CUSTOM_BORDER_COLOR, custom_border_color) \
+    FEATURE(EXT, DepthBiasControl, DEPTH_BIAS_CONTROL, depth_bias_control) \
+    FEATURE(EXT, DepthClipControl, DEPTH_CLIP_CONTROL, depth_clip_control) \
+    FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state) \
+    FEATURE(EXT, ExtendedDynamicState2, EXTENDED_DYNAMIC_STATE_2, extended_dynamic_state2) \
+    FEATURE(EXT, ExtendedDynamicState3, EXTENDED_DYNAMIC_STATE_3, extended_dynamic_state3) \
+    FEATURE(EXT, 4444Formats, 4444_FORMATS, format_a4b4g4r4) \
+    FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8) \
+    FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization) \
+    FEATURE(EXT, \
+            PrimitiveTopologyListRestart, \
+            PRIMITIVE_TOPOLOGY_LIST_RESTART, \
+            primitive_topology_list_restart) \
+    FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex) \
+    FEATURE(EXT, Robustness2, ROBUSTNESS_2, robustness2) \
+    FEATURE(EXT, TransformFeedback, TRANSFORM_FEEDBACK, transform_feedback) \
+    FEATURE(EXT, VertexInputDynamicState, VERTEX_INPUT_DYNAMIC_STATE, vertex_input_dynamic_state) \
+    FEATURE(KHR, \
+            PipelineExecutableProperties, \
+            PIPELINE_EXECUTABLE_PROPERTIES, \
+            pipeline_executable_properties) \
+    FEATURE(KHR, \
+            WorkgroupMemoryExplicitLayout, \
+            WORKGROUP_MEMORY_EXPLICIT_LAYOUT, \
             workgroup_memory_explicit_layout)
 
+// TODO(alekpop): descriptor index is incomplete and needs fix.
+
 // Define miscellaneous extensions which may be used by the implementation here.
 #define FOR_EACH_VK_EXTENSION(EXTENSION)                                                           \
     EXTENSION(EXT, CONDITIONAL_RENDERING, conditional_rendering)                                   \
@@ -149,24 +157,24 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE_NAME(variable_pointer, variablePointersStorageBuffer)
 
 // Define features where the absence of the feature may result in a degraded experience.
-#define FOR_EACH_VK_RECOMMENDED_FEATURE(FEATURE_NAME)                                              \
-    FEATURE_NAME(custom_border_color, customBorderColors)                                          \
-    FEATURE_NAME(depth_bias_control, depthBiasControl)                                             \
-    FEATURE_NAME(depth_bias_control, leastRepresentableValueForceUnormRepresentation)              \
-    FEATURE_NAME(depth_bias_control, depthBiasExact)                                               \
-    FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
-    FEATURE_NAME(format_a4b4g4r4, formatA4B4G4R4)                                                  \
-    FEATURE_NAME(index_type_uint8, indexTypeUint8)                                                 \
-    FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart)                    \
-    FEATURE_NAME(provoking_vertex, provokingVertexLast)                                            \
-    FEATURE_NAME(robustness2, nullDescriptor)                                                      \
-    FEATURE_NAME(robustness2, robustBufferAccess2)                                                 \
-    FEATURE_NAME(robustness2, robustImageAccess2)                                                  \
-    FEATURE_NAME(shader_float16_int8, shaderFloat16)                                               \
-    FEATURE_NAME(shader_float16_int8, shaderInt8)                                                  \
-    FEATURE_NAME(timeline_semaphore, timelineSemaphore)                                            \
-    FEATURE_NAME(transform_feedback, transformFeedback)                                            \
-    FEATURE_NAME(uniform_buffer_standard_layout, uniformBufferStandardLayout)                      \
+#define FOR_EACH_VK_RECOMMENDED_FEATURE(FEATURE_NAME) \
+    FEATURE_NAME(custom_border_color, customBorderColors) \
+    FEATURE_NAME(depth_bias_control, depthBiasControl) \
+    FEATURE_NAME(depth_bias_control, leastRepresentableValueForceUnormRepresentation) \
+    FEATURE_NAME(depth_bias_control, depthBiasExact) \
+    FEATURE_NAME(extended_dynamic_state, extendedDynamicState) \
+    FEATURE_NAME(format_a4b4g4r4, formatA4B4G4R4) \
+    FEATURE_NAME(index_type_uint8, indexTypeUint8) \
+    FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart) \
+    FEATURE_NAME(provoking_vertex, provokingVertexLast) \
+    FEATURE_NAME(robustness2, nullDescriptor) \
+    FEATURE_NAME(robustness2, robustBufferAccess2) \
+    FEATURE_NAME(robustness2, robustImageAccess2) \
+    FEATURE_NAME(shader_float16_int8, shaderFloat16) \
+    FEATURE_NAME(shader_float16_int8, shaderInt8) \
+    FEATURE_NAME(timeline_semaphore, timelineSemaphore) \
+    FEATURE_NAME(transform_feedback, transformFeedback) \
+    FEATURE_NAME(uniform_buffer_standard_layout, uniformBufferStandardLayout) \
     FEATURE_NAME(vertex_input_dynamic_state, vertexInputDynamicState)
 
 namespace Vulkan {