shader_recompiler: patch small float image writes on broken drivers

qt: settings: Fix per-game vsync combobox

CMakeLists.txt

@@ -305,7 +305,7 @@ find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
 
 if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
-    find_package(Vulkan 1.3.256 REQUIRED)
+    find_package(Vulkan 1.3.274 REQUIRED)
 endif()
 
 if (ENABLE_LIBUSB)

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/GamesFragment.kt

@@ -91,18 +91,20 @@ class GamesFragment : Fragment() {
         viewLifecycleOwner.lifecycleScope.apply {
             launch {
                 repeatOnLifecycle(Lifecycle.State.RESUMED) {
-                    gamesViewModel.isReloading.collect { binding.swipeRefresh.isRefreshing = it }
+                    gamesViewModel.isReloading.collect {
+                        binding.swipeRefresh.isRefreshing = it
+                        if (gamesViewModel.games.value.isEmpty() && !it) {
+                            binding.noticeText.visibility = View.VISIBLE
+                        } else {
+                            binding.noticeText.visibility = View.INVISIBLE
+                        }
+                    }
                 }
             }
             launch {
                 repeatOnLifecycle(Lifecycle.State.RESUMED) {
                     gamesViewModel.games.collectLatest {
                         (binding.gridGames.adapter as GameAdapter).submitList(it)
-                        if (it.isEmpty()) {
-                            binding.noticeText.visibility = View.VISIBLE
-                        } else {
-                            binding.noticeText.visibility = View.GONE
-                        }
                     }
                 }
             }

src/core/arm/nce/arm_nce.cpp

@@ -39,7 +39,7 @@ fpsimd_context* GetFloatingPointState(mcontext_t& host_ctx) {
 }
 
 using namespace Common::Literals;
-constexpr u32 StackSize = 32_KiB;
+constexpr u32 StackSize = 128_KiB;
 
 } // namespace
 

src/core/arm/nce/interpreter_visitor.cpp

@@ -5,8 +5,6 @@
 #include "common/bit_cast.h"
 #include "core/arm/nce/interpreter_visitor.h"
 
-#include <dynarmic/frontend/A64/decoder/a64.h>
-
 namespace Core {
 
 template <u32 BitSize>
@@ -249,6 +247,7 @@ bool InterpreterVisitor::LDR_lit_fpsimd(Imm<2> opc, Imm<19> imm19, Vec Vt) {
         return false;
     }
 
+    // Size in bytes
     const u64 size = 4 << opc.ZeroExtend();
     const u64 offset = imm19.SignExtend<u64>() << 2;
     const u64 address = this->GetPc() + offset;
@@ -530,7 +529,7 @@ bool InterpreterVisitor::SIMDImmediate(bool wback, bool postindex, size_t scale,
     }
     case MemOp::Load: {
         u128 data{};
-        m_memory.ReadBlock(address, &data, datasize);
+        m_memory.ReadBlock(address, &data, datasize / 8);
         this->SetVec(Vt, data);
         break;
     }

src/core/arm/nce/visitor_base.h

@@ -4,9 +4,15 @@
 
 #pragma once
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+
 #include <dynarmic/frontend/A64/a64_types.h>
+#include <dynarmic/frontend/A64/decoder/a64.h>
 #include <dynarmic/frontend/imm.h>
 
+#pragma GCC diagnostic pop
+
 namespace Core {
 
 class VisitorBase {

src/core/hle/service/hid/hid_server.cpp

@@ -51,7 +51,7 @@ private:
         IPC::RequestParser rp{ctx};
         const auto vibration_device_handle{rp.PopRaw<Core::HID::VibrationDeviceHandle>()};
 
-        if (resource_manager != nullptr) {
+        if (resource_manager != nullptr && resource_manager->GetNpad()) {
             resource_manager->GetNpad()->InitializeVibrationDevice(vibration_device_handle);
         }
 

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -74,6 +74,11 @@ std::optional<OutAttr> OutputAttrPointer(EmitContext& ctx, IR::Attribute attr) {
     case IR::Attribute::ClipDistance7: {
         const u32 base{static_cast<u32>(IR::Attribute::ClipDistance0)};
         const u32 index{static_cast<u32>(attr) - base};
+        if (index >= ctx.profile.max_user_clip_distances) {
+            LOG_WARNING(Shader, "Ignoring clip distance store {} >= {} supported", index,
+                        ctx.profile.max_user_clip_distances);
+            return std::nullopt;
+        }
         const Id clip_num{ctx.Const(index)};
         return OutputAccessChain(ctx, ctx.output_f32, ctx.clip_distances, clip_num);
     }

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -74,9 +74,17 @@ spv::ImageFormat GetImageFormat(ImageFormat format) {
     throw InvalidArgument("Invalid image format {}", format);
 }
 
+Id GetImageSampledType(EmitContext& ctx, const ImageDescriptor& desc) {
+    if (desc.is_float) {
+        return ctx.F32[1];
+    } else {
+        return ctx.U32[1];
+    }
+}
+
 Id ImageType(EmitContext& ctx, const ImageDescriptor& desc) {
     const spv::ImageFormat format{GetImageFormat(desc.format)};
-    const Id type{ctx.U32[1]};
+    const Id type{GetImageSampledType(ctx, desc)};
     switch (desc.type) {
     case TextureType::Color1D:
         return ctx.TypeImage(type, spv::Dim::Dim1D, false, false, false, 2, format);
@@ -1528,7 +1536,8 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
         if (stage == Stage::Fragment) {
             throw NotImplementedException("Storing ClipDistance in fragment stage");
         }
-        const Id type{TypeArray(F32[1], Const(8U))};
+        const Id type{TypeArray(
+            F32[1], Const(std::min(info.used_clip_distances, profile.max_user_clip_distances)))};
         clip_distances = DefineOutput(*this, type, invocations, spv::BuiltIn::ClipDistance);
     }
     if (info.stores[IR::Attribute::Layer] &&

src/shader_recompiler/frontend/ir/opcodes.inc

@@ -512,7 +512,7 @@ OPCODE(ImageQueryDimensions,                                U32x4,          Opaq
 OPCODE(ImageQueryLod,                                       F32x4,          Opaque,         Opaque,                                                         )
 OPCODE(ImageGradient,                                       F32x4,          Opaque,         Opaque,         Opaque,         Opaque,         Opaque,         )
 OPCODE(ImageRead,                                           U32x4,          Opaque,         Opaque,                                                         )
-OPCODE(ImageWrite,                                          Void,           Opaque,         Opaque,         U32x4,                                          )
+OPCODE(ImageWrite,                                          Void,           Opaque,         Opaque,         Opaque,                                         )
 
 OPCODE(IsTextureScaled,                                     U1,             U32,                                                                            )
 OPCODE(IsImageScaled,                                       U1,             U32,                                                                            )

src/shader_recompiler/host_translate_info.h

@@ -19,8 +19,10 @@ struct HostTranslateInfo {
     u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
-    bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
-                                        ///< control flow
+    bool support_conditional_barrier{};  ///< True when the device supports barriers in conditional
+                                         ///< control flow
+    bool support_ufloat_write_as_uint{}; ///< True when the device supports writing float images
+                                         ///< as bitcasts to uint
 };
 
 } // namespace Shader

src/shader_recompiler/ir_opt/collect_shader_info_pass.cpp

@@ -913,7 +913,11 @@ void GatherInfoFromHeader(Environment& env, Info& info) {
         }
         for (size_t index = 0; index < 8; ++index) {
             const u16 mask{header.vtg.omap_systemc.clip_distances};
-            info.stores.Set(IR::Attribute::ClipDistance0 + index, ((mask >> index) & 1) != 0);
+            const bool used{((mask >> index) & 1) != 0};
+            info.stores.Set(IR::Attribute::ClipDistance0 + index, used);
+            if (used) {
+                info.used_clip_distances = static_cast<u32>(index) + 1;
+            }
         }
         info.stores.Set(IR::Attribute::PrimitiveId,
                         header.vtg.omap_systemb.primitive_array_id != 0);

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -372,6 +372,10 @@ TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAdd
     return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }
 
+bool TexturePixelFormatIsFloat(Environment& env, const ConstBufferAddr& cbuf) {
+    return ReadTexturePixelFormat(env, cbuf) == TexturePixelFormat::B10G11R11_FLOAT;
+}
+
 class Descriptors {
 public:
     explicit Descriptors(TextureBufferDescriptors& texture_buffer_descriptors_,
@@ -428,8 +432,9 @@ public:
             return desc.type == existing.type && desc.format == existing.format &&
                    desc.cbuf_index == existing.cbuf_index &&
                    desc.cbuf_offset == existing.cbuf_offset && desc.count == existing.count &&
-                   desc.size_shift == existing.size_shift;
+                   desc.size_shift == existing.size_shift && desc.is_float == existing.is_float;
         })};
+        // TODO: handle is_float?
         image_descriptors[index].is_written |= desc.is_written;
         image_descriptors[index].is_read |= desc.is_read;
         return index;
@@ -500,6 +505,19 @@ void PatchTexelFetch(IR::Block& block, IR::Inst& inst, TexturePixelFormat pixel_
                               ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::U32>(w)), max_value));
     inst.ReplaceUsesWith(converted);
 }
+
+void PatchSmallFloatImageWrite(IR::Block& block, IR::Inst& inst) {
+    IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
+
+    const IR::Value old_value{inst.Arg(2)};
+    const IR::F32 x(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 0))));
+    const IR::F32 y(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 1))));
+    const IR::F32 z(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 2))));
+    const IR::F32 w(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 3))));
+    const IR::Value converted = ir.CompositeConstruct(x, y, z, w);
+    inst.SetArg(2, converted);
+}
+
 } // Anonymous namespace
 
 void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo& host_info) {
@@ -531,6 +549,9 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
         inst->ReplaceOpcode(IndexedInstruction(*inst));
 
         const auto& cbuf{texture_inst.cbuf};
+        const bool is_float_write{!host_info.support_ufloat_write_as_uint &&
+                                  inst->GetOpcode() == IR::Opcode::ImageWrite &&
+                                  TexturePixelFormatIsFloat(env, cbuf)};
         auto flags{inst->Flags<IR::TextureInstInfo>()};
         bool is_multisample{false};
         switch (inst->GetOpcode()) {
@@ -603,6 +624,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                     .format = flags.image_format,
                     .is_written = is_written,
                     .is_read = is_read,
+                    .is_float = is_float_write,
                     .cbuf_index = cbuf.index,
                     .cbuf_offset = cbuf.offset,
                     .count = cbuf.count,
@@ -662,6 +684,10 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                 PatchTexelFetch(*texture_inst.block, *texture_inst.inst, pixel_format);
             }
         }
+
+        if (is_float_write) {
+            PatchSmallFloatImageWrite(*texture_inst.block, *inst);
+        }
     }
 }
 

src/shader_recompiler/profile.h

@@ -87,6 +87,8 @@ struct Profile {
     bool has_broken_robust{};
 
     u64 min_ssbo_alignment{};
+
+    u32 max_user_clip_distances{};
 };
 
 } // namespace Shader

src/shader_recompiler/shader_info.h

@@ -42,6 +42,7 @@ enum class TexturePixelFormat : u32 {
     R16G16B16A16_SNORM,
     R16G16_SNORM,
     R16_SNORM,
+    B10G11R11_FLOAT,
     OTHER
 };
 
@@ -129,6 +130,7 @@ struct ImageDescriptor {
     ImageFormat format;
     bool is_written;
     bool is_read;
+    bool is_float;
     u32 cbuf_index;
     u32 cbuf_offset;
     u32 count;
@@ -227,6 +229,8 @@ struct Info {
     bool requires_layer_emulation{};
     IR::Attribute emulated_layer{};
 
+    u32 used_clip_distances{};
+
     boost::container::static_vector<ConstantBufferDescriptor, MAX_CBUFS>
         constant_buffer_descriptors;
     boost::container::static_vector<StorageBufferDescriptor, MAX_SSBOS> storage_buffers_descriptors;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -233,6 +233,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .ignore_nan_fp_comparisons = true,
           .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
           .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
+          .max_user_clip_distances = 8,
       },
       host_info{
           .support_float64 = true,
@@ -244,6 +245,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
           .support_conditional_barrier = device.SupportsConditionalBarriers(),
+          .support_ufloat_write_as_uint = true,
       } {
     if (use_asynchronous_shaders) {
         workers = CreateWorkers();

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -563,22 +563,27 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
         }
         buffer_handles.push_back(handle);
     }
+    const u32 device_max = device.GetMaxVertexInputBindings();
+    const u32 min_binding = std::min(bindings.min_index, device_max);
+    const u32 max_binding = std::min(bindings.max_index, device_max);
+    const u32 binding_count = max_binding - min_binding;
+    if (binding_count == 0) {
+        return;
+    }
     if (device.IsExtExtendedDynamicStateSupported()) {
-        scheduler.Record([this, bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
-            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index,
-                                         std::min(bindings_.max_index - bindings_.min_index,
-                                                  device.GetMaxVertexInputBindings()),
-                                         buffer_handles_.data(), bindings_.offsets.data(),
-                                         bindings_.sizes.data(), bindings_.strides.data());
+        scheduler.Record([bindings_ = std::move(bindings),
+                          buffer_handles_ = std::move(buffer_handles),
+                          binding_count](vk::CommandBuffer cmdbuf) {
+            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index, binding_count, buffer_handles_.data(),
+                                         bindings_.offsets.data(), bindings_.sizes.data(),
+                                         bindings_.strides.data());
         });
     } else {
-        scheduler.Record([this, bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
-            cmdbuf.BindVertexBuffers(bindings_.min_index,
-                                     std::min(bindings_.max_index - bindings_.min_index,
-                                              device.GetMaxVertexInputBindings()),
-                                     buffer_handles_.data(), bindings_.offsets.data());
+        scheduler.Record([bindings_ = std::move(bindings),
+                          buffer_handles_ = std::move(buffer_handles),
+                          binding_count](vk::CommandBuffer cmdbuf) {
+            cmdbuf.BindVertexBuffers(bindings_.min_index, binding_count, buffer_handles_.data(),
+                                     bindings_.offsets.data());
         });
     }
 }

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -374,6 +374,7 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
         .has_broken_robust =
             device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
         .min_ssbo_alignment = device.GetStorageBufferAlignment(),
+        .max_user_clip_distances = device.GetMaxUserClipDistances(),
     };
 
     host_info = Shader::HostTranslateInfo{
@@ -387,6 +388,8 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
         .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
         .support_conditional_barrier = device.SupportsConditionalBarriers(),
+        .support_ufloat_write_as_uint =
+            driver_id != VK_DRIVER_ID_QUALCOMM_PROPRIETARY && driver_id != VK_DRIVER_ID_MESA_TURNIP,
     };
 
     if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -289,12 +289,15 @@ public:
         }
 
         if (has_multi_queries) {
-            size_t intermediary_buffer_index = ObtainBuffer<false>(num_slots_used);
+            const size_t min_accumulation_limit =
+                std::min(first_accumulation_checkpoint, num_slots_used);
+            const size_t max_accumulation_limit =
+                std::max(last_accumulation_checkpoint, num_slots_used);
+            const size_t intermediary_buffer_index = ObtainBuffer<false>(num_slots_used);
             resolve_buffers.push_back(intermediary_buffer_index);
             queries_prefix_scan_pass->Run(*accumulation_buffer, *buffers[intermediary_buffer_index],
                                           *buffers[resolve_buffer_index], num_slots_used,
-                                          std::min(first_accumulation_checkpoint, num_slots_used),
-                                          last_accumulation_checkpoint);
+                                          min_accumulation_limit, max_accumulation_limit);
 
         } else {
             scheduler.RequestOutsideRenderPassOperationContext();

src/video_core/shader_environment.cpp

@@ -76,6 +76,8 @@ static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture
         return Shader::TexturePixelFormat::R16G16_SNORM;
     case VideoCore::Surface::PixelFormat::R16_SNORM:
         return Shader::TexturePixelFormat::R16_SNORM;
+    case VideoCore::Surface::PixelFormat::B10G11R11_FLOAT:
+        return Shader::TexturePixelFormat::B10G11R11_FLOAT;
     default:
         return Shader::TexturePixelFormat::OTHER;
     }

src/video_core/vulkan_common/vulkan_device.cpp

@@ -695,6 +695,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             std::min(properties.properties.limits.maxVertexInputBindings, 16U);
     }
 
+    if (is_turnip) {
+        LOG_WARNING(Render_Vulkan, "Turnip requires higher-than-reported binding limits");
+        properties.properties.limits.maxVertexInputBindings = 32;
+    }
+
     if (!extensions.extended_dynamic_state && extensions.extended_dynamic_state2) {
         LOG_INFO(Render_Vulkan,
                  "Removing extendedDynamicState2 due to missing extendedDynamicState");

src/video_core/vulkan_common/vulkan_device.h

@@ -665,6 +665,10 @@ public:
         return properties.properties.limits.maxViewports;
     }
 
+    u32 GetMaxUserClipDistances() const {
+        return properties.properties.limits.maxClipDistances;
+    }
+
     bool SupportsConditionalBarriers() const {
         return supports_conditional_barriers;
     }

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -377,6 +377,8 @@ const char* ToString(VkResult result) noexcept {
         return "VK_OPERATION_DEFERRED_KHR";
     case VkResult::VK_OPERATION_NOT_DEFERRED_KHR:
         return "VK_OPERATION_NOT_DEFERRED_KHR";
+    case VkResult::VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR:
+        return "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR";
     case VkResult::VK_PIPELINE_COMPILE_REQUIRED_EXT:
         return "VK_PIPELINE_COMPILE_REQUIRED_EXT";
     case VkResult::VK_RESULT_MAX_ENUM:

src/yuzu/configuration/configure_graphics.cpp

@@ -106,32 +106,30 @@ ConfigureGraphics::ConfigureGraphics(
                                                 Settings::values.bg_green.GetValue(),
                                                 Settings::values.bg_blue.GetValue()));
     UpdateAPILayout();
-    PopulateVSyncModeSelection(); //< must happen after UpdateAPILayout
+    PopulateVSyncModeSelection(false); //< must happen after UpdateAPILayout
 
     // VSync setting needs to be determined after populating the VSync combobox
-    if (Settings::IsConfiguringGlobal()) {
-        const auto vsync_mode_setting = Settings::values.vsync_mode.GetValue();
-        const auto vsync_mode = VSyncSettingToMode(vsync_mode_setting);
-        int index{};
-        for (const auto mode : vsync_mode_combobox_enum_map) {
-            if (mode == vsync_mode) {
-                break;
-            }
-            index++;
-        }
-        if (static_cast<unsigned long>(index) < vsync_mode_combobox_enum_map.size()) {
-            vsync_mode_combobox->setCurrentIndex(index);
+    const auto vsync_mode_setting = Settings::values.vsync_mode.GetValue();
+    const auto vsync_mode = VSyncSettingToMode(vsync_mode_setting);
+    int index{};
+    for (const auto mode : vsync_mode_combobox_enum_map) {
+        if (mode == vsync_mode) {
+            break;
         }
+        index++;
+    }
+    if (static_cast<unsigned long>(index) < vsync_mode_combobox_enum_map.size()) {
+        vsync_mode_combobox->setCurrentIndex(index);
     }
 
     connect(api_combobox, qOverload<int>(&QComboBox::activated), this, [this] {
         UpdateAPILayout();
-        PopulateVSyncModeSelection();
+        PopulateVSyncModeSelection(false);
     });
     connect(vulkan_device_combobox, qOverload<int>(&QComboBox::activated), this,
             [this](int device) {
                 UpdateDeviceSelection(device);
-                PopulateVSyncModeSelection();
+                PopulateVSyncModeSelection(false);
             });
     connect(shader_backend_combobox, qOverload<int>(&QComboBox::activated), this,
             [this](int backend) { UpdateShaderBackendSelection(backend); });
@@ -147,8 +145,9 @@ ConfigureGraphics::ConfigureGraphics(
     const auto& update_screenshot_info = [this, &builder]() {
         const auto& combobox_enumerations = builder.ComboboxTranslations().at(
             Settings::EnumMetadata<Settings::AspectRatio>::Index());
-        const auto index = aspect_ratio_combobox->currentIndex();
-        const auto ratio = static_cast<Settings::AspectRatio>(combobox_enumerations[index].first);
+        const auto ratio_index = aspect_ratio_combobox->currentIndex();
+        const auto ratio =
+            static_cast<Settings::AspectRatio>(combobox_enumerations[ratio_index].first);
 
         const auto& combobox_enumerations_resolution = builder.ComboboxTranslations().at(
             Settings::EnumMetadata<Settings::ResolutionSetup>::Index());
@@ -174,11 +173,7 @@ ConfigureGraphics::ConfigureGraphics(
     }
 }
 
-void ConfigureGraphics::PopulateVSyncModeSelection() {
-    if (!Settings::IsConfiguringGlobal()) {
-        return;
-    }
-
+void ConfigureGraphics::PopulateVSyncModeSelection(bool use_setting) {
     const Settings::RendererBackend backend{GetCurrentGraphicsBackend()};
     if (backend == Settings::RendererBackend::Null) {
         vsync_mode_combobox->setEnabled(false);
@@ -189,8 +184,9 @@ void ConfigureGraphics::PopulateVSyncModeSelection() {
     const int current_index = //< current selected vsync mode from combobox
         vsync_mode_combobox->currentIndex();
     const auto current_mode = //< current selected vsync mode as a VkPresentModeKHR
-        current_index == -1 ? VSyncSettingToMode(Settings::values.vsync_mode.GetValue())
-                            : vsync_mode_combobox_enum_map[current_index];
+        current_index == -1 || use_setting
+            ? VSyncSettingToMode(Settings::values.vsync_mode.GetValue())
+            : vsync_mode_combobox_enum_map[current_index];
     int index{};
     const int device{vulkan_device_combobox->currentIndex()}; //< current selected Vulkan device
 
@@ -214,6 +210,23 @@ void ConfigureGraphics::PopulateVSyncModeSelection() {
         }
         index++;
     }
+
+    if (!Settings::IsConfiguringGlobal()) {
+        vsync_restore_global_button->setVisible(!Settings::values.vsync_mode.UsingGlobal());
+
+        const Settings::VSyncMode global_vsync_mode = Settings::values.vsync_mode.GetValue(true);
+        vsync_restore_global_button->setEnabled(
+            (backend == Settings::RendererBackend::OpenGL &&
+             (global_vsync_mode == Settings::VSyncMode::Immediate ||
+              global_vsync_mode == Settings::VSyncMode::Fifo)) ||
+            backend == Settings::RendererBackend::Vulkan);
+    }
+}
+
+void ConfigureGraphics::UpdateVsyncSetting() const {
+    const auto mode = vsync_mode_combobox_enum_map[vsync_mode_combobox->currentIndex()];
+    const auto vsync_mode = PresentModeToSetting(mode);
+    Settings::values.vsync_mode.SetValue(vsync_mode);
 }
 
 void ConfigureGraphics::UpdateDeviceSelection(int device) {
@@ -299,6 +312,33 @@ void ConfigureGraphics::Setup(const ConfigurationShared::Builder& builder) {
         } else if (setting->Id() == Settings::values.vsync_mode.Id()) {
             // Keep track of vsync_mode's combobox so we can populate it
             vsync_mode_combobox = widget->combobox;
+
+            // Since vsync is populated at runtime, we have to manually set up the button for
+            // restoring the global setting.
+            if (!Settings::IsConfiguringGlobal()) {
+                QPushButton* restore_button =
+                    ConfigurationShared::Widget::CreateRestoreGlobalButton(
+                        Settings::values.vsync_mode.UsingGlobal(), widget);
+                restore_button->setEnabled(true);
+                widget->layout()->addWidget(restore_button);
+
+                QObject::connect(restore_button, &QAbstractButton::clicked,
+                                 [restore_button, this](bool) {
+                                     Settings::values.vsync_mode.SetGlobal(true);
+                                     PopulateVSyncModeSelection(true);
+
+                                     restore_button->setVisible(false);
+                                 });
+
+                std::function<void()> set_non_global = [restore_button, this]() {
+                    Settings::values.vsync_mode.SetGlobal(false);
+                    UpdateVsyncSetting();
+                    restore_button->setVisible(true);
+                };
+                QObject::connect(widget->combobox, QOverload<int>::of(&QComboBox::activated),
+                                 [set_non_global]() { set_non_global(); });
+                vsync_restore_global_button = restore_button;
+            }
             hold_graphics.emplace(setting->Id(), widget);
         } else if (setting->Id() == Settings::values.aspect_ratio.Id()) {
             // Keep track of the aspect ratio combobox to update other UI tabs that need it
@@ -400,11 +440,7 @@ void ConfigureGraphics::ApplyConfiguration() {
         func(powered_on);
     }
 
-    if (Settings::IsConfiguringGlobal()) {
-        const auto mode = vsync_mode_combobox_enum_map[vsync_mode_combobox->currentIndex()];
-        const auto vsync_mode = PresentModeToSetting(mode);
-        Settings::values.vsync_mode.SetValue(vsync_mode);
-    }
+    UpdateVsyncSetting();
 
     Settings::values.vulkan_device.SetGlobal(true);
     Settings::values.shader_backend.SetGlobal(true);

src/yuzu/configuration/configure_graphics.h

@@ -62,7 +62,8 @@ private:
 
     void Setup(const ConfigurationShared::Builder& builder);
 
-    void PopulateVSyncModeSelection();
+    void PopulateVSyncModeSelection(bool use_setting);
+    void UpdateVsyncSetting() const;
     void UpdateBackgroundColorButton(QColor color);
     void UpdateAPILayout();
     void UpdateDeviceSelection(int device);
@@ -104,6 +105,7 @@ private:
     QComboBox* api_combobox;
     QComboBox* shader_backend_combobox;
     QComboBox* vsync_mode_combobox;
+    QPushButton* vsync_restore_global_button;
     QWidget* vulkan_device_widget;
     QWidget* api_widget;
     QWidget* shader_backend_widget;

src/yuzu/configuration/qt_config.cpp

@@ -225,6 +225,8 @@ void QtConfig::ReadPathValues() {
         QString::fromStdString(ReadStringSetting(std::string("recentFiles")))
             .split(QStringLiteral(", "), Qt::SkipEmptyParts, Qt::CaseSensitive);
 
+    ReadCategory(Settings::Category::Paths);
+
     EndGroup();
 }
 
@@ -405,6 +407,8 @@ void QtConfig::SaveQtControlValues() {
 void QtConfig::SavePathValues() {
     BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
 
+    WriteCategory(Settings::Category::Paths);
+
     WriteSetting(std::string("romsPath"), UISettings::values.roms_path);
     BeginArray(std::string("gamedirs"));
     for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {