Android #27

.codespellrc

@@ -3,4 +3,4 @@
 
 [codespell]
 skip = ./.git,./build,./dist,./Doxyfile,./externals,./LICENSES,./src/android/app/src/main/res
-ignore-words-list = aci,allright,ba,canonicalizations,deques,froms,hda,inout,lod,masia,nam,nax,nd,optin,pullrequests,pullrequest,te,transfered,unstall,uscaled,zink
+ignore-words-list = aci,allright,ba,deques,froms,hda,inout,lod,masia,nam,nax,nd,optin,pullrequests,pullrequest,te,transfered,unstall,uscaled,zink

README.md

@@ -48,7 +48,7 @@ It is written in C++ with portability in mind, and we actively maintain builds f
 
 The emulator is capable of running most commercial games at full speed, provided you meet the [necessary hardware requirements](https://yuzu-emu.org/help/quickstart/#hardware-requirements).
 
-For a full list of games yuzu supports, please visit our [Compatibility page](https://yuzu-emu.org/game/).
+For a full list of games yuzu support, please visit our [Compatibility page](https://yuzu-emu.org/game/)
 
 Check out our [website](https://yuzu-emu.org/) for the latest news on exciting features, monthly progress reports, and more!
 

src/CMakeLists.txt

@@ -35,7 +35,6 @@ if (MSVC)
     # /volatile:iso       - Use strict standards-compliant volatile semantics.
     # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
     # /Zc:inline          - Let codegen omit inline functions in object files
-    # /Zc:preprocessor    - Enable standards-conforming preprocessor
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
     # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
@@ -49,7 +48,6 @@ if (MSVC)
         /volatile:iso
         /Zc:externConstexpr
         /Zc:inline
-        /Zc:preprocessor
         /Zc:throwingNew
         /GT
 

src/android/app/src/main/jni/config.cpp

@@ -150,17 +150,15 @@ void Config::ReadValues() {
     if (rng_seed_enabled) {
         Settings::values.rng_seed.SetValue(config->GetInteger("System", "rng_seed", 0));
     } else {
-        Settings::values.rng_seed.SetValue(0);
+        Settings::values.rng_seed.SetValue(std::nullopt);
     }
-    Settings::values.rng_seed_enabled.SetValue(rng_seed_enabled);
 
     const auto custom_rtc_enabled = config->GetBoolean("System", "custom_rtc_enabled", false);
     if (custom_rtc_enabled) {
         Settings::values.custom_rtc = config->GetInteger("System", "custom_rtc", 0);
     } else {
-        Settings::values.custom_rtc = 0;
+        Settings::values.custom_rtc = std::nullopt;
     }
-    Settings::values.custom_rtc_enabled = custom_rtc_enabled;
 
     ReadSetting("System", Settings::values.language_index);
     ReadSetting("System", Settings::values.region_index);
@@ -169,7 +167,7 @@ void Config::ReadValues() {
 
     // Core
     ReadSetting("Core", Settings::values.use_multi_core);
-    ReadSetting("Core", Settings::values.memory_layout_mode);
+    ReadSetting("Core", Settings::values.use_unsafe_extended_memory_layout);
 
     // Cpu
     ReadSetting("Cpu", Settings::values.cpu_accuracy);
@@ -224,17 +222,14 @@ void Config::ReadValues() {
     ReadSetting("Renderer", Settings::values.bg_blue);
 
     // Use GPU accuracy normal by default on Android
-    Settings::values.gpu_accuracy = static_cast<Settings::GpuAccuracy>(config->GetInteger(
-        "Renderer", "gpu_accuracy", static_cast<u32>(Settings::GpuAccuracy::Normal)));
+    Settings::values.gpu_accuracy = static_cast<Settings::GPUAccuracy>(config->GetInteger(
+        "Renderer", "gpu_accuracy", static_cast<u32>(Settings::GPUAccuracy::Normal)));
 
     // Use GPU default anisotropic filtering on Android
-    Settings::values.max_anisotropy =
-        static_cast<Settings::AnisotropyMode>(config->GetInteger("Renderer", "max_anisotropy", 1));
+    Settings::values.max_anisotropy = config->GetInteger("Renderer", "max_anisotropy", 1);
 
     // Disable ASTC compute by default on Android
-    Settings::values.accelerate_astc.SetValue(
-        config->GetBoolean("Renderer", "accelerate_astc", false) ? Settings::AstcDecodeMode::Gpu
-                                                                 : Settings::AstcDecodeMode::Cpu);
+    Settings::values.accelerate_astc = config->GetBoolean("Renderer", "accelerate_astc", false);
 
     // Enable asynchronous presentation by default on Android
     Settings::values.async_presentation =

src/audio_core/sink/sink_details.cpp

@@ -15,7 +15,6 @@
 #endif
 #include "audio_core/sink/null_sink.h"
 #include "common/logging/log.h"
-#include "common/settings_enums.h"
 
 namespace AudioCore::Sink {
 namespace {
@@ -25,7 +24,7 @@ struct SinkDetails {
     using LatencyFn = u32 (*)();
 
     /// Name for this sink.
-    Settings::AudioEngine id;
+    std::string_view id;
     /// A method to call to construct an instance of this type of sink.
     FactoryFn factory;
     /// A method to call to list available devices.
@@ -38,7 +37,7 @@ struct SinkDetails {
 constexpr SinkDetails sink_details[] = {
 #ifdef HAVE_CUBEB
     SinkDetails{
-        Settings::AudioEngine::Cubeb,
+        "cubeb",
         [](std::string_view device_id) -> std::unique_ptr<Sink> {
             return std::make_unique<CubebSink>(device_id);
         },
@@ -48,7 +47,7 @@ constexpr SinkDetails sink_details[] = {
 #endif
 #ifdef HAVE_SDL2
     SinkDetails{
-        Settings::AudioEngine::Sdl2,
+        "sdl2",
         [](std::string_view device_id) -> std::unique_ptr<Sink> {
             return std::make_unique<SDLSink>(device_id);
         },
@@ -56,47 +55,46 @@ constexpr SinkDetails sink_details[] = {
         &GetSDLLatency,
     },
 #endif
-    SinkDetails{Settings::AudioEngine::Null,
+    SinkDetails{"null",
                 [](std::string_view device_id) -> std::unique_ptr<Sink> {
                     return std::make_unique<NullSink>(device_id);
                 },
                 [](bool capture) { return std::vector<std::string>{"null"}; }, []() { return 0u; }},
 };
 
-const SinkDetails& GetOutputSinkDetails(Settings::AudioEngine sink_id) {
-    const auto find_backend{[](Settings::AudioEngine id) {
+const SinkDetails& GetOutputSinkDetails(std::string_view sink_id) {
+    const auto find_backend{[](std::string_view id) {
         return std::find_if(std::begin(sink_details), std::end(sink_details),
                             [&id](const auto& sink_detail) { return sink_detail.id == id; });
     }};
 
     auto iter = find_backend(sink_id);
 
-    if (sink_id == Settings::AudioEngine::Auto) {
+    if (sink_id == "auto") {
         // Auto-select a backend. Prefer CubeB, but it may report a large minimum latency which
         // causes audio issues, in that case go with SDL.
 #if defined(HAVE_CUBEB) && defined(HAVE_SDL2)
-        iter = find_backend(Settings::AudioEngine::Cubeb);
+        iter = find_backend("cubeb");
         if (iter->latency() > TargetSampleCount * 3) {
-            iter = find_backend(Settings::AudioEngine::Sdl2);
+            iter = find_backend("sdl2");
         }
 #else
         iter = std::begin(sink_details);
 #endif
-        LOG_INFO(Service_Audio, "Auto-selecting the {} backend",
-                 Settings::CanonicalizeEnum(iter->id));
+        LOG_INFO(Service_Audio, "Auto-selecting the {} backend", iter->id);
     }
 
     if (iter == std::end(sink_details)) {
-        LOG_ERROR(Audio, "Invalid sink_id {}", Settings::CanonicalizeEnum(sink_id));
-        iter = find_backend(Settings::AudioEngine::Null);
+        LOG_ERROR(Audio, "Invalid sink_id {}", sink_id);
+        iter = find_backend("null");
     }
 
     return *iter;
 }
 } // Anonymous namespace
 
-std::vector<Settings::AudioEngine> GetSinkIDs() {
-    std::vector<Settings::AudioEngine> sink_ids(std::size(sink_details));
+std::vector<std::string_view> GetSinkIDs() {
+    std::vector<std::string_view> sink_ids(std::size(sink_details));
 
     std::transform(std::begin(sink_details), std::end(sink_details), std::begin(sink_ids),
                    [](const auto& sink) { return sink.id; });
@@ -104,11 +102,11 @@ std::vector<Settings::AudioEngine> GetSinkIDs() {
     return sink_ids;
 }
 
-std::vector<std::string> GetDeviceListForSink(Settings::AudioEngine sink_id, bool capture) {
+std::vector<std::string> GetDeviceListForSink(std::string_view sink_id, bool capture) {
     return GetOutputSinkDetails(sink_id).list_devices(capture);
 }
 
-std::unique_ptr<Sink> CreateSinkFromID(Settings::AudioEngine sink_id, std::string_view device_id) {
+std::unique_ptr<Sink> CreateSinkFromID(std::string_view sink_id, std::string_view device_id) {
     return GetOutputSinkDetails(sink_id).factory(device_id);
 }
 

src/audio_core/sink/sink_details.h

@@ -3,11 +3,9 @@
 
 #pragma once
 
-#include <memory>
 #include <string>
 #include <string_view>
 #include <vector>
-#include "common/settings_enums.h"
 
 namespace AudioCore {
 class AudioManager;
@@ -21,7 +19,7 @@ class Sink;
  *
  * @return Vector of available sink names.
  */
-std::vector<Settings::AudioEngine> GetSinkIDs();
+std::vector<std::string_view> GetSinkIDs();
 
 /**
  * Gets the list of devices for a particular sink identified by the given ID.
@@ -30,7 +28,7 @@ std::vector<Settings::AudioEngine> GetSinkIDs();
  * @param capture - Get capture (input) devices, or output devices?
  * @return Vector of device names.
  */
-std::vector<std::string> GetDeviceListForSink(Settings::AudioEngine sink_id, bool capture);
+std::vector<std::string> GetDeviceListForSink(std::string_view sink_id, bool capture);
 
 /**
  * Creates an audio sink identified by the given device ID.
@@ -39,7 +37,7 @@ std::vector<std::string> GetDeviceListForSink(Settings::AudioEngine sink_id, boo
  * @param device_id - Name of the device to create.
  * @return Pointer to the created sink.
  */
-std::unique_ptr<Sink> CreateSinkFromID(Settings::AudioEngine sink_id, std::string_view device_id);
+std::unique_ptr<Sink> CreateSinkFromID(std::string_view sink_id, std::string_view device_id);
 
 } // namespace Sink
 } // namespace AudioCore

src/common/CMakeLists.txt

@@ -110,12 +110,8 @@ add_library(common STATIC
     scratch_buffer.h
     settings.cpp
     settings.h
-    settings_common.cpp
-    settings_common.h
-    settings_enums.h
     settings_input.cpp
     settings_input.h
-    settings_setting.h
     socket_types.h
     spin_lock.cpp
     spin_lock.h
@@ -197,16 +193,9 @@ if (MSVC)
     /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
     /we4800 # Implicit conversion from 'type' to bool. Possible information loss
   )
-endif()
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+else()
   target_compile_options(common PRIVATE
-    -fsized-deallocation
-    -Werror=unreachable-code-aggressive
-  )
-  target_compile_definitions(common PRIVATE
-    # Clang 14 and earlier have errors when explicitly instantiating Settings::Setting
-    $<$<VERSION_LESS:$<CXX_COMPILER_VERSION>,15>:CANNOT_EXPLICITLY_INSTANTIATE>
+    $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
   )
 endif()
 

src/common/logging/backend.cpp

@@ -108,7 +108,7 @@ public:
 
         using namespace Common::Literals;
         // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
-        const auto write_limit = Settings::values.extended_logging.GetValue() ? 1_GiB : 100_MiB;
+        const auto write_limit = Settings::values.extended_logging ? 1_GiB : 100_MiB;
         const bool write_limit_exceeded = bytes_written > write_limit;
         if (entry.log_level >= Level::Error || write_limit_exceeded) {
             if (write_limit_exceeded) {

src/common/settings.cpp

@@ -7,16 +7,9 @@
 #include <exception>
 #include <stdexcept>
 #endif
-#include <compare>
-#include <cstddef>
-#include <filesystem>
-#include <functional>
 #include <string_view>
-#include <type_traits>
-#include <fmt/core.h>
 
 #include "common/assert.h"
-#include "common/fs/fs_util.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
@@ -24,50 +17,11 @@
 
 namespace Settings {
 
-// Clang 14 and earlier have errors when explicitly instantiating these classes
-#ifndef CANNOT_EXPLICITLY_INSTANTIATE
-#define SETTING(TYPE, RANGED) template class Setting<TYPE, RANGED>
-#define SWITCHABLE(TYPE, RANGED) template class SwitchableSetting<TYPE, RANGED>
-
-SETTING(AudioEngine, false);
-SETTING(bool, false);
-SETTING(int, false);
-SETTING(std::string, false);
-SETTING(u16, false);
-SWITCHABLE(AnisotropyMode, true);
-SWITCHABLE(AntiAliasing, false);
-SWITCHABLE(AspectRatio, true);
-SWITCHABLE(AstcDecodeMode, true);
-SWITCHABLE(AstcRecompression, true);
-SWITCHABLE(AudioMode, true);
-SWITCHABLE(CpuAccuracy, true);
-SWITCHABLE(FullscreenMode, true);
-SWITCHABLE(GpuAccuracy, true);
-SWITCHABLE(Language, true);
-SWITCHABLE(NvdecEmulation, false);
-SWITCHABLE(Region, true);
-SWITCHABLE(RendererBackend, true);
-SWITCHABLE(ScalingFilter, false);
-SWITCHABLE(ShaderBackend, true);
-SWITCHABLE(TimeZone, true);
-SETTING(VSyncMode, true);
-SWITCHABLE(bool, false);
-SWITCHABLE(int, false);
-SWITCHABLE(int, true);
-SWITCHABLE(s64, false);
-SWITCHABLE(u16, true);
-SWITCHABLE(u32, false);
-SWITCHABLE(u8, false);
-SWITCHABLE(u8, true);
-
-#undef SETTING
-#undef SWITCHABLE
-#endif
-
 Values values;
+static bool configuring_global = true;
 
-std::string GetTimeZoneString(TimeZone time_zone) {
-    const auto time_zone_index = static_cast<std::size_t>(time_zone);
+std::string GetTimeZoneString() {
+    const auto time_zone_index = static_cast<std::size_t>(values.time_zone_index.GetValue());
     ASSERT(time_zone_index < Common::TimeZone::GetTimeZoneStrings().size());
 
     std::string location_name;
@@ -107,35 +61,73 @@ void LogSettings() {
     };
 
     LOG_INFO(Config, "yuzu Configuration:");
-    for (auto& [category, settings] : values.linkage.by_category) {
-        for (const auto& setting : settings) {
-            if (setting->Id() == values.yuzu_token.Id()) {
-                // Hide the token secret, for security reasons.
-                continue;
-            }
-
-            const auto name = fmt::format(
-                "{:c}{:c} {}.{}", setting->ToString() == setting->DefaultToString() ? '-' : 'M',
-                setting->UsingGlobal() ? '-' : 'C', TranslateCategory(category),
-                setting->GetLabel());
-
-            log_setting(name, setting->Canonicalize());
-        }
-    }
+    log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
+    log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
+    log_setting("System_DeviceName", values.device_name.GetValue());
+    log_setting("System_CurrentUser", values.current_user.GetValue());
+    log_setting("System_LanguageIndex", values.language_index.GetValue());
+    log_setting("System_RegionIndex", values.region_index.GetValue());
+    log_setting("System_TimeZoneIndex", values.time_zone_index.GetValue());
+    log_setting("System_UnsafeMemoryLayout", values.use_unsafe_extended_memory_layout.GetValue());
+    log_setting("Core_UseMultiCore", values.use_multi_core.GetValue());
+    log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
+    log_setting("Renderer_UseResolutionScaling", values.resolution_setup.GetValue());
+    log_setting("Renderer_ScalingFilter", values.scaling_filter.GetValue());
+    log_setting("Renderer_FSRSlider", values.fsr_sharpening_slider.GetValue());
+    log_setting("Renderer_AntiAliasing", values.anti_aliasing.GetValue());
+    log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
+    log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
+    log_setting("Renderer_UseDiskShaderCache", values.use_disk_shader_cache.GetValue());
+    log_setting("Renderer_GPUAccuracyLevel", values.gpu_accuracy.GetValue());
+    log_setting("Renderer_UseAsynchronousGpuEmulation",
+                values.use_asynchronous_gpu_emulation.GetValue());
+    log_setting("Renderer_NvdecEmulation", values.nvdec_emulation.GetValue());
+    log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
+    log_setting("Renderer_AsyncASTC", values.async_astc.GetValue());
+    log_setting("Renderer_AstcRecompression", values.astc_recompression.GetValue());
+    log_setting("Renderer_UseVsync", values.vsync_mode.GetValue());
+    log_setting("Renderer_UseReactiveFlushing", values.use_reactive_flushing.GetValue());
+    log_setting("Renderer_ShaderBackend", values.shader_backend.GetValue());
+    log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
+    log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
+    log_setting("Audio_OutputEngine", values.sink_id.GetValue());
+    log_setting("Audio_OutputDevice", values.audio_output_device_id.GetValue());
+    log_setting("Audio_InputDevice", values.audio_input_device_id.GetValue());
+    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd.GetValue());
     log_path("DataStorage_CacheDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir));
     log_path("DataStorage_ConfigDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir));
     log_path("DataStorage_LoadDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::LoadDir));
     log_path("DataStorage_NANDDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir));
     log_path("DataStorage_SDMCDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir));
+    log_setting("Debugging_ProgramArgs", values.program_args.GetValue());
+    log_setting("Debugging_GDBStub", values.use_gdbstub.GetValue());
+    log_setting("Input_EnableMotion", values.motion_enabled.GetValue());
+    log_setting("Input_EnableVibration", values.vibration_enabled.GetValue());
+    log_setting("Input_EnableTouch", values.touchscreen.enabled);
+    log_setting("Input_EnableMouse", values.mouse_enabled.GetValue());
+    log_setting("Input_EnableKeyboard", values.keyboard_enabled.GetValue());
+    log_setting("Input_EnableRingController", values.enable_ring_controller.GetValue());
+    log_setting("Input_EnableIrSensor", values.enable_ir_sensor.GetValue());
+    log_setting("Input_EnableCustomJoycon", values.enable_joycon_driver.GetValue());
+    log_setting("Input_EnableCustomProController", values.enable_procon_driver.GetValue());
+    log_setting("Input_EnableRawInput", values.enable_raw_input.GetValue());
+}
+
+bool IsConfiguringGlobal() {
+    return configuring_global;
+}
+
+void SetConfiguringGlobal(bool is_global) {
+    configuring_global = is_global;
 }
 
 bool IsGPULevelExtreme() {
-    return values.gpu_accuracy.GetValue() == GpuAccuracy::Extreme;
+    return values.gpu_accuracy.GetValue() == GPUAccuracy::Extreme;
 }
 
 bool IsGPULevelHigh() {
-    return values.gpu_accuracy.GetValue() == GpuAccuracy::Extreme ||
-           values.gpu_accuracy.GetValue() == GpuAccuracy::High;
+    return values.gpu_accuracy.GetValue() == GPUAccuracy::Extreme ||
+           values.gpu_accuracy.GetValue() == GPUAccuracy::High;
 }
 
 bool IsFastmemEnabled() {
@@ -152,61 +144,6 @@ float Volume() {
     return values.volume.GetValue() / static_cast<f32>(values.volume.GetDefault());
 }
 
-const char* TranslateCategory(Category category) {
-    switch (category) {
-    case Category::Audio:
-        return "Audio";
-    case Category::Core:
-        return "Core";
-    case Category::Cpu:
-    case Category::CpuDebug:
-    case Category::CpuUnsafe:
-        return "Cpu";
-    case Category::Renderer:
-    case Category::RendererAdvanced:
-    case Category::RendererDebug:
-        return "Renderer";
-    case Category::System:
-    case Category::SystemAudio:
-        return "System";
-    case Category::DataStorage:
-        return "Data Storage";
-    case Category::Debugging:
-    case Category::DebuggingGraphics:
-        return "Debugging";
-    case Category::Miscellaneous:
-        return "Miscellaneous";
-    case Category::Network:
-        return "Network";
-    case Category::WebService:
-        return "WebService";
-    case Category::AddOns:
-        return "DisabledAddOns";
-    case Category::Controls:
-        return "Controls";
-    case Category::Ui:
-    case Category::UiGeneral:
-        return "UI";
-    case Category::UiLayout:
-        return "UiLayout";
-    case Category::UiGameList:
-        return "UiGameList";
-    case Category::Screenshots:
-        return "Screenshots";
-    case Category::Shortcuts:
-        return "Shortcuts";
-    case Category::Multiplayer:
-        return "Multiplayer";
-    case Category::Services:
-        return "Services";
-    case Category::Paths:
-        return "Paths";
-    case Category::MaxEnum:
-        break;
-    }
-    return "Miscellaneous";
-}
-
 void UpdateRescalingInfo() {
     const auto setup = values.resolution_setup.GetValue();
     auto& info = values.resolution_info;
@@ -275,19 +212,66 @@ void RestoreGlobalState(bool is_powered_on) {
         return;
     }
 
-    for (const auto& reset : values.linkage.restore_functions) {
-        reset();
-    }
-}
+    // Audio
+    values.volume.SetGlobal(true);
 
-static bool configuring_global = true;
+    // Core
+    values.use_multi_core.SetGlobal(true);
+    values.use_unsafe_extended_memory_layout.SetGlobal(true);
 
-bool IsConfiguringGlobal() {
-    return configuring_global;
-}
+    // CPU
+    values.cpu_accuracy.SetGlobal(true);
+    values.cpuopt_unsafe_unfuse_fma.SetGlobal(true);
+    values.cpuopt_unsafe_reduce_fp_error.SetGlobal(true);
+    values.cpuopt_unsafe_ignore_standard_fpcr.SetGlobal(true);
+    values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
+    values.cpuopt_unsafe_fastmem_check.SetGlobal(true);
+    values.cpuopt_unsafe_ignore_global_monitor.SetGlobal(true);
 
-void SetConfiguringGlobal(bool is_global) {
-    configuring_global = is_global;
+    // Renderer
+    values.fsr_sharpening_slider.SetGlobal(true);
+    values.renderer_backend.SetGlobal(true);
+    values.async_presentation.SetGlobal(true);
+    values.renderer_force_max_clock.SetGlobal(true);
+    values.vulkan_device.SetGlobal(true);
+    values.fullscreen_mode.SetGlobal(true);
+    values.aspect_ratio.SetGlobal(true);
+    values.resolution_setup.SetGlobal(true);
+    values.scaling_filter.SetGlobal(true);
+    values.anti_aliasing.SetGlobal(true);
+    values.max_anisotropy.SetGlobal(true);
+    values.use_speed_limit.SetGlobal(true);
+    values.speed_limit.SetGlobal(true);
+    values.use_disk_shader_cache.SetGlobal(true);
+    values.gpu_accuracy.SetGlobal(true);
+    values.use_asynchronous_gpu_emulation.SetGlobal(true);
+    values.nvdec_emulation.SetGlobal(true);
+    values.accelerate_astc.SetGlobal(true);
+    values.async_astc.SetGlobal(true);
+    values.astc_recompression.SetGlobal(true);
+    values.use_reactive_flushing.SetGlobal(true);
+    values.shader_backend.SetGlobal(true);
+    values.use_asynchronous_shaders.SetGlobal(true);
+    values.use_fast_gpu_time.SetGlobal(true);
+    values.use_vulkan_driver_pipeline_cache.SetGlobal(true);
+    values.bg_red.SetGlobal(true);
+    values.bg_green.SetGlobal(true);
+    values.bg_blue.SetGlobal(true);
+    values.enable_compute_pipelines.SetGlobal(true);
+    values.use_video_framerate.SetGlobal(true);
+
+    // System
+    values.language_index.SetGlobal(true);
+    values.region_index.SetGlobal(true);
+    values.time_zone_index.SetGlobal(true);
+    values.rng_seed.SetGlobal(true);
+    values.sound_index.SetGlobal(true);
+
+    // Controls
+    values.players.SetGlobal(true);
+    values.use_docked_mode.SetGlobal(true);
+    values.vibration_enabled.SetGlobal(true);
+    values.motion_enabled.SetGlobal(true);
 }
 
 } // namespace Settings

src/common/settings.h

@@ -6,21 +6,95 @@
 #include <algorithm>
 #include <array>
 #include <map>
-#include <memory>
-#include <stdexcept>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "common/common_types.h"
-#include "common/settings_common.h"
-#include "common/settings_enums.h"
 #include "common/settings_input.h"
-#include "common/settings_setting.h"
 
 namespace Settings {
 
-const char* TranslateCategory(Settings::Category category);
+enum class VSyncMode : u32 {
+    Immediate = 0,
+    Mailbox = 1,
+    FIFO = 2,
+    FIFORelaxed = 3,
+};
+
+enum class RendererBackend : u32 {
+    OpenGL = 0,
+    Vulkan = 1,
+    Null = 2,
+};
+
+enum class ShaderBackend : u32 {
+    GLSL = 0,
+    GLASM = 1,
+    SPIRV = 2,
+};
+
+enum class GPUAccuracy : u32 {
+    Normal = 0,
+    High = 1,
+    Extreme = 2,
+};
+
+enum class CPUAccuracy : u32 {
+    Auto = 0,
+    Accurate = 1,
+    Unsafe = 2,
+    Paranoid = 3,
+};
+
+enum class FullscreenMode : u32 {
+    Borderless = 0,
+    Exclusive = 1,
+};
+
+enum class NvdecEmulation : u32 {
+    Off = 0,
+    CPU = 1,
+    GPU = 2,
+};
+
+enum class ResolutionSetup : u32 {
+    Res1_2X = 0,
+    Res3_4X = 1,
+    Res1X = 2,
+    Res3_2X = 3,
+    Res2X = 4,
+    Res3X = 5,
+    Res4X = 6,
+    Res5X = 7,
+    Res6X = 8,
+    Res7X = 9,
+    Res8X = 10,
+};
+
+enum class ScalingFilter : u32 {
+    NearestNeighbor = 0,
+    Bilinear = 1,
+    Bicubic = 2,
+    Gaussian = 3,
+    ScaleForce = 4,
+    Fsr = 5,
+    LastFilter = Fsr,
+};
+
+enum class AntiAliasing : u32 {
+    None = 0,
+    Fxaa = 1,
+    Smaa = 2,
+    LastAA = Smaa,
+};
+
+enum class AstcRecompression : u32 {
+    Uncompressed = 0,
+    Bc1 = 1,
+    Bc3 = 2,
+};
 
 struct ResolutionScalingInfo {
     u32 up_scale{1};
@@ -45,47 +119,239 @@ struct ResolutionScalingInfo {
     }
 };
 
-#ifndef CANNOT_EXPLICITLY_INSTANTIATE
-// Instantiate the classes elsewhere (settings.cpp) to reduce compiler/linker work
-#define SETTING(TYPE, RANGED) extern template class Setting<TYPE, RANGED>
-#define SWITCHABLE(TYPE, RANGED) extern template class SwitchableSetting<TYPE, RANGED>
+/** The Setting class is a simple resource manager. It defines a label and default value alongside
+ * the actual value of the setting for simpler and less-error prone use with frontend
+ * configurations. Specifying a default value and label is required. A minimum and maximum range can
+ * be specified for sanitization.
+ */
+template <typename Type, bool ranged = false>
+class Setting {
+protected:
+    Setting() = default;
 
-SETTING(AudioEngine, false);
-SETTING(bool, false);
-SETTING(int, false);
-SETTING(s32, false);
-SETTING(std::string, false);
-SETTING(std::string, false);
-SETTING(u16, false);
-SWITCHABLE(AnisotropyMode, true);
-SWITCHABLE(AntiAliasing, false);
-SWITCHABLE(AspectRatio, true);
-SWITCHABLE(AstcDecodeMode, true);
-SWITCHABLE(AstcRecompression, true);
-SWITCHABLE(AudioMode, true);
-SWITCHABLE(CpuAccuracy, true);
-SWITCHABLE(FullscreenMode, true);
-SWITCHABLE(GpuAccuracy, true);
-SWITCHABLE(Language, true);
-SWITCHABLE(NvdecEmulation, false);
-SWITCHABLE(Region, true);
-SWITCHABLE(RendererBackend, true);
-SWITCHABLE(ScalingFilter, false);
-SWITCHABLE(ShaderBackend, true);
-SWITCHABLE(TimeZone, true);
-SETTING(VSyncMode, true);
-SWITCHABLE(bool, false);
-SWITCHABLE(int, false);
-SWITCHABLE(int, true);
-SWITCHABLE(s64, false);
-SWITCHABLE(u16, true);
-SWITCHABLE(u32, false);
-SWITCHABLE(u8, false);
-SWITCHABLE(u8, true);
+    /**
+     * Only sets the setting to the given initializer, leaving the other members to their default
+     * initializers.
+     *
+     * @param global_val Initial value of the setting
+     */
+    explicit Setting(const Type& val) : value{val} {}
 
-#undef SETTING
-#undef SWITCHABLE
-#endif
+public:
+    /**
+     * Sets a default value, label, and setting value.
+     *
+     * @param default_val Initial value of the setting, and default value of the setting
+     * @param name Label for the setting
+     */
+    explicit Setting(const Type& default_val, const std::string& name)
+        requires(!ranged)
+        : value{default_val}, default_value{default_val}, label{name} {}
+    virtual ~Setting() = default;
+
+    /**
+     * Sets a default value, minimum value, maximum value, and label.
+     *
+     * @param default_val Initial value of the setting, and default value of the setting
+     * @param min_val Sets the minimum allowed value of the setting
+     * @param max_val Sets the maximum allowed value of the setting
+     * @param name Label for the setting
+     */
+    explicit Setting(const Type& default_val, const Type& min_val, const Type& max_val,
+                     const std::string& name)
+        requires(ranged)
+        : value{default_val},
+          default_value{default_val}, maximum{max_val}, minimum{min_val}, label{name} {}
+
+    /**
+     *  Returns a reference to the setting's value.
+     *
+     * @returns A reference to the setting
+     */
+    [[nodiscard]] virtual const Type& GetValue() const {
+        return value;
+    }
+
+    /**
+     * Sets the setting to the given value.
+     *
+     * @param val The desired value
+     */
+    virtual void SetValue(const Type& val) {
+        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
+        std::swap(value, temp);
+    }
+
+    /**
+     * Returns the value that this setting was created with.
+     *
+     * @returns A reference to the default value
+     */
+    [[nodiscard]] const Type& GetDefault() const {
+        return default_value;
+    }
+
+    /**
+     * Returns the label this setting was created with.
+     *
+     * @returns A reference to the label
+     */
+    [[nodiscard]] const std::string& GetLabel() const {
+        return label;
+    }
+
+    /**
+     * Assigns a value to the setting.
+     *
+     * @param val The desired setting value
+     *
+     * @returns A reference to the setting
+     */
+    virtual const Type& operator=(const Type& val) {
+        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
+        std::swap(value, temp);
+        return value;
+    }
+
+    /**
+     * Returns a reference to the setting.
+     *
+     * @returns A reference to the setting
+     */
+    explicit virtual operator const Type&() const {
+        return value;
+    }
+
+protected:
+    Type value{};               ///< The setting
+    const Type default_value{}; ///< The default value
+    const Type maximum{};       ///< Maximum allowed value of the setting
+    const Type minimum{};       ///< Minimum allowed value of the setting
+    const std::string label{};  ///< The setting's label
+};
+
+/**
+ * The SwitchableSetting class is a slightly more complex version of the Setting class. This adds a
+ * custom setting to switch to when a guest application specifically requires it. The effect is that
+ * other components of the emulator can access the setting's intended value without any need for the
+ * component to ask whether the custom or global setting is needed at the moment.
+ *
+ * By default, the global setting is used.
+ */
+template <typename Type, bool ranged = false>
+class SwitchableSetting : virtual public Setting<Type, ranged> {
+public:
+    /**
+     * Sets a default value, label, and setting value.
+     *
+     * @param default_val Initial value of the setting, and default value of the setting
+     * @param name Label for the setting
+     */
+    explicit SwitchableSetting(const Type& default_val, const std::string& name)
+        requires(!ranged)
+        : Setting<Type>{default_val, name} {}
+    virtual ~SwitchableSetting() = default;
+
+    /**
+     * Sets a default value, minimum value, maximum value, and label.
+     *
+     * @param default_val Initial value of the setting, and default value of the setting
+     * @param min_val Sets the minimum allowed value of the setting
+     * @param max_val Sets the maximum allowed value of the setting
+     * @param name Label for the setting
+     */
+    explicit SwitchableSetting(const Type& default_val, const Type& min_val, const Type& max_val,
+                               const std::string& name)
+        requires(ranged)
+        : Setting<Type, true>{default_val, min_val, max_val, name} {}
+
+    /**
+     * Tells this setting to represent either the global or custom setting when other member
+     * functions are used.
+     *
+     * @param to_global Whether to use the global or custom setting.
+     */
+    void SetGlobal(bool to_global) {
+        use_global = to_global;
+    }
+
+    /**
+     * Returns whether this setting is using the global setting or not.
+     *
+     * @returns The global state
+     */
+    [[nodiscard]] bool UsingGlobal() const {
+        return use_global;
+    }
+
+    /**
+     * Returns either the global or custom setting depending on the values of this setting's global
+     * state or if the global value was specifically requested.
+     *
+     * @param need_global Request global value regardless of setting's state; defaults to false
+     *
+     * @returns The required value of the setting
+     */
+    [[nodiscard]] virtual const Type& GetValue() const override {
+        if (use_global) {
+            return this->value;
+        }
+        return custom;
+    }
+    [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
+        if (use_global || need_global) {
+            return this->value;
+        }
+        return custom;
+    }
+
+    /**
+     * Sets the current setting value depending on the global state.
+     *
+     * @param val The new value
+     */
+    void SetValue(const Type& val) override {
+        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
+        if (use_global) {
+            std::swap(this->value, temp);
+        } else {
+            std::swap(custom, temp);
+        }
+    }
+
+    /**
+     * Assigns the current setting value depending on the global state.
+     *
+     * @param val The new value
+     *
+     * @returns A reference to the current setting value
+     */
+    const Type& operator=(const Type& val) override {
+        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
+        if (use_global) {
+            std::swap(this->value, temp);
+            return this->value;
+        }
+        std::swap(custom, temp);
+        return custom;
+    }
+
+    /**
+     * Returns the current setting value depending on the global state.
+     *
+     * @returns A reference to the current setting value
+     */
+    virtual explicit operator const Type&() const override {
+        if (use_global) {
+            return this->value;
+        }
+        return custom;
+    }
+
+protected:
+    bool use_global{true}; ///< The setting's global state
+    Type custom{};         ///< The custom value of the setting
+};
 
 /**
  * The InputSetting class allows for getting a reference to either the global or custom members.
@@ -125,388 +391,208 @@ struct TouchFromButtonMap {
 };
 
 struct Values {
-    Linkage linkage{};
-
     // Audio
-    Setting<AudioEngine> sink_id{linkage, AudioEngine::Auto, "output_engine", Category::Audio,
-                                 Specialization::RuntimeList};
-    Setting<std::string> audio_output_device_id{linkage, "auto", "output_device", Category::Audio,
-                                                Specialization::RuntimeList};
-    Setting<std::string> audio_input_device_id{linkage, "auto", "input_device", Category::Audio,
-                                               Specialization::RuntimeList};
-    SwitchableSetting<AudioMode, true> sound_index{
-        linkage,       AudioMode::Stereo,     AudioMode::Mono,         AudioMode::Surround,
-        "sound_index", Category::SystemAudio, Specialization::Default, true,
-        true};
-    SwitchableSetting<u8, true> volume{linkage,
-                                       100,
-                                       0,
-                                       200,
-                                       "volume",
-                                       Category::Audio,
-                                       Specialization::Scalar | Specialization::Percentage,
-                                       true,
-                                       true};
-    Setting<bool, false> audio_muted{
-        linkage, false, "audio_muted", Category::Audio, Specialization::Default, false, true};
-    Setting<bool, false> dump_audio_commands{
-        linkage, false, "dump_audio_commands", Category::Audio, Specialization::Default, false};
+    Setting<std::string> sink_id{"auto", "output_engine"};
+    Setting<std::string> audio_output_device_id{"auto", "output_device"};
+    Setting<std::string> audio_input_device_id{"auto", "input_device"};
+    Setting<bool> audio_muted{false, "audio_muted"};
+    SwitchableSetting<u8, true> volume{100, 0, 200, "volume"};
+    Setting<bool> dump_audio_commands{false, "dump_audio_commands"};
 
     // Core
-    SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
-    SwitchableSetting<MemoryLayout, true> memory_layout_mode{linkage,
-                                                             MemoryLayout::Memory_4Gb,
-                                                             MemoryLayout::Memory_4Gb,
-                                                             MemoryLayout::Memory_8Gb,
-                                                             "memory_layout_mode",
-                                                             Category::Core};
-    SwitchableSetting<bool> use_speed_limit{
-        linkage, true, "use_speed_limit", Category::Core, Specialization::Paired, false, true};
-    SwitchableSetting<u16, true> speed_limit{linkage,
-                                             100,
-                                             0,
-                                             9999,
-                                             "speed_limit",
-                                             Category::Core,
-                                             Specialization::Countable | Specialization::Percentage,
-                                             true,
-                                             true,
-                                             &use_speed_limit};
+    SwitchableSetting<bool> use_multi_core{true, "use_multi_core"};
+    SwitchableSetting<bool> use_unsafe_extended_memory_layout{false,
+                                                              "use_unsafe_extended_memory_layout"};
 
     // Cpu
-    SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage,           CpuAccuracy::Auto,
-                                                      CpuAccuracy::Auto, CpuAccuracy::Paranoid,
-                                                      "cpu_accuracy",    Category::Cpu};
-    Setting<bool> cpu_debug_mode{linkage, false, "cpu_debug_mode", Category::CpuDebug};
+    SwitchableSetting<CPUAccuracy, true> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
+                                                      CPUAccuracy::Paranoid, "cpu_accuracy"};
+    // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
+    Setting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
+    Setting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
 
-    Setting<bool> cpuopt_page_tables{linkage, true, "cpuopt_page_tables", Category::CpuDebug};
-    Setting<bool> cpuopt_block_linking{linkage, true, "cpuopt_block_linking", Category::CpuDebug};
-    Setting<bool> cpuopt_return_stack_buffer{linkage, true, "cpuopt_return_stack_buffer",
-                                             Category::CpuDebug};
-    Setting<bool> cpuopt_fast_dispatcher{linkage, true, "cpuopt_fast_dispatcher",
-                                         Category::CpuDebug};
-    Setting<bool> cpuopt_context_elimination{linkage, true, "cpuopt_context_elimination",
-                                             Category::CpuDebug};
-    Setting<bool> cpuopt_const_prop{linkage, true, "cpuopt_const_prop", Category::CpuDebug};
-    Setting<bool> cpuopt_misc_ir{linkage, true, "cpuopt_misc_ir", Category::CpuDebug};
-    Setting<bool> cpuopt_reduce_misalign_checks{linkage, true, "cpuopt_reduce_misalign_checks",
-                                                Category::CpuDebug};
-    Setting<bool> cpuopt_fastmem{linkage, true, "cpuopt_fastmem", Category::CpuDebug};
-    Setting<bool> cpuopt_fastmem_exclusives{linkage, true, "cpuopt_fastmem_exclusives",
-                                            Category::CpuDebug};
-    Setting<bool> cpuopt_recompile_exclusives{linkage, true, "cpuopt_recompile_exclusives",
-                                              Category::CpuDebug};
-    Setting<bool> cpuopt_ignore_memory_aborts{linkage, true, "cpuopt_ignore_memory_aborts",
-                                              Category::CpuDebug};
+    Setting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
+    Setting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
+    Setting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
+    Setting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
+    Setting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
+    Setting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
+    Setting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
+    Setting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
+    Setting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
+    Setting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
+    Setting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
+    Setting<bool> cpuopt_ignore_memory_aborts{true, "cpuopt_ignore_memory_aborts"};
 
-    SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{linkage, true, "cpuopt_unsafe_unfuse_fma",
-                                                     Category::CpuUnsafe};
-    SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{
-        linkage, true, "cpuopt_unsafe_reduce_fp_error", Category::CpuUnsafe};
+    SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
+    SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
     SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{
-        linkage, true, "cpuopt_unsafe_ignore_standard_fpcr", Category::CpuUnsafe};
-    SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{
-        linkage, true, "cpuopt_unsafe_inaccurate_nan", Category::CpuUnsafe};
-    SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{
-        linkage, true, "cpuopt_unsafe_fastmem_check", Category::CpuUnsafe};
+        true, "cpuopt_unsafe_ignore_standard_fpcr"};
+    SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
+    SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
     SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{
-        linkage, true, "cpuopt_unsafe_ignore_global_monitor", Category::CpuUnsafe};
+        true, "cpuopt_unsafe_ignore_global_monitor"};
 
     // Renderer
     SwitchableSetting<RendererBackend, true> renderer_backend{
-        linkage,   RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null,
-        "backend", Category::Renderer};
-    SwitchableSetting<ShaderBackend, true> shader_backend{
-        linkage,          ShaderBackend::Glsl, ShaderBackend::Glsl,        ShaderBackend::SpirV,
-        "shader_backend", Category::Renderer,  Specialization::RuntimeList};
-    SwitchableSetting<int> vulkan_device{linkage, 0, "vulkan_device", Category::Renderer,
-                                         Specialization::RuntimeList};
+        RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
+    SwitchableSetting<bool> async_presentation{false, "async_presentation"};
+    SwitchableSetting<bool> renderer_force_max_clock{false, "force_max_clock"};
+    Setting<bool> renderer_debug{false, "debug"};
+    Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
+    Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
+    Setting<bool> disable_shader_loop_safety_checks{false, "disable_shader_loop_safety_checks"};
+    SwitchableSetting<int> vulkan_device{0, "vulkan_device"};
 
-    SwitchableSetting<bool> use_disk_shader_cache{linkage, true, "use_disk_shader_cache",
-                                                  Category::Renderer};
-    SwitchableSetting<bool> use_asynchronous_gpu_emulation{
-        linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
-    SwitchableSetting<AstcDecodeMode, true> accelerate_astc{linkage,
-                                                            AstcDecodeMode::Gpu,
-                                                            AstcDecodeMode::Cpu,
-                                                            AstcDecodeMode::CpuAsynchronous,
-                                                            "accelerate_astc",
-                                                            Category::Renderer};
-    Setting<VSyncMode, true> vsync_mode{
-        linkage,     VSyncMode::Fifo,    VSyncMode::Immediate,        VSyncMode::FifoRelaxed,
-        "use_vsync", Category::Renderer, Specialization::RuntimeList, true,
-        true};
-    SwitchableSetting<NvdecEmulation> nvdec_emulation{linkage, NvdecEmulation::Gpu,
-                                                      "nvdec_emulation", Category::Renderer};
+    ResolutionScalingInfo resolution_info{};
+    SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
+    SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
+    SwitchableSetting<int, true> fsr_sharpening_slider{25, 0, 200, "fsr_sharpening_slider"};
+    SwitchableSetting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
     // *nix platforms may have issues with the borderless windowed fullscreen mode.
     // Default to exclusive fullscreen on these platforms for now.
-    SwitchableSetting<FullscreenMode, true> fullscreen_mode{linkage,
+    SwitchableSetting<FullscreenMode, true> fullscreen_mode{
 #ifdef _WIN32
         FullscreenMode::Borderless,
 #else
         FullscreenMode::Exclusive,
 #endif
-                                                            FullscreenMode::Borderless,
-                                                            FullscreenMode::Exclusive,
-                                                            "fullscreen_mode",
-                                                            Category::Renderer,
-                                                            Specialization::Default,
-                                                            true,
-                                                            true};
-    SwitchableSetting<AspectRatio, true> aspect_ratio{linkage,
-                                                      AspectRatio::R16_9,
-                                                      AspectRatio::R16_9,
-                                                      AspectRatio::Stretch,
-                                                      "aspect_ratio",
-                                                      Category::Renderer,
-                                                      Specialization::Default,
-                                                      true,
-                                                      true};
+        FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
+    SwitchableSetting<int, true> aspect_ratio{0, 0, 4, "aspect_ratio"};
+    SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"};
+    SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
+    SwitchableSetting<u16, true> speed_limit{100, 0, 9999, "speed_limit"};
+    SwitchableSetting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
+    SwitchableSetting<GPUAccuracy, true> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
+                                                      GPUAccuracy::Extreme, "gpu_accuracy"};
+    SwitchableSetting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
+    SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
+    SwitchableSetting<bool> accelerate_astc{true, "accelerate_astc"};
+    SwitchableSetting<bool> async_astc{false, "async_astc"};
+    Setting<VSyncMode, true> vsync_mode{VSyncMode::FIFO, VSyncMode::Immediate,
+                                        VSyncMode::FIFORelaxed, "use_vsync"};
+    SwitchableSetting<bool> use_reactive_flushing{true, "use_reactive_flushing"};
+    SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLSL, ShaderBackend::GLSL,
+                                                          ShaderBackend::SPIRV, "shader_backend"};
+    SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
+    SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
+    SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true,
+                                                             "use_vulkan_driver_pipeline_cache"};
+    SwitchableSetting<bool> enable_compute_pipelines{false, "enable_compute_pipelines"};
+    SwitchableSetting<AstcRecompression, true> astc_recompression{
+        AstcRecompression::Uncompressed, AstcRecompression::Uncompressed, AstcRecompression::Bc3,
+        "astc_recompression"};
+    SwitchableSetting<bool> use_video_framerate{false, "use_video_framerate"};
+    SwitchableSetting<bool> barrier_feedback_loops{true, "barrier_feedback_loops"};
 
-    ResolutionScalingInfo resolution_info{};
-    SwitchableSetting<ResolutionSetup> resolution_setup{linkage, ResolutionSetup::Res1X,
-                                                        "resolution_setup", Category::Renderer};
-    SwitchableSetting<ScalingFilter> scaling_filter{linkage,
-                                                    ScalingFilter::Bilinear,
-                                                    "scaling_filter",
-                                                    Category::Renderer,
-                                                    Specialization::Default,
-                                                    true,
-                                                    true};
-    SwitchableSetting<AntiAliasing> anti_aliasing{linkage,
-                                                  AntiAliasing::None,
-                                                  "anti_aliasing",
-                                                  Category::Renderer,
-                                                  Specialization::Default,
-                                                  true,
-                                                  true};
-    SwitchableSetting<int, true> fsr_sharpening_slider{linkage,
-                                                       25,
-                                                       0,
-                                                       200,
-                                                       "fsr_sharpening_slider",
-                                                       Category::Renderer,
-                                                       Specialization::Scalar |
-                                                           Specialization::Percentage,
-                                                       true,
-                                                       true};
-
-    SwitchableSetting<u8, false> bg_red{
-        linkage, 0, "bg_red", Category::Renderer, Specialization::Default, true, true};
-    SwitchableSetting<u8, false> bg_green{
-        linkage, 0, "bg_green", Category::Renderer, Specialization::Default, true, true};
-    SwitchableSetting<u8, false> bg_blue{
-        linkage, 0, "bg_blue", Category::Renderer, Specialization::Default, true, true};
-
-    SwitchableSetting<GpuAccuracy, true> gpu_accuracy{linkage,
-                                                      GpuAccuracy::High,
-                                                      GpuAccuracy::Normal,
-                                                      GpuAccuracy::Extreme,
-                                                      "gpu_accuracy",
-                                                      Category::RendererAdvanced,
-                                                      Specialization::Default,
-                                                      true,
-                                                      true};
-    SwitchableSetting<AnisotropyMode, true> max_anisotropy{
-        linkage,          AnisotropyMode::Automatic, AnisotropyMode::Automatic, AnisotropyMode::X16,
-        "max_anisotropy", Category::RendererAdvanced};
-    SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
-                                                                  AstcRecompression::Uncompressed,
-                                                                  AstcRecompression::Uncompressed,
-                                                                  AstcRecompression::Bc3,
-                                                                  "astc_recompression",
-                                                                  Category::RendererAdvanced};
-    SwitchableSetting<bool> async_presentation{linkage, false, "async_presentation",
-                                               Category::RendererAdvanced};
-    SwitchableSetting<bool> renderer_force_max_clock{linkage, false, "force_max_clock",
-                                                     Category::RendererAdvanced};
-    SwitchableSetting<bool> use_reactive_flushing{linkage, true, "use_reactive_flushing",
-                                                  Category::RendererAdvanced};
-    SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
-                                                     Category::RendererAdvanced};
-    SwitchableSetting<bool> use_fast_gpu_time{
-        linkage, true, "use_fast_gpu_time", Category::RendererAdvanced, Specialization::Default,
-        true,    true};
-    SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{linkage,
-                                                             true,
-                                                             "use_vulkan_driver_pipeline_cache",
-                                                             Category::RendererAdvanced,
-                                                             Specialization::Default,
-                                                             true,
-                                                             true};
-    SwitchableSetting<bool> enable_compute_pipelines{linkage, false, "enable_compute_pipelines",
-                                                     Category::RendererAdvanced};
-    SwitchableSetting<bool> use_video_framerate{linkage, false, "use_video_framerate",
-                                                Category::RendererAdvanced};
-    SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops",
-                                                   Category::RendererAdvanced};
-
-    Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
-    Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
-                                           Category::RendererDebug};
-    Setting<bool> enable_nsight_aftermath{linkage, false, "nsight_aftermath",
-                                          Category::RendererDebug};
-    Setting<bool> disable_shader_loop_safety_checks{
-        linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
+    SwitchableSetting<u8> bg_red{0, "bg_red"};
+    SwitchableSetting<u8> bg_green{0, "bg_green"};
+    SwitchableSetting<u8> bg_blue{0, "bg_blue"};
 
     // System
-    SwitchableSetting<Language, true> language_index{linkage,
-                                                     Language::EnglishAmerican,
-                                                     Language::Japanese,
-                                                     Language::PortugueseBrazilian,
-                                                     "language_index",
-                                                     Category::System};
-    SwitchableSetting<Region, true> region_index{linkage,        Region::Usa,    Region::Japan,
-                                                 Region::Taiwan, "region_index", Category::System};
-    SwitchableSetting<TimeZone, true> time_zone_index{linkage,           TimeZone::Auto,
-                                                      TimeZone::Auto,    TimeZone::Zulu,
-                                                      "time_zone_index", Category::System};
+    SwitchableSetting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    Setting<std::string> device_name{"Yuzu", "device_name"};
     // Measured in seconds since epoch
-    SwitchableSetting<bool> custom_rtc_enabled{
-        linkage, false, "custom_rtc_enabled", Category::System, Specialization::Paired, true, true};
-    SwitchableSetting<s64> custom_rtc{
-        linkage, 0,    "custom_rtc",       Category::System, Specialization::Time,
-        true,    true, &custom_rtc_enabled};
+    std::optional<s64> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
     s64 custom_rtc_differential;
-    SwitchableSetting<bool> rng_seed_enabled{
-        linkage, false, "rng_seed_enabled", Category::System, Specialization::Paired, true, true};
-    SwitchableSetting<u32> rng_seed{
-        linkage, 0,    "rng_seed",       Category::System, Specialization::Hex,
-        true,    true, &rng_seed_enabled};
-    Setting<std::string> device_name{
-        linkage, "yuzu", "device_name", Category::System, Specialization::Default, true, true};
 
-    Setting<s32> current_user{linkage, 0, "current_user", Category::System};
-
-    SwitchableSetting<bool> use_docked_mode{linkage, true, "use_docked_mode", Category::System};
+    Setting<s32> current_user{0, "current_user"};
+    SwitchableSetting<s32, true> language_index{1, 0, 17, "language_index"};
+    SwitchableSetting<s32, true> region_index{1, 0, 6, "region_index"};
+    SwitchableSetting<s32, true> time_zone_index{0, 0, 45, "time_zone_index"};
+    SwitchableSetting<s32, true> sound_index{1, 0, 2, "sound_index"};
 
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
 
-    Setting<bool> enable_raw_input{
-        linkage, false, "enable_raw_input", Category::Controls, Specialization::Default,
-// Only read/write enable_raw_input on Windows platforms
-#ifdef _WIN32
-        true
-#else
-        false
-#endif
-    };
-    Setting<bool> controller_navigation{linkage, true, "controller_navigation", Category::Controls};
-    Setting<bool> enable_joycon_driver{linkage, true, "enable_joycon_driver", Category::Controls};
-    Setting<bool> enable_procon_driver{linkage, false, "enable_procon_driver", Category::Controls};
+    SwitchableSetting<bool> use_docked_mode{true, "use_docked_mode"};
 
-    SwitchableSetting<bool> vibration_enabled{linkage, true, "vibration_enabled",
-                                              Category::Controls};
-    SwitchableSetting<bool> enable_accurate_vibrations{linkage, false, "enable_accurate_vibrations",
-                                                       Category::Controls};
+    Setting<bool> enable_raw_input{false, "enable_raw_input"};
+    Setting<bool> controller_navigation{true, "controller_navigation"};
+    Setting<bool> enable_joycon_driver{true, "enable_joycon_driver"};
+    Setting<bool> enable_procon_driver{false, "enable_procon_driver"};
 
-    SwitchableSetting<bool> motion_enabled{linkage, true, "motion_enabled", Category::Controls};
-    Setting<std::string> udp_input_servers{linkage, "127.0.0.1:26760", "udp_input_servers",
-                                           Category::Controls};
-    Setting<bool> enable_udp_controller{linkage, false, "enable_udp_controller",
-                                        Category::Controls};
+    SwitchableSetting<bool> vibration_enabled{true, "vibration_enabled"};
+    SwitchableSetting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
 
-    Setting<bool> pause_tas_on_load{linkage, true, "pause_tas_on_load", Category::Controls};
-    Setting<bool> tas_enable{linkage, false, "tas_enable", Category::Controls};
-    Setting<bool> tas_loop{linkage, false, "tas_loop", Category::Controls};
+    SwitchableSetting<bool> motion_enabled{true, "motion_enabled"};
+    Setting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
+    Setting<bool> enable_udp_controller{false, "enable_udp_controller"};
 
-    Setting<bool> mouse_panning{
-        linkage, false, "mouse_panning", Category::Controls, Specialization::Default, false};
-    Setting<u8, true> mouse_panning_sensitivity{
-        linkage, 50, 1, 100, "mouse_panning_sensitivity", Category::Controls};
-    Setting<bool> mouse_enabled{linkage, false, "mouse_enabled", Category::Controls};
+    Setting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
+    Setting<bool> tas_enable{false, "tas_enable"};
+    Setting<bool> tas_loop{false, "tas_loop"};
 
-    Setting<u8, true> mouse_panning_x_sensitivity{
-        linkage, 50, 1, 100, "mouse_panning_x_sensitivity", Category::Controls};
-    Setting<u8, true> mouse_panning_y_sensitivity{
-        linkage, 50, 1, 100, "mouse_panning_y_sensitivity", Category::Controls};
-    Setting<u8, true> mouse_panning_deadzone_counterweight{
-        linkage, 20, 0, 100, "mouse_panning_deadzone_counterweight", Category::Controls};
-    Setting<u8, true> mouse_panning_decay_strength{
-        linkage, 18, 0, 100, "mouse_panning_decay_strength", Category::Controls};
-    Setting<u8, true> mouse_panning_min_decay{
-        linkage, 6, 0, 100, "mouse_panning_min_decay", Category::Controls};
+    Setting<bool> mouse_panning{false, "mouse_panning"};
+    Setting<u8, true> mouse_panning_x_sensitivity{50, 1, 100, "mouse_panning_x_sensitivity"};
+    Setting<u8, true> mouse_panning_y_sensitivity{50, 1, 100, "mouse_panning_y_sensitivity"};
+    Setting<u8, true> mouse_panning_deadzone_counterweight{20, 0, 100,
+                                                           "mouse_panning_deadzone_counterweight"};
+    Setting<u8, true> mouse_panning_decay_strength{18, 0, 100, "mouse_panning_decay_strength"};
+    Setting<u8, true> mouse_panning_min_decay{6, 0, 100, "mouse_panning_min_decay"};
 
-    Setting<bool> emulate_analog_keyboard{linkage, false, "emulate_analog_keyboard",
-                                          Category::Controls};
-    Setting<bool> keyboard_enabled{linkage, false, "keyboard_enabled", Category::Controls};
+    Setting<bool> mouse_enabled{false, "mouse_enabled"};
+    Setting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
+    Setting<bool> keyboard_enabled{false, "keyboard_enabled"};
 
-    Setting<bool> debug_pad_enabled{linkage, false, "debug_pad_enabled", Category::Controls};
+    Setting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
     ButtonsRaw debug_pad_buttons;
     AnalogsRaw debug_pad_analogs;
 
     TouchscreenInput touchscreen;
 
-    Setting<std::string> touch_device{linkage, "min_x:100,min_y:50,max_x:1800,max_y:850",
-                                      "touch_device", Category::Controls};
-    Setting<int> touch_from_button_map_index{linkage, 0, "touch_from_button_map",
-                                             Category::Controls};
+    Setting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850", "touch_device"};
+    Setting<int> touch_from_button_map_index{0, "touch_from_button_map"};
     std::vector<TouchFromButtonMap> touch_from_button_maps;
 
-    Setting<bool> enable_ring_controller{linkage, true, "enable_ring_controller",
-                                         Category::Controls};
+    Setting<bool> enable_ring_controller{true, "enable_ring_controller"};
     RingconRaw ringcon_analogs;
 
-    Setting<bool> enable_ir_sensor{linkage, false, "enable_ir_sensor", Category::Controls};
-    Setting<std::string> ir_sensor_device{linkage, "auto", "ir_sensor_device", Category::Controls};
+    Setting<bool> enable_ir_sensor{false, "enable_ir_sensor"};
+    Setting<std::string> ir_sensor_device{"auto", "ir_sensor_device"};
 
-    Setting<bool> random_amiibo_id{linkage, false, "random_amiibo_id", Category::Controls};
+    Setting<bool> random_amiibo_id{false, "random_amiibo_id"};
 
     // Data Storage
-    Setting<bool> use_virtual_sd{linkage, true, "use_virtual_sd", Category::DataStorage};
-    Setting<bool> gamecard_inserted{linkage, false, "gamecard_inserted", Category::DataStorage};
-    Setting<bool> gamecard_current_game{linkage, false, "gamecard_current_game",
-                                        Category::DataStorage};
-    Setting<std::string> gamecard_path{linkage, std::string(), "gamecard_path",
-                                       Category::DataStorage};
+    Setting<bool> use_virtual_sd{true, "use_virtual_sd"};
+    Setting<bool> gamecard_inserted{false, "gamecard_inserted"};
+    Setting<bool> gamecard_current_game{false, "gamecard_current_game"};
+    Setting<std::string> gamecard_path{std::string(), "gamecard_path"};
 
     // Debugging
     bool record_frame_times;
-    Setting<bool> use_gdbstub{linkage, false, "use_gdbstub", Category::Debugging};
-    Setting<u16> gdbstub_port{linkage, 6543, "gdbstub_port", Category::Debugging};
-    Setting<std::string> program_args{linkage, std::string(), "program_args", Category::Debugging};
-    Setting<bool> dump_exefs{linkage, false, "dump_exefs", Category::Debugging};
-    Setting<bool> dump_nso{linkage, false, "dump_nso", Category::Debugging};
-    Setting<bool> dump_shaders{
-        linkage, false, "dump_shaders", Category::DebuggingGraphics, Specialization::Default,
-        false};
-    Setting<bool> dump_macros{
-        linkage, false, "dump_macros", Category::DebuggingGraphics, Specialization::Default, false};
-    Setting<bool> enable_fs_access_log{linkage, false, "enable_fs_access_log", Category::Debugging};
-    Setting<bool> reporting_services{
-        linkage, false, "reporting_services", Category::Debugging, Specialization::Default, false};
-    Setting<bool> quest_flag{linkage, false, "quest_flag", Category::Debugging};
-    Setting<bool> disable_macro_jit{linkage, false, "disable_macro_jit",
-                                    Category::DebuggingGraphics};
-    Setting<bool> disable_macro_hle{linkage, false, "disable_macro_hle",
-                                    Category::DebuggingGraphics};
-    Setting<bool> extended_logging{
-        linkage, false, "extended_logging", Category::Debugging, Specialization::Default, false};
-    Setting<bool> use_debug_asserts{linkage, false, "use_debug_asserts", Category::Debugging};
-    Setting<bool> use_auto_stub{
-        linkage, false, "use_auto_stub", Category::Debugging, Specialization::Default, false};
-    Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers",
-                                         Category::Debugging};
-    Setting<bool> create_crash_dumps{linkage, false, "create_crash_dumps", Category::Debugging};
-    Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging};
+    Setting<bool> use_gdbstub{false, "use_gdbstub"};
+    Setting<u16> gdbstub_port{6543, "gdbstub_port"};
+    Setting<std::string> program_args{std::string(), "program_args"};
+    Setting<bool> dump_exefs{false, "dump_exefs"};
+    Setting<bool> dump_nso{false, "dump_nso"};
+    Setting<bool> dump_shaders{false, "dump_shaders"};
+    Setting<bool> dump_macros{false, "dump_macros"};
+    Setting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
+    Setting<bool> reporting_services{false, "reporting_services"};
+    Setting<bool> quest_flag{false, "quest_flag"};
+    Setting<bool> disable_macro_jit{false, "disable_macro_jit"};
+    Setting<bool> disable_macro_hle{false, "disable_macro_hle"};
+    Setting<bool> extended_logging{false, "extended_logging"};
+    Setting<bool> use_debug_asserts{false, "use_debug_asserts"};
+    Setting<bool> use_auto_stub{false, "use_auto_stub"};
+    Setting<bool> enable_all_controllers{false, "enable_all_controllers"};
+    Setting<bool> create_crash_dumps{false, "create_crash_dumps"};
+    Setting<bool> perform_vulkan_check{true, "perform_vulkan_check"};
 
     // Miscellaneous
-    Setting<std::string> log_filter{linkage, "*:Info", "log_filter", Category::Miscellaneous};
-    Setting<bool> use_dev_keys{linkage, false, "use_dev_keys", Category::Miscellaneous};
+    Setting<std::string> log_filter{"*:Info", "log_filter"};
+    Setting<bool> use_dev_keys{false, "use_dev_keys"};
 
     // Network
-    Setting<std::string> network_interface{linkage, std::string(), "network_interface",
-                                           Category::Network};
+    Setting<std::string> network_interface{std::string(), "network_interface"};
 
     // WebService
-    Setting<bool> enable_telemetry{linkage, true, "enable_telemetry", Category::WebService};
-    Setting<std::string> web_api_url{linkage, "https://api.yuzu-emu.org", "web_api_url",
-                                     Category::WebService};
-    Setting<std::string> yuzu_username{linkage, std::string(), "yuzu_username",
-                                       Category::WebService};
-    Setting<std::string> yuzu_token{linkage, std::string(), "yuzu_token", Category::WebService};
+    Setting<bool> enable_telemetry{true, "enable_telemetry"};
+    Setting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
+    Setting<std::string> yuzu_username{std::string(), "yuzu_username"};
+    Setting<std::string> yuzu_token{std::string(), "yuzu_token"};
 
     // Add-Ons
     std::map<u64, std::vector<std::string>> disabled_addons;
@@ -514,6 +600,9 @@ struct Values {
 
 extern Values values;
 
+bool IsConfiguringGlobal();
+void SetConfiguringGlobal(bool is_global);
+
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();
 
@@ -521,7 +610,7 @@ bool IsFastmemEnabled();
 
 float Volume();
 
-std::string GetTimeZoneString(TimeZone time_zone);
+std::string GetTimeZoneString();
 
 void LogSettings();
 
@@ -530,7 +619,4 @@ void UpdateRescalingInfo();
 // Restore the global state of all applicable settings in the Values struct
 void RestoreGlobalState(bool is_powered_on);
 
-bool IsConfiguringGlobal();
-void SetConfiguringGlobal(bool is_global);
-
 } // namespace Settings

src/common/settings_common.cpp

@@ -1,58 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <string>
-#include "common/settings_common.h"
-
-namespace Settings {
-
-BasicSetting::BasicSetting(Linkage& linkage, const std::string& name, enum Category category_,
-                           bool save_, bool runtime_modifiable_, u32 specialization_,
-                           BasicSetting* other_setting_)
-    : label{name}, category{category_}, id{linkage.count}, save{save_},
-      runtime_modifiable{runtime_modifiable_}, specialization{specialization_},
-      other_setting{other_setting_} {
-    linkage.by_category[category].push_back(this);
-    linkage.count++;
-}
-
-BasicSetting::~BasicSetting() = default;
-
-std::string BasicSetting::ToStringGlobal() const {
-    return this->ToString();
-}
-
-bool BasicSetting::UsingGlobal() const {
-    return true;
-}
-
-void BasicSetting::SetGlobal(bool global) {}
-
-bool BasicSetting::Save() const {
-    return save;
-}
-
-bool BasicSetting::RuntimeModfiable() const {
-    return runtime_modifiable;
-}
-
-Category BasicSetting::GetCategory() const {
-    return category;
-}
-
-u32 BasicSetting::Specialization() const {
-    return specialization;
-}
-
-BasicSetting* BasicSetting::PairedSetting() const {
-    return other_setting;
-}
-
-const std::string& BasicSetting::GetLabel() const {
-    return label;
-}
-
-Linkage::Linkage(u32 initial_count) : count{initial_count} {}
-Linkage::~Linkage() = default;
-
-} // namespace Settings

src/common/settings_common.h

@@ -1,256 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <functional>
-#include <map>
-#include <string>
-#include <typeindex>
-#include "common/common_types.h"
-
-namespace Settings {
-
-enum class Category : u32 {
-    Audio,
-    Core,
-    Cpu,
-    CpuDebug,
-    CpuUnsafe,
-    Renderer,
-    RendererAdvanced,
-    RendererDebug,
-    System,
-    SystemAudio,
-    DataStorage,
-    Debugging,
-    DebuggingGraphics,
-    Miscellaneous,
-    Network,
-    WebService,
-    AddOns,
-    Controls,
-    Ui,
-    UiGeneral,
-    UiLayout,
-    UiGameList,
-    Screenshots,
-    Shortcuts,
-    Multiplayer,
-    Services,
-    Paths,
-    MaxEnum,
-};
-
-constexpr u8 SpecializationTypeMask = 0xf;
-constexpr u8 SpecializationAttributeMask = 0xf0;
-constexpr u8 SpecializationAttributeOffset = 4;
-
-// Scalar and countable could have better names
-enum Specialization : u8 {
-    Default = 0,
-    Time = 1,        // Duration or specific moment in time
-    Hex = 2,         // Hexadecimal number
-    List = 3,        // Setting has specific members
-    RuntimeList = 4, // Members of the list are determined during runtime
-    Scalar = 5,      // Values are continuous
-    Countable = 6,   // Can be stepped through
-    Paired = 7,      // Another setting is associated with this setting
-
-    Percentage = (1 << SpecializationAttributeOffset), // Should be represented as a percentage
-};
-
-class BasicSetting;
-
-class Linkage {
-public:
-    explicit Linkage(u32 initial_count = 0);
-    ~Linkage();
-    std::map<Category, std::vector<BasicSetting*>> by_category{};
-    std::vector<std::function<void()>> restore_functions{};
-    u32 count;
-};
-
-/**
- * BasicSetting is an abstract class that only keeps track of metadata. The string methods are
- * available to get data values out.
- */
-class BasicSetting {
-protected:
-    explicit BasicSetting(Linkage& linkage, const std::string& name, Category category_, bool save_,
-                          bool runtime_modifiable_, u32 specialization,
-                          BasicSetting* other_setting);
-
-public:
-    virtual ~BasicSetting();
-
-    /*
-     * Data retrieval
-     */
-
-    /**
-     * Returns a string representation of the internal data. If the Setting is Switchable, it
-     * respects the internal global state: it is based on GetValue().
-     *
-     * @returns A string representation of the internal data.
-     */
-    [[nodiscard]] virtual std::string ToString() const = 0;
-
-    /**
-     * Returns a string representation of the global version of internal data. If the Setting is
-     * not Switchable, it behaves like ToString.
-     *
-     * @returns A string representation of the global version of internal data.
-     */
-    [[nodiscard]] virtual std::string ToStringGlobal() const;
-
-    /**
-     * @returns A string representation of the Setting's default value.
-     */
-    [[nodiscard]] virtual std::string DefaultToString() const = 0;
-
-    /**
-     * Returns a string representation of the minimum value of the setting. If the Setting is not
-     * ranged, the string represents the default initialization of the data type.
-     *
-     * @returns A string representation of the minimum value of the setting.
-     */
-    [[nodiscard]] virtual std::string MinVal() const = 0;
-
-    /**
-     * Returns a string representation of the maximum value of the setting. If the Setting is not
-     * ranged, the string represents the default initialization of the data type.
-     *
-     * @returns A string representation of the maximum value of the setting.
-     */
-    [[nodiscard]] virtual std::string MaxVal() const = 0;
-
-    /**
-     * Takes a string input, converts it to the internal data type if necessary, and then runs
-     * SetValue with it.
-     *
-     * @param load String of the input data.
-     */
-    virtual void LoadString(const std::string& load) = 0;
-
-    /**
-     * Returns a string representation of the data. If the data is an enum, it returns a string of
-     * the enum value. If the internal data type is not an enum, this is equivalent to ToString.
-     *
-     * e.g. renderer_backend.Canonicalize() == "OpenGL"
-     *
-     * @returns Canonicalized string representation of the internal data
-     */
-    [[nodiscard]] virtual std::string Canonicalize() const = 0;
-
-    /*
-     * Metadata
-     */
-
-    /**
-     * @returns A unique identifier for the Setting's internal data type.
-     */
-    [[nodiscard]] virtual std::type_index TypeId() const = 0;
-
-    /**
-     * Returns true if the Setting's internal data type is an enum.
-     *
-     * @returns True if the Setting's internal data type is an enum
-     */
-    [[nodiscard]] virtual constexpr bool IsEnum() const = 0;
-
-    /**
-     * Returns true if the current setting is Switchable.
-     *
-     * @returns If the setting is a SwitchableSetting
-     */
-    [[nodiscard]] virtual constexpr bool Switchable() const {
-        return false;
-    }
-
-    /**
-     * Returns true to suggest that a frontend can read or write the setting to a configuration
-     * file.
-     *
-     * @returns The save preference
-     */
-    [[nodiscard]] bool Save() const;
-
-    /**
-     * @returns true if the current setting can be changed while the guest is running.
-     */
-    [[nodiscard]] bool RuntimeModfiable() const;
-
-    /**
-     * @returns A unique number corresponding to the setting.
-     */
-    [[nodiscard]] constexpr u32 Id() const {
-        return id;
-    }
-
-    /**
-     * Returns the setting's category AKA INI group.
-     *
-     * @returns The setting's category
-     */
-    [[nodiscard]] Category GetCategory() const;
-
-    /**
-     * @returns Extra metadata for data representation in frontend implementations.
-     */
-    [[nodiscard]] u32 Specialization() const;
-
-    /**
-     * @returns Another BasicSetting if one is paired, or nullptr otherwise.
-     */
-    [[nodiscard]] BasicSetting* PairedSetting() const;
-
-    /**
-     * Returns the label this setting was created with.
-     *
-     * @returns A reference to the label
-     */
-    [[nodiscard]] const std::string& GetLabel() const;
-
-    /**
-     * @returns If the Setting checks input values for valid ranges.
-     */
-    [[nodiscard]] virtual constexpr bool Ranged() const = 0;
-
-    /**
-     * @returns The index of the enum if the underlying setting type is an enum, else max of u32.
-     */
-    [[nodiscard]] virtual constexpr u32 EnumIndex() const = 0;
-
-    /*
-     * Switchable settings
-     */
-
-    /**
-     * Sets a setting's global state. True means use the normal setting, false to use a custom
-     * value. Has no effect if the Setting is not Switchable.
-     *
-     * @param global The desired state
-     */
-    virtual void SetGlobal(bool global);
-
-    /**
-     * Returns true if the setting is using the normal setting value. Always true if the setting is
-     * not Switchable.
-     *
-     * @returns The Setting's global state
-     */
-    [[nodiscard]] virtual bool UsingGlobal() const;
-
-private:
-    const std::string label; ///< The setting's label
-    const Category category; ///< The setting's category AKA INI group
-    const u32 id;            ///< Unique integer for the setting
-    const bool save; ///< Suggests if the setting should be saved and read to a frontend config
-    const bool
-        runtime_modifiable;   ///< Suggests if the setting can be modified while a guest is running
-    const u32 specialization; ///< Extra data to identify representation of a setting
-    BasicSetting* const other_setting; ///< A paired setting
-};
-
-} // namespace Settings

src/common/settings_enums.h

@@ -1,214 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <string>
-#include <utility>
-#include <vector>
-#include "common/common_types.h"
-
-namespace Settings {
-
-template <typename T>
-struct EnumMetadata {
-    static constexpr std::vector<std::pair<std::string, T>> Canonicalizations();
-    static constexpr u32 Index();
-};
-
-#define PAIR_45(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_46(N, __VA_ARGS__))
-#define PAIR_44(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_45(N, __VA_ARGS__))
-#define PAIR_43(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_44(N, __VA_ARGS__))
-#define PAIR_42(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_43(N, __VA_ARGS__))
-#define PAIR_41(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_42(N, __VA_ARGS__))
-#define PAIR_40(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_41(N, __VA_ARGS__))
-#define PAIR_39(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_40(N, __VA_ARGS__))
-#define PAIR_38(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_39(N, __VA_ARGS__))
-#define PAIR_37(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_38(N, __VA_ARGS__))
-#define PAIR_36(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_37(N, __VA_ARGS__))
-#define PAIR_35(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_36(N, __VA_ARGS__))
-#define PAIR_34(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_35(N, __VA_ARGS__))
-#define PAIR_33(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_34(N, __VA_ARGS__))
-#define PAIR_32(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_33(N, __VA_ARGS__))
-#define PAIR_31(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_32(N, __VA_ARGS__))
-#define PAIR_30(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_31(N, __VA_ARGS__))
-#define PAIR_29(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_30(N, __VA_ARGS__))
-#define PAIR_28(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_29(N, __VA_ARGS__))
-#define PAIR_27(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_28(N, __VA_ARGS__))
-#define PAIR_26(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_27(N, __VA_ARGS__))
-#define PAIR_25(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_26(N, __VA_ARGS__))
-#define PAIR_24(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_25(N, __VA_ARGS__))
-#define PAIR_23(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_24(N, __VA_ARGS__))
-#define PAIR_22(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_23(N, __VA_ARGS__))
-#define PAIR_21(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_22(N, __VA_ARGS__))
-#define PAIR_20(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_21(N, __VA_ARGS__))
-#define PAIR_19(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_20(N, __VA_ARGS__))
-#define PAIR_18(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_19(N, __VA_ARGS__))
-#define PAIR_17(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_18(N, __VA_ARGS__))
-#define PAIR_16(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_17(N, __VA_ARGS__))
-#define PAIR_15(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_16(N, __VA_ARGS__))
-#define PAIR_14(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_15(N, __VA_ARGS__))
-#define PAIR_13(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_14(N, __VA_ARGS__))
-#define PAIR_12(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_13(N, __VA_ARGS__))
-#define PAIR_11(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_12(N, __VA_ARGS__))
-#define PAIR_10(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_11(N, __VA_ARGS__))
-#define PAIR_9(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_10(N, __VA_ARGS__))
-#define PAIR_8(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_9(N, __VA_ARGS__))
-#define PAIR_7(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_8(N, __VA_ARGS__))
-#define PAIR_6(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_7(N, __VA_ARGS__))
-#define PAIR_5(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_6(N, __VA_ARGS__))
-#define PAIR_4(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_5(N, __VA_ARGS__))
-#define PAIR_3(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_4(N, __VA_ARGS__))
-#define PAIR_2(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_3(N, __VA_ARGS__))
-#define PAIR_1(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_2(N, __VA_ARGS__))
-#define PAIR(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_1(N, __VA_ARGS__))
-
-#define ENUM(NAME, ...)                                                                            \
-    enum class NAME : u32 { __VA_ARGS__ };                                                         \
-    template <>                                                                                    \
-    constexpr std::vector<std::pair<std::string, NAME>> EnumMetadata<NAME>::Canonicalizations() {  \
-        return {PAIR(NAME, __VA_ARGS__)};                                                          \
-    }                                                                                              \
-    template <>                                                                                    \
-    constexpr u32 EnumMetadata<NAME>::Index() {                                                    \
-        return __COUNTER__;                                                                        \
-    }
-
-// AudioEngine must be specified discretely due to having existing but slightly different
-// canonicalizations
-// TODO (lat9nq): Remove explicit definition of AudioEngine/sink_id
-enum class AudioEngine : u32 {
-    Auto,
-    Cubeb,
-    Sdl2,
-    Null,
-};
-
-template <>
-constexpr std::vector<std::pair<std::string, AudioEngine>>
-EnumMetadata<AudioEngine>::Canonicalizations() {
-    return {
-        {"auto", AudioEngine::Auto},
-        {"cubeb", AudioEngine::Cubeb},
-        {"sdl2", AudioEngine::Sdl2},
-        {"null", AudioEngine::Null},
-    };
-}
-
-template <>
-constexpr u32 EnumMetadata<AudioEngine>::Index() {
-    // This is just a sufficiently large number that is more than the number of other enums declared
-    // here
-    return 100;
-}
-
-ENUM(AudioMode, Mono, Stereo, Surround);
-
-ENUM(Language, Japanese, EnglishAmerican, French, German, Italian, Spanish, Chinese, Korean, Dutch,
-     Portuguese, Russian, Taiwanese, EnglishBritish, FrenchCanadian, SpanishLatin,
-     ChineseSimplified, ChineseTraditional, PortugueseBrazilian);
-
-ENUM(Region, Japan, Usa, Europe, Australia, China, Korea, Taiwan);
-
-ENUM(TimeZone, Auto, Default, Cet, Cst6Cdt, Cuba, Eet, Egypt, Eire, Est, Est5Edt, Gb, GbEire, Gmt,
-     GmtPlusZero, GmtMinusZero, GmtZero, Greenwich, Hongkong, Hst, Iceland, Iran, Israel, Jamaica,
-     Japan, Kwajalein, Libya, Met, Mst, Mst7Mdt, Navajo, Nz, NzChat, Poland, Portugal, Prc, Pst8Pdt,
-     Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
-
-ENUM(AnisotropyMode, Automatic, Default, X2, X4, X8, X16);
-
-ENUM(AstcDecodeMode, Cpu, Gpu, CpuAsynchronous);
-
-ENUM(AstcRecompression, Uncompressed, Bc1, Bc3);
-
-ENUM(VSyncMode, Immediate, Mailbox, Fifo, FifoRelaxed);
-
-ENUM(RendererBackend, OpenGL, Vulkan, Null);
-
-ENUM(ShaderBackend, Glsl, Glasm, SpirV);
-
-ENUM(GpuAccuracy, Normal, High, Extreme);
-
-ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid);
-
-ENUM(MemoryLayout, Memory_4Gb, Memory_6Gb, Memory_8Gb);
-
-ENUM(FullscreenMode, Borderless, Exclusive);
-
-ENUM(NvdecEmulation, Off, Cpu, Gpu);
-
-ENUM(ResolutionSetup, Res1_2X, Res3_4X, Res1X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X, Res7X,
-     Res8X);
-
-ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, ScaleForce, Fsr, MaxEnum);
-
-ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
-
-ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
-
-template <typename Type>
-constexpr std::string CanonicalizeEnum(Type id) {
-    const auto group = EnumMetadata<Type>::Canonicalizations();
-    for (auto& [name, value] : group) {
-        if (value == id) {
-            return name;
-        }
-    }
-    return "unknown";
-}
-
-template <typename Type>
-constexpr Type ToEnum(const std::string& canonicalization) {
-    const auto group = EnumMetadata<Type>::Canonicalizations();
-    for (auto& [name, value] : group) {
-        if (name == canonicalization) {
-            return value;
-        }
-    }
-    return {};
-}
-} // namespace Settings
-
-#undef ENUM
-#undef PAIR
-#undef PAIR_1
-#undef PAIR_2
-#undef PAIR_3
-#undef PAIR_4
-#undef PAIR_5
-#undef PAIR_6
-#undef PAIR_7
-#undef PAIR_8
-#undef PAIR_9
-#undef PAIR_10
-#undef PAIR_12
-#undef PAIR_13
-#undef PAIR_14
-#undef PAIR_15
-#undef PAIR_16
-#undef PAIR_17
-#undef PAIR_18
-#undef PAIR_19
-#undef PAIR_20
-#undef PAIR_22
-#undef PAIR_23
-#undef PAIR_24
-#undef PAIR_25
-#undef PAIR_26
-#undef PAIR_27
-#undef PAIR_28
-#undef PAIR_29
-#undef PAIR_30
-#undef PAIR_32
-#undef PAIR_33
-#undef PAIR_34
-#undef PAIR_35
-#undef PAIR_36
-#undef PAIR_37
-#undef PAIR_38
-#undef PAIR_39
-#undef PAIR_40
-#undef PAIR_42
-#undef PAIR_43
-#undef PAIR_44
-#undef PAIR_45

src/common/settings_setting.h

@@ -1,394 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <limits>
-#include <map>
-#include <optional>
-#include <stdexcept>
-#include <string>
-#include <typeindex>
-#include <typeinfo>
-#include "common/common_types.h"
-#include "common/settings_common.h"
-#include "common/settings_enums.h"
-
-namespace Settings {
-
-/** The Setting class is a simple resource manager. It defines a label and default value
- * alongside the actual value of the setting for simpler and less-error prone use with frontend
- * configurations. Specifying a default value and label is required. A minimum and maximum range
- * can be specified for sanitization.
- */
-template <typename Type, bool ranged = false>
-class Setting : public BasicSetting {
-protected:
-    Setting() = default;
-
-public:
-    /**
-     * Sets a default value, label, and setting value.
-     *
-     * @param linkage Setting registry
-     * @param default_val Initial value of the setting, and default value of the setting
-     * @param name Label for the setting
-     * @param category_ Category of the setting AKA INI group
-     * @param specialization_ Suggestion for how frontend implementations represent this in a config
-     * @param save_ Suggests that this should or should not be saved to a frontend config file
-     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
-     * @param other_setting_ A second Setting to associate to this one in metadata
-     */
-    explicit Setting(Linkage& linkage, const Type& default_val, const std::string& name,
-                     Category category_, u32 specialization_ = Specialization::Default,
-                     bool save_ = true, bool runtime_modifiable_ = false,
-                     BasicSetting* other_setting_ = nullptr)
-        requires(!ranged)
-        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_,
-                       other_setting_),
-          value{default_val}, default_value{default_val} {}
-    virtual ~Setting() = default;
-
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param linkage Setting registry
-     * @param default_val Initial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     * @param category_ Category of the setting AKA INI group
-     * @param specialization_ Suggestion for how frontend implementations represent this in a config
-     * @param save_ Suggests that this should or should not be saved to a frontend config file
-     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
-     * @param other_setting_ A second Setting to associate to this one in metadata
-     */
-    explicit Setting(Linkage& linkage, const Type& default_val, const Type& min_val,
-                     const Type& max_val, const std::string& name, Category category_,
-                     u32 specialization_ = Specialization::Default, bool save_ = true,
-                     bool runtime_modifiable_ = false, BasicSetting* other_setting_ = nullptr)
-        requires(ranged)
-        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_,
-                       other_setting_),
-          value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val} {}
-
-    /**
-     *  Returns a reference to the setting's value.
-     *
-     * @returns A reference to the setting
-     */
-    [[nodiscard]] virtual const Type& GetValue() const {
-        return value;
-    }
-
-    /**
-     * Sets the setting to the given value.
-     *
-     * @param val The desired value
-     */
-    virtual void SetValue(const Type& val) {
-        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
-        std::swap(value, temp);
-    }
-
-    /**
-     * Returns the value that this setting was created with.
-     *
-     * @returns A reference to the default value
-     */
-    [[nodiscard]] const Type& GetDefault() const {
-        return default_value;
-    }
-
-    [[nodiscard]] constexpr bool IsEnum() const override {
-        return std::is_enum_v<Type>;
-    }
-
-protected:
-    [[nodiscard]] std::string ToString(const Type& value_) const {
-        if constexpr (std::is_same_v<Type, std::string>) {
-            return value_;
-        } else if constexpr (std::is_same_v<Type, std::optional<u32>>) {
-            return value_.has_value() ? std::to_string(*value_) : "none";
-        } else if constexpr (std::is_same_v<Type, bool>) {
-            return value_ ? "true" : "false";
-        } else if constexpr (std::is_same_v<Type, AudioEngine>) {
-            // Compatibility with old AudioEngine setting being a string
-            return CanonicalizeEnum(value_);
-        } else {
-            return std::to_string(static_cast<u64>(value_));
-        }
-    }
-
-public:
-    /**
-     * Converts the value of the setting to a std::string. Respects the global state if the setting
-     * has one.
-     *
-     * @returns The current setting as a std::string
-     */
-    [[nodiscard]] std::string ToString() const override {
-        return ToString(this->GetValue());
-    }
-
-    /**
-     * Returns the default value of the setting as a std::string.
-     *
-     * @returns The default value as a string.
-     */
-    [[nodiscard]] std::string DefaultToString() const override {
-        return ToString(default_value);
-    }
-
-    /**
-     * Assigns a value to the setting.
-     *
-     * @param val The desired setting value
-     *
-     * @returns A reference to the setting
-     */
-    virtual const Type& operator=(const Type& val) {
-        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
-        std::swap(value, temp);
-        return value;
-    }
-
-    /**
-     * Returns a reference to the setting.
-     *
-     * @returns A reference to the setting
-     */
-    explicit virtual operator const Type&() const {
-        return value;
-    }
-
-    /**
-     * Converts the given value to the Setting's type of value. Uses SetValue to enter the setting,
-     * thus respecting its constraints.
-     *
-     * @param input The desired value
-     */
-    void LoadString(const std::string& input) override final {
-        if (input.empty()) {
-            this->SetValue(this->GetDefault());
-            return;
-        }
-        try {
-            if constexpr (std::is_same_v<Type, std::string>) {
-                this->SetValue(input);
-            } else if constexpr (std::is_same_v<Type, std::optional<u32>>) {
-                this->SetValue(static_cast<u32>(std::stoul(input)));
-            } else if constexpr (std::is_same_v<Type, bool>) {
-                this->SetValue(input == "true");
-            } else if constexpr (std::is_same_v<Type, AudioEngine>) {
-                this->SetValue(ToEnum<Type>(input));
-            } else {
-                this->SetValue(static_cast<Type>(std::stoll(input)));
-            }
-        } catch (std::invalid_argument&) {
-            this->SetValue(this->GetDefault());
-        }
-    }
-
-    [[nodiscard]] std::string constexpr Canonicalize() const override final {
-        if constexpr (std::is_enum_v<Type>) {
-            return CanonicalizeEnum(this->GetValue());
-        } else {
-            return ToString(this->GetValue());
-        }
-    }
-
-    /**
-     * Gives us another way to identify the setting without having to go through a string.
-     *
-     * @returns the type_index of the setting's type
-     */
-    [[nodiscard]] std::type_index TypeId() const override final {
-        return std::type_index(typeid(Type));
-    }
-
-    [[nodiscard]] constexpr u32 EnumIndex() const override final {
-        if constexpr (std::is_enum_v<Type>) {
-            return EnumMetadata<Type>::Index();
-        } else {
-            return std::numeric_limits<u32>::max();
-        }
-    }
-
-    [[nodiscard]] std::string MinVal() const override final {
-        return this->ToString(minimum);
-    }
-    [[nodiscard]] std::string MaxVal() const override final {
-        return this->ToString(maximum);
-    }
-
-    [[nodiscard]] constexpr bool Ranged() const override {
-        return ranged;
-    }
-
-protected:
-    Type value{};               ///< The setting
-    const Type default_value{}; ///< The default value
-    const Type maximum{};       ///< Maximum allowed value of the setting
-    const Type minimum{};       ///< Minimum allowed value of the setting
-};
-
-/**
- * The SwitchableSetting class is a slightly more complex version of the Setting class. This adds a
- * custom setting to switch to when a guest application specifically requires it. The effect is that
- * other components of the emulator can access the setting's intended value without any need for the
- * component to ask whether the custom or global setting is needed at the moment.
- *
- * By default, the global setting is used.
- */
-template <typename Type, bool ranged = false>
-class SwitchableSetting : virtual public Setting<Type, ranged> {
-public:
-    /**
-     * Sets a default value, label, and setting value.
-     *
-     * @param linkage Setting registry
-     * @param default_val Initial value of the setting, and default value of the setting
-     * @param name Label for the setting
-     * @param category_ Category of the setting AKA INI group
-     * @param specialization_ Suggestion for how frontend implementations represent this in a config
-     * @param save_ Suggests that this should or should not be saved to a frontend config file
-     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
-     * @param other_setting_ A second Setting to associate to this one in metadata
-     */
-    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,
-                               Category category_, u32 specialization_ = Specialization::Default,
-                               bool save_ = true, bool runtime_modifiable_ = false,
-                               BasicSetting* other_setting_ = nullptr)
-        requires(!ranged)
-        : Setting<Type, false>{
-              linkage, default_val,         name,          category_, specialization_,
-              save_,   runtime_modifiable_, other_setting_} {
-        linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
-    }
-    virtual ~SwitchableSetting() = default;
-
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param linkage Setting registry
-     * @param default_val Initial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     * @param category_ Category of the setting AKA INI group
-     * @param specialization_ Suggestion for how frontend implementations represent this in a config
-     * @param save_ Suggests that this should or should not be saved to a frontend config file
-     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
-     * @param other_setting_ A second Setting to associate to this one in metadata
-     */
-    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,
-                               const Type& max_val, const std::string& name, Category category_,
-                               u32 specialization_ = Specialization::Default, bool save_ = true,
-                               bool runtime_modifiable_ = false,
-                               BasicSetting* other_setting_ = nullptr)
-        requires(ranged)
-        : Setting<Type, true>{linkage,         default_val, min_val,
-                              max_val,         name,        category_,
-                              specialization_, save_,       runtime_modifiable_,
-                              other_setting_} {
-        linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
-    }
-
-    /**
-     * Tells this setting to represent either the global or custom setting when other member
-     * functions are used.
-     *
-     * @param to_global Whether to use the global or custom setting.
-     */
-    void SetGlobal(bool to_global) override final {
-        use_global = to_global;
-    }
-
-    /**
-     * Returns whether this setting is using the global setting or not.
-     *
-     * @returns The global state
-     */
-    [[nodiscard]] bool UsingGlobal() const override final {
-        return use_global;
-    }
-
-    /**
-     * Returns either the global or custom setting depending on the values of this setting's global
-     * state or if the global value was specifically requested.
-     *
-     * @param need_global Request global value regardless of setting's state; defaults to false
-     *
-     * @returns The required value of the setting
-     */
-    [[nodiscard]] const Type& GetValue() const override final {
-        if (use_global) {
-            return this->value;
-        }
-        return custom;
-    }
-    [[nodiscard]] const Type& GetValue(bool need_global) const {
-        if (use_global || need_global) {
-            return this->value;
-        }
-        return custom;
-    }
-
-    /**
-     * Sets the current setting value depending on the global state.
-     *
-     * @param val The new value
-     */
-    void SetValue(const Type& val) override final {
-        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
-        if (use_global) {
-            std::swap(this->value, temp);
-        } else {
-            std::swap(custom, temp);
-        }
-    }
-
-    [[nodiscard]] constexpr bool Switchable() const override final {
-        return true;
-    }
-
-    [[nodiscard]] std::string ToStringGlobal() const override final {
-        return this->ToString(this->value);
-    }
-
-    /**
-     * Assigns the current setting value depending on the global state.
-     *
-     * @param val The new value
-     *
-     * @returns A reference to the current setting value
-     */
-    const Type& operator=(const Type& val) override final {
-        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
-        if (use_global) {
-            std::swap(this->value, temp);
-            return this->value;
-        }
-        std::swap(custom, temp);
-        return custom;
-    }
-
-    /**
-     * Returns the current setting value depending on the global state.
-     *
-     * @returns A reference to the current setting value
-     */
-    explicit operator const Type&() const override final {
-        if (use_global) {
-            return this->value;
-        }
-        return custom;
-    }
-
-protected:
-    bool use_global{true}; ///< The setting's global state
-    Type custom{};         ///< The custom value of the setting
-};
-
-} // namespace Settings

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -287,7 +287,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         }
     } else {
         // Unsafe optimizations
-        if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Unsafe) {
+        if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
             config.unsafe_optimizations = true;
             if (Settings::values.cpuopt_unsafe_unfuse_fma) {
                 config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
@@ -307,7 +307,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         }
 
         // Curated optimizations
-        if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Auto) {
+        if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
             config.unsafe_optimizations = true;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
@@ -316,7 +316,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         }
 
         // Paranoia mode for debugging optimizations
-        if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Paranoid) {
+        if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Paranoid) {
             config.unsafe_optimizations = false;
             config.optimizations = Dynarmic::no_optimizations;
         }

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -347,7 +347,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         }
     } else {
         // Unsafe optimizations
-        if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Unsafe) {
+        if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
             config.unsafe_optimizations = true;
             if (Settings::values.cpuopt_unsafe_unfuse_fma) {
                 config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
@@ -367,7 +367,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         }
 
         // Curated optimizations
-        if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Auto) {
+        if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
             config.unsafe_optimizations = true;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
             config.fastmem_address_space_bits = 64;
@@ -375,7 +375,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         }
 
         // Paranoia mode for debugging optimizations
-        if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Paranoid) {
+        if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Paranoid) {
             config.unsafe_optimizations = false;
             config.optimizations = Dynarmic::no_optimizations;
         }

src/core/core.cpp

@@ -12,7 +12,6 @@
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/settings.h"
-#include "common/settings_enums.h"
 #include "common/string_util.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
@@ -141,13 +140,16 @@ struct System::Impl {
         device_memory = std::make_unique<Core::DeviceMemory>();
 
         is_multicore = Settings::values.use_multi_core.GetValue();
-        extended_memory_layout =
-            Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        extended_memory_layout = Settings::values.use_unsafe_extended_memory_layout.GetValue();
 
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        RefreshTime();
+        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
+        const auto current_time =
+            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
+        Settings::values.custom_rtc_differential =
+            Settings::values.custom_rtc.value_or(current_time) - current_time;
 
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr) {
@@ -170,8 +172,7 @@ struct System::Impl {
     void ReinitializeIfNecessary(System& system) {
         const bool must_reinitialize =
             is_multicore != Settings::values.use_multi_core.GetValue() ||
-            extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb);
+            extended_memory_layout != Settings::values.use_unsafe_extended_memory_layout.GetValue();
 
         if (!must_reinitialize) {
             return;
@@ -180,22 +181,11 @@ struct System::Impl {
         LOG_DEBUG(Kernel, "Re-initializing");
 
         is_multicore = Settings::values.use_multi_core.GetValue();
-        extended_memory_layout =
-            Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        extended_memory_layout = Settings::values.use_unsafe_extended_memory_layout.GetValue();
 
         Initialize(system);
     }
 
-    void RefreshTime() {
-        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
-        const auto current_time =
-            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
-        Settings::values.custom_rtc_differential =
-            (Settings::values.custom_rtc_enabled ? Settings::values.custom_rtc.GetValue()
-                                                 : current_time) -
-            current_time;
-    }
-
     void Run() {
         std::unique_lock<std::mutex> lk(suspend_guard);
 
@@ -1038,8 +1028,6 @@ void System::Exit() {
 }
 
 void System::ApplySettings() {
-    impl->RefreshTime();
-
     if (IsPoweredOn()) {
         Renderer().RefreshBaseSettings();
     }

src/core/file_sys/control_metadata.cpp

@@ -68,8 +68,7 @@ NACP::NACP(VirtualFile file) {
 NACP::~NACP() = default;
 
 const LanguageEntry& NACP::GetLanguageEntry() const {
-    Language language =
-        language_to_codes[static_cast<s32>(Settings::values.language_index.GetValue())];
+    Language language = language_to_codes[Settings::values.language_index.GetValue()];
 
     {
         const auto& language_entry = raw.language_entries.at(static_cast<u8>(language));

src/core/file_sys/patch_manager.cpp

@@ -626,8 +626,8 @@ PatchManager::Metadata PatchManager::ParseControlNCA(const NCA& nca) const {
     auto nacp = nacp_file == nullptr ? nullptr : std::make_unique<NACP>(nacp_file);
 
     // Get language code from settings
-    const auto language_code = Service::Set::GetLanguageCodeFromIndex(
-        static_cast<u32>(Settings::values.language_index.GetValue()));
+    const auto language_code =
+        Service::Set::GetLanguageCodeFromIndex(Settings::values.language_index.GetValue());
 
     // Convert to application language and get priority list
     const auto application_language =

src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp

@@ -35,27 +35,13 @@ namespace {
 using namespace Common::Literals;
 
 u32 GetMemorySizeForInit() {
-    switch (Settings::values.memory_layout_mode.GetValue()) {
-    case Settings::MemoryLayout::Memory_4Gb:
-        return Smc::MemorySize_4GB;
-    case Settings::MemoryLayout::Memory_6Gb:
-        return Smc::MemorySize_6GB;
-    case Settings::MemoryLayout::Memory_8Gb:
-        return Smc::MemorySize_8GB;
-    }
-    return Smc::MemorySize_4GB;
+    return Settings::values.use_unsafe_extended_memory_layout ? Smc::MemorySize_8GB
+                                                              : Smc::MemorySize_4GB;
 }
 
 Smc::MemoryArrangement GetMemoryArrangeForInit() {
-    switch (Settings::values.memory_layout_mode.GetValue()) {
-    case Settings::MemoryLayout::Memory_4Gb:
-        return Smc::MemoryArrangement_4GB;
-    case Settings::MemoryLayout::Memory_6Gb:
-        return Smc::MemoryArrangement_6GB;
-    case Settings::MemoryLayout::Memory_8Gb:
-        return Smc::MemoryArrangement_8GB;
-    }
-    return Smc::MemoryArrangement_4GB;
+    return Settings::values.use_unsafe_extended_memory_layout ? Smc::MemoryArrangement_8GB
+                                                              : Smc::MemoryArrangement_4GB;
 }
 } // namespace
 

src/core/hle/kernel/k_process.cpp

@@ -81,8 +81,7 @@ Result KProcess::Initialize(KProcess* process, Core::System& system, std::string
     process->m_capabilities.InitializeForMetadatalessProcess();
     process->m_is_initialized = true;
 
-    std::mt19937 rng(Settings::values.rng_seed_enabled ? Settings::values.rng_seed.GetValue()
-                                                       : static_cast<u32>(std::time(nullptr)));
+    std::mt19937 rng(Settings::values.rng_seed.GetValue().value_or(std::time(nullptr)));
     std::uniform_int_distribution<u64> distribution;
     std::generate(process->m_random_entropy.begin(), process->m_random_entropy.end(),
                   [&] { return distribution(rng); });

src/core/hle/service/am/am.cpp

@@ -1317,50 +1317,6 @@ void ILibraryAppletCreator::CreateHandleStorage(HLERequestContext& ctx) {
     rb.PushIpcInterface<IStorage>(system, std::move(memory));
 }
 
-ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_)
-    : ServiceFramework{system_, "ILibraryAppletSelfAccessor"} {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "PopInData"},
-        {1, nullptr, "PushOutData"},
-        {2, nullptr, "PopInteractiveInData"},
-        {3, nullptr, "PushInteractiveOutData"},
-        {5, nullptr, "GetPopInDataEvent"},
-        {6, nullptr, "GetPopInteractiveInDataEvent"},
-        {10, nullptr, "ExitProcessAndReturn"},
-        {11, nullptr, "GetLibraryAppletInfo"},
-        {12, nullptr, "GetMainAppletIdentityInfo"},
-        {13, nullptr, "CanUseApplicationCore"},
-        {14, nullptr, "GetCallerAppletIdentityInfo"},
-        {15, nullptr, "GetMainAppletApplicationControlProperty"},
-        {16, nullptr, "GetMainAppletStorageId"},
-        {17, nullptr, "GetCallerAppletIdentityInfoStack"},
-        {18, nullptr, "GetNextReturnDestinationAppletIdentityInfo"},
-        {19, nullptr, "GetDesirableKeyboardLayout"},
-        {20, nullptr, "PopExtraStorage"},
-        {25, nullptr, "GetPopExtraStorageEvent"},
-        {30, nullptr, "UnpopInData"},
-        {31, nullptr, "UnpopExtraStorage"},
-        {40, nullptr, "GetIndirectLayerProducerHandle"},
-        {50, nullptr, "ReportVisibleError"},
-        {51, nullptr, "ReportVisibleErrorWithErrorContext"},
-        {60, nullptr, "GetMainAppletApplicationDesiredLanguage"},
-        {70, nullptr, "GetCurrentApplicationId"},
-        {80, nullptr, "RequestExitToSelf"},
-        {90, nullptr, "CreateApplicationAndPushAndRequestToLaunch"},
-        {100, nullptr, "CreateGameMovieTrimmer"},
-        {101, nullptr, "ReserveResourceForMovieOperation"},
-        {102, nullptr, "UnreserveResourceForMovieOperation"},
-        {110, nullptr, "GetMainAppletAvailableUsers"},
-        {120, nullptr, "GetLaunchStorageInfoForDebug"},
-        {130, nullptr, "GetGpuErrorDetectedSystemEvent"},
-        {140, nullptr, "SetApplicationMemoryReservation"},
-        {150, nullptr, "ShouldSetGpuTimeSliceManually"},
-    };
-    RegisterHandlers(functions);
-}
-
-ILibraryAppletSelfAccessor::~ILibraryAppletSelfAccessor() = default;
-
 IApplicationFunctions::IApplicationFunctions(Core::System& system_)
     : ServiceFramework{system_, "IApplicationFunctions"}, service_context{system,
                                                                           "IApplicationFunctions"} {

src/core/hle/service/am/am.h

@@ -22,6 +22,30 @@ class Nvnflinger;
 
 namespace Service::AM {
 
+// This is nn::settings::Language
+enum SystemLanguage {
+    Japanese = 0,
+    English = 1, // en-US
+    French = 2,
+    German = 3,
+    Italian = 4,
+    Spanish = 5,
+    Chinese = 6,
+    Korean = 7,
+    Dutch = 8,
+    Portuguese = 9,
+    Russian = 10,
+    Taiwanese = 11,
+    BritishEnglish = 12, // en-GB
+    CanadianFrench = 13,
+    LatinAmericanSpanish = 14, // es-419
+    // 4.0.0+
+    SimplifiedChinese = 15,
+    TraditionalChinese = 16,
+    // 10.1.0+
+    BrazilianPortuguese = 17,
+};
+
 class AppletMessageQueue {
 public:
     // This is nn::am::AppletMessage
@@ -290,12 +314,6 @@ private:
     void CreateHandleStorage(HLERequestContext& ctx);
 };
 
-class ILibraryAppletSelfAccessor final : public ServiceFramework<ILibraryAppletSelfAccessor> {
-public:
-    explicit ILibraryAppletSelfAccessor(Core::System& system_);
-    ~ILibraryAppletSelfAccessor() override;
-};
-
 class IApplicationFunctions final : public ServiceFramework<IApplicationFunctions> {
 public:
     explicit IApplicationFunctions(Core::System& system_);

src/core/hle/service/am/applet_ae.cpp

@@ -26,10 +26,8 @@ public:
             {4, &ILibraryAppletProxy::GetDisplayController, "GetDisplayController"},
             {10, &ILibraryAppletProxy::GetProcessWindingController, "GetProcessWindingController"},
             {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
-            {20, &ILibraryAppletProxy::OpenLibraryAppletSelfAccessor, "OpenLibraryAppletSelfAccessor"},
+            {20, &ILibraryAppletProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {21, nullptr, "GetAppletCommonFunctions"},
-            {22, nullptr, "GetHomeMenuFunctions"},
-            {23, nullptr, "GetGlobalStateController"},
             {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
         // clang-format on
@@ -102,12 +100,12 @@ private:
         rb.PushIpcInterface<ILibraryAppletCreator>(system);
     }
 
-    void OpenLibraryAppletSelfAccessor(HLERequestContext& ctx) {
+    void GetApplicationFunctions(HLERequestContext& ctx) {
         LOG_DEBUG(Service_AM, "called");
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ILibraryAppletSelfAccessor>(system);
+        rb.PushIpcInterface<IApplicationFunctions>(system);
     }
 
     Nvnflinger::Nvnflinger& nvnflinger;

src/core/hle/service/audio/audctl.cpp

@@ -22,13 +22,13 @@ AudCtl::AudCtl(Core::System& system_) : ServiceFramework{system_, "audctl"} {
         {9, nullptr, "GetAudioOutputMode"},
         {10, nullptr, "SetAudioOutputMode"},
         {11, nullptr, "SetForceMutePolicy"},
-        {12, &AudCtl::GetForceMutePolicy, "GetForceMutePolicy"},
-        {13, &AudCtl::GetOutputModeSetting, "GetOutputModeSetting"},
+        {12, nullptr, "GetForceMutePolicy"},
+        {13, nullptr, "GetOutputModeSetting"},
         {14, nullptr, "SetOutputModeSetting"},
         {15, nullptr, "SetOutputTarget"},
         {16, nullptr, "SetInputTargetForceEnabled"},
         {17, nullptr, "SetHeadphoneOutputLevelMode"},
-        {18, &AudCtl::GetHeadphoneOutputLevelMode, "GetHeadphoneOutputLevelMode"},
+        {18, nullptr, "GetHeadphoneOutputLevelMode"},
         {19, nullptr, "AcquireAudioVolumeUpdateEventForPlayReport"},
         {20, nullptr, "AcquireAudioOutputDeviceUpdateEventForPlayReport"},
         {21, nullptr, "GetAudioOutputTargetForPlayReport"},
@@ -41,7 +41,7 @@ AudCtl::AudCtl(Core::System& system_) : ServiceFramework{system_, "audctl"} {
         {28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
         {29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
         {30, nullptr, "SetSpeakerAutoMuteEnabled"},
-        {31, &AudCtl::IsSpeakerAutoMuteEnabled, "IsSpeakerAutoMuteEnabled"},
+        {31, nullptr, "IsSpeakerAutoMuteEnabled"},
         {32, nullptr, "GetActiveOutputTarget"},
         {33, nullptr, "GetTargetDeviceInfo"},
         {34, nullptr, "AcquireTargetNotification"},
@@ -96,42 +96,4 @@ void AudCtl::GetTargetVolumeMax(HLERequestContext& ctx) {
     rb.Push(target_max_volume);
 }
 
-void AudCtl::GetForceMutePolicy(HLERequestContext& ctx) {
-    LOG_WARNING(Audio, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(ForceMutePolicy::Disable);
-}
-
-void AudCtl::GetOutputModeSetting(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto value = rp.Pop<u32>();
-
-    LOG_WARNING(Audio, "(STUBBED) called, value={}", value);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(AudioOutputMode::PcmAuto);
-}
-
-void AudCtl::GetHeadphoneOutputLevelMode(HLERequestContext& ctx) {
-    LOG_WARNING(Audio, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(HeadphoneOutputLevelMode::Normal);
-}
-
-void AudCtl::IsSpeakerAutoMuteEnabled(HLERequestContext& ctx) {
-    const bool is_speaker_auto_mute_enabled = false;
-
-    LOG_WARNING(Audio, "(STUBBED) called, is_speaker_auto_mute_enabled={}",
-                is_speaker_auto_mute_enabled);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push<u8>(is_speaker_auto_mute_enabled);
-}
-
 } // namespace Service::Audio

src/core/hle/service/audio/audctl.h

@@ -17,30 +17,8 @@ public:
     ~AudCtl() override;
 
 private:
-    enum class AudioOutputMode {
-        Invalid,
-        Pcm1ch,
-        Pcm2ch,
-        Pcm6ch,
-        PcmAuto,
-    };
-
-    enum class ForceMutePolicy {
-        Disable,
-        SpeakerMuteOnHeadphoneUnplugged,
-    };
-
-    enum class HeadphoneOutputLevelMode {
-        Normal,
-        HighPower,
-    };
-
     void GetTargetVolumeMin(HLERequestContext& ctx);
     void GetTargetVolumeMax(HLERequestContext& ctx);
-    void GetForceMutePolicy(HLERequestContext& ctx);
-    void GetOutputModeSetting(HLERequestContext& ctx);
-    void GetHeadphoneOutputLevelMode(HLERequestContext& ctx);
-    void IsSpeakerAutoMuteEnabled(HLERequestContext& ctx);
 };
 
 } // namespace Service::Audio

src/core/hle/service/ns/ns.cpp

@@ -409,7 +409,7 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
 
     // Get language code from settings
     const auto language_code =
-        Set::GetLanguageCodeFromIndex(static_cast<s32>(Settings::values.language_index.GetValue()));
+        Set::GetLanguageCodeFromIndex(Settings::values.language_index.GetValue());
 
     // Convert to application language, get priority list
     const auto application_language = ConvertToApplicationLanguage(language_code);

src/core/hle/service/olsc/olsc.cpp

@@ -8,16 +8,15 @@
 
 namespace Service::OLSC {
 
-class IOlscServiceForApplication final : public ServiceFramework<IOlscServiceForApplication> {
+class OLSC final : public ServiceFramework<OLSC> {
 public:
-    explicit IOlscServiceForApplication(Core::System& system_)
-        : ServiceFramework{system_, "olsc:u"} {
+    explicit OLSC(Core::System& system_) : ServiceFramework{system_, "olsc:u"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &IOlscServiceForApplication::Initialize, "Initialize"},
+            {0, &OLSC::Initialize, "Initialize"},
             {10, nullptr, "VerifySaveDataBackupLicenseAsync"},
-            {13, &IOlscServiceForApplication::GetSaveDataBackupSetting, "GetSaveDataBackupSetting"},
-            {14, &IOlscServiceForApplication::SetSaveDataBackupSettingEnabled, "SetSaveDataBackupSettingEnabled"},
+            {13, &OLSC::GetSaveDataBackupSetting, "GetSaveDataBackupSetting"},
+            {14, &OLSC::SetSaveDataBackupSettingEnabled, "SetSaveDataBackupSettingEnabled"},
             {15, nullptr, "SetCustomData"},
             {16, nullptr, "DeleteSaveDataBackupSetting"},
             {18, nullptr, "GetSaveDataBackupInfoCache"},
@@ -73,155 +72,10 @@ private:
     bool initialized{};
 };
 
-class INativeHandleHolder final : public ServiceFramework<INativeHandleHolder> {
-public:
-    explicit INativeHandleHolder(Core::System& system_)
-        : ServiceFramework{system_, "INativeHandleHolder"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetNativeHandle"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class ITransferTaskListController final : public ServiceFramework<ITransferTaskListController> {
-public:
-    explicit ITransferTaskListController(Core::System& system_)
-        : ServiceFramework{system_, "ITransferTaskListController"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown0"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, &ITransferTaskListController::GetNativeHandleHolder , "GetNativeHandleHolder"},
-            {6, nullptr, "Unknown6"},
-            {7, nullptr, "Unknown7"},
-            {8, nullptr, "GetRemoteStorageController"},
-            {9, &ITransferTaskListController::GetNativeHandleHolder, "GetNativeHandleHolder2"},
-            {10, nullptr, "Unknown10"},
-            {11, nullptr, "Unknown11"},
-            {12, nullptr, "Unknown12"},
-            {13, nullptr, "Unknown13"},
-            {14, nullptr, "Unknown14"},
-            {15, nullptr, "Unknown15"},
-            {16, nullptr, "Unknown16"},
-            {17, nullptr, "Unknown17"},
-            {18, nullptr, "Unknown18"},
-            {19, nullptr, "Unknown19"},
-            {20, nullptr, "Unknown20"},
-            {21, nullptr, "Unknown21"},
-            {22, nullptr, "Unknown22"},
-            {23, nullptr, "Unknown23"},
-            {24, nullptr, "Unknown24"},
-            {25, nullptr, "Unknown25"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetNativeHandleHolder(HLERequestContext& ctx) {
-        LOG_INFO(Service_OLSC, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<INativeHandleHolder>(system);
-    }
-};
-
-class IOlscServiceForSystemService final : public ServiceFramework<IOlscServiceForSystemService> {
-public:
-    explicit IOlscServiceForSystemService(Core::System& system_)
-        : ServiceFramework{system_, "olsc:s"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IOlscServiceForSystemService::OpenTransferTaskListController, "OpenTransferTaskListController"},
-            {1, nullptr, "OpenRemoteStorageController"},
-            {2, nullptr, "OpenDaemonController"},
-            {10, nullptr, "Unknown10"},
-            {11, nullptr, "Unknown11"},
-            {12, nullptr, "Unknown12"},
-            {13, nullptr, "Unknown13"},
-            {100, nullptr, "ListLastTransferTaskErrorInfo"},
-            {101, nullptr, "GetLastErrorInfoCount"},
-            {102, nullptr, "RemoveLastErrorInfoOld"},
-            {103, nullptr, "GetLastErrorInfo"},
-            {104, nullptr, "GetLastErrorEventHolder"},
-            {105, nullptr, "GetLastTransferTaskErrorInfo"},
-            {200, nullptr, "GetDataTransferPolicyInfo"},
-            {201, nullptr, "RemoveDataTransferPolicyInfo"},
-            {202, nullptr, "UpdateDataTransferPolicyOld"},
-            {203, nullptr, "UpdateDataTransferPolicy"},
-            {204, nullptr, "CleanupDataTransferPolicyInfo"},
-            {205, nullptr, "RequestDataTransferPolicy"},
-            {300, nullptr, "GetAutoTransferSeriesInfo"},
-            {301, nullptr, "UpdateAutoTransferSeriesInfo"},
-            {400, nullptr, "CleanupSaveDataArchiveInfoType1"},
-            {900, nullptr, "CleanupTransferTask"},
-            {902, nullptr, "CleanupSeriesInfoType0"},
-            {903, nullptr, "CleanupSaveDataArchiveInfoType0"},
-            {904, nullptr, "CleanupApplicationAutoTransferSetting"},
-            {905, nullptr, "CleanupErrorHistory"},
-            {906, nullptr, "SetLastError"},
-            {907, nullptr, "AddSaveDataArchiveInfoType0"},
-            {908, nullptr, "RemoveSeriesInfoType0"},
-            {909, nullptr, "GetSeriesInfoType0"},
-            {910, nullptr, "RemoveLastErrorInfo"},
-            {911, nullptr, "CleanupSeriesInfoType1"},
-            {912, nullptr, "RemoveSeriesInfoType1"},
-            {913, nullptr, "GetSeriesInfoType1"},
-            {1000, nullptr, "UpdateIssueOld"},
-            {1010, nullptr, "Unknown1010"},
-            {1011, nullptr, "ListIssueInfoOld"},
-            {1012, nullptr, "GetIssueOld"},
-            {1013, nullptr, "GetIssue2Old"},
-            {1014, nullptr, "GetIssue3Old"},
-            {1020, nullptr, "RepairIssueOld"},
-            {1021, nullptr, "RepairIssueWithUserIdOld"},
-            {1022, nullptr, "RepairIssue2Old"},
-            {1023, nullptr, "RepairIssue3Old"},
-            {1024, nullptr, "Unknown1024"},
-            {1100, nullptr, "UpdateIssue"},
-            {1110, nullptr, "Unknown1110"},
-            {1111, nullptr, "ListIssueInfo"},
-            {1112, nullptr, "GetIssue"},
-            {1113, nullptr, "GetIssue2"},
-            {1114, nullptr, "GetIssue3"},
-            {1120, nullptr, "RepairIssue"},
-            {1121, nullptr, "RepairIssueWithUserId"},
-            {1122, nullptr, "RepairIssue2"},
-            {1123, nullptr, "RepairIssue3"},
-            {1124, nullptr, "Unknown1124"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void OpenTransferTaskListController(HLERequestContext& ctx) {
-        LOG_INFO(Service_OLSC, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ITransferTaskListController>(system);
-    }
-};
-
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
-    server_manager->RegisterNamedService("olsc:u",
-                                         std::make_shared<IOlscServiceForApplication>(system));
-    server_manager->RegisterNamedService("olsc:s",
-                                         std::make_shared<IOlscServiceForSystemService>(system));
-
+    server_manager->RegisterNamedService("olsc:u", std::make_shared<OLSC>(system));
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/pctl/pctl_module.cpp

@@ -6,7 +6,6 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/pctl/pctl.h"
 #include "core/hle/service/pctl/pctl_module.h"
 #include "core/hle/service/server_manager.h"
@@ -25,8 +24,7 @@ constexpr Result ResultNoRestrictionEnabled{ErrorModule::PCTL, 181};
 class IParentalControlService final : public ServiceFramework<IParentalControlService> {
 public:
     explicit IParentalControlService(Core::System& system_, Capability capability_)
-        : ServiceFramework{system_, "IParentalControlService"}, capability{capability_},
-          service_context{system_, "IParentalControlService"} {
+        : ServiceFramework{system_, "IParentalControlService"}, capability{capability_} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {1, &IParentalControlService::Initialize, "Initialize"},
@@ -35,7 +33,7 @@ public:
             {1003, nullptr, "ConfirmResumeApplicationPermission"},
             {1004, nullptr, "ConfirmSnsPostPermission"},
             {1005, nullptr, "ConfirmSystemSettingsPermission"},
-            {1006, &IParentalControlService::IsRestrictionTemporaryUnlocked, "IsRestrictionTemporaryUnlocked"},
+            {1006, nullptr, "IsRestrictionTemporaryUnlocked"},
             {1007, nullptr, "RevertRestrictionTemporaryUnlocked"},
             {1008, nullptr, "EnterRestrictedSystemSettings"},
             {1009, nullptr, "LeaveRestrictedSystemSettings"},
@@ -49,14 +47,14 @@ public:
             {1017, &IParentalControlService::EndFreeCommunication, "EndFreeCommunication"},
             {1018, &IParentalControlService::IsFreeCommunicationAvailable, "IsFreeCommunicationAvailable"},
             {1031, &IParentalControlService::IsRestrictionEnabled, "IsRestrictionEnabled"},
-            {1032, &IParentalControlService::GetSafetyLevel, "GetSafetyLevel"},
+            {1032, nullptr, "GetSafetyLevel"},
             {1033, nullptr, "SetSafetyLevel"},
             {1034, nullptr, "GetSafetyLevelSettings"},
-            {1035, &IParentalControlService::GetCurrentSettings, "GetCurrentSettings"},
+            {1035, nullptr, "GetCurrentSettings"},
             {1036, nullptr, "SetCustomSafetyLevelSettings"},
             {1037, nullptr, "GetDefaultRatingOrganization"},
             {1038, nullptr, "SetDefaultRatingOrganization"},
-            {1039, &IParentalControlService::GetFreeCommunicationApplicationListCount, "GetFreeCommunicationApplicationListCount"},
+            {1039, nullptr, "GetFreeCommunicationApplicationListCount"},
             {1042, nullptr, "AddToFreeCommunicationApplicationList"},
             {1043, nullptr, "DeleteSettings"},
             {1044, nullptr, "GetFreeCommunicationApplicationList"},
@@ -78,7 +76,7 @@ public:
             {1206, nullptr, "GetPinCodeLength"},
             {1207, nullptr, "GetPinCodeChangedEvent"},
             {1208, nullptr, "GetPinCode"},
-            {1403, &IParentalControlService::IsPairingActive, "IsPairingActive"},
+            {1403, nullptr, "IsPairingActive"},
             {1406, nullptr, "GetSettingsLastUpdated"},
             {1411, nullptr, "GetPairingAccountInfo"},
             {1421, nullptr, "GetAccountNickname"},
@@ -86,18 +84,18 @@ public:
             {1425, nullptr, "RequestPostEvents"},
             {1426, nullptr, "GetPostEventInterval"},
             {1427, nullptr, "SetPostEventInterval"},
-            {1432, &IParentalControlService::GetSynchronizationEvent, "GetSynchronizationEvent"},
+            {1432, nullptr, "GetSynchronizationEvent"},
             {1451, nullptr, "StartPlayTimer"},
             {1452, nullptr, "StopPlayTimer"},
             {1453, nullptr, "IsPlayTimerEnabled"},
             {1454, nullptr, "GetPlayTimerRemainingTime"},
             {1455, nullptr, "IsRestrictedByPlayTimer"},
-            {1456, &IParentalControlService::GetPlayTimerSettings, "GetPlayTimerSettings"},
-            {1457, &IParentalControlService::GetPlayTimerEventToRequestSuspension, "GetPlayTimerEventToRequestSuspension"},
-            {1458, &IParentalControlService::IsPlayTimerAlarmDisabled, "IsPlayTimerAlarmDisabled"},
+            {1456, nullptr, "GetPlayTimerSettings"},
+            {1457, nullptr, "GetPlayTimerEventToRequestSuspension"},
+            {1458, nullptr, "IsPlayTimerAlarmDisabled"},
             {1471, nullptr, "NotifyWrongPinCodeInputManyTimes"},
             {1472, nullptr, "CancelNetworkRequest"},
-            {1473, &IParentalControlService::GetUnlinkedEvent, "GetUnlinkedEvent"},
+            {1473, nullptr, "GetUnlinkedEvent"},
             {1474, nullptr, "ClearUnlinkedEvent"},
             {1601, nullptr, "DisableAllFeatures"},
             {1602, nullptr, "PostEnableAllFeatures"},
@@ -133,12 +131,6 @@ public:
         };
         // clang-format on
         RegisterHandlers(functions);
-
-        synchronization_event =
-            service_context.CreateEvent("IParentalControlService::SynchronizationEvent");
-        unlinked_event = service_context.CreateEvent("IParentalControlService::UnlinkedEvent");
-        request_suspension_event =
-            service_context.CreateEvent("IParentalControlService::RequestSuspensionEvent");
     }
 
 private:
@@ -152,7 +144,7 @@ private:
         if (pin_code[0] == '\0') {
             return true;
         }
-        if (!restriction_settings.is_free_communication_default_on) {
+        if (!settings.is_free_communication_default_on) {
             return true;
         }
         // TODO(ogniK): Check for blacklisted/exempted applications. Return false can happen here
@@ -168,21 +160,21 @@ private:
         if (pin_code[0] == '\0') {
             return true;
         }
-        if (!restriction_settings.is_stero_vision_restricted) {
+        if (!settings.is_stero_vision_restricted) {
             return false;
         }
         return true;
     }
 
     void SetStereoVisionRestrictionImpl(bool is_restricted) {
-        if (restriction_settings.disabled) {
+        if (settings.disabled) {
             return;
         }
 
         if (pin_code[0] == '\0') {
             return;
         }
-        restriction_settings.is_stero_vision_restricted = is_restricted;
+        settings.is_stero_vision_restricted = is_restricted;
     }
 
     void Initialize(HLERequestContext& ctx) {
@@ -236,17 +228,6 @@ private:
         states.free_communication = true;
     }
 
-    void IsRestrictionTemporaryUnlocked(HLERequestContext& ctx) {
-        const bool is_temporary_unlocked = false;
-
-        LOG_WARNING(Service_PCTL, "(STUBBED) called, is_temporary_unlocked={}",
-                    is_temporary_unlocked);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push<u8>(is_temporary_unlocked);
-    }
-
     void ConfirmStereoVisionPermission(HLERequestContext& ctx) {
         LOG_DEBUG(Service_PCTL, "called");
         states.stereo_vision = true;
@@ -287,34 +268,6 @@ private:
         rb.Push(pin_code[0] != '\0');
     }
 
-    void GetSafetyLevel(HLERequestContext& ctx) {
-        const u32 safety_level = 0;
-
-        LOG_WARNING(Service_PCTL, "(STUBBED) called, safety_level={}", safety_level);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(safety_level);
-    }
-
-    void GetCurrentSettings(HLERequestContext& ctx) {
-        LOG_INFO(Service_PCTL, "called");
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(restriction_settings);
-    }
-
-    void GetFreeCommunicationApplicationListCount(HLERequestContext& ctx) {
-        const u32 count = 4;
-
-        LOG_WARNING(Service_PCTL, "(STUBBED) called, count={}", count);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(count);
-    }
-
     void ConfirmStereoVisionRestrictionConfigurable(HLERequestContext& ctx) {
         LOG_DEBUG(Service_PCTL, "called");
 
@@ -347,61 +300,6 @@ private:
         }
     }
 
-    void IsPairingActive(HLERequestContext& ctx) {
-        const bool is_pairing_active = false;
-
-        LOG_WARNING(Service_PCTL, "(STUBBED) called, is_pairing_active={}", is_pairing_active);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push<u8>(is_pairing_active);
-    }
-
-    void GetSynchronizationEvent(HLERequestContext& ctx) {
-        LOG_INFO(Service_PCTL, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(synchronization_event->GetReadableEvent());
-    }
-
-    void GetPlayTimerSettings(HLERequestContext& ctx) {
-        LOG_WARNING(Service_PCTL, "(STUBBED) called");
-
-        const PlayTimerSettings timer_settings{};
-
-        IPC::ResponseBuilder rb{ctx, 15};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(timer_settings);
-    }
-
-    void GetPlayTimerEventToRequestSuspension(HLERequestContext& ctx) {
-        LOG_INFO(Service_PCTL, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(request_suspension_event->GetReadableEvent());
-    }
-
-    void IsPlayTimerAlarmDisabled(HLERequestContext& ctx) {
-        const bool is_play_timer_alarm_disabled = false;
-
-        LOG_INFO(Service_PCTL, "called, is_play_timer_alarm_disabled={}",
-                 is_play_timer_alarm_disabled);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push<u8>(is_play_timer_alarm_disabled);
-    }
-
-    void GetUnlinkedEvent(HLERequestContext& ctx) {
-        LOG_INFO(Service_PCTL, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(unlinked_event->GetReadableEvent());
-    }
-
     void SetStereoVisionRestriction(HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto can_use = rp.Pop<bool>();
@@ -430,7 +328,7 @@ private:
         }
 
         rb.Push(ResultSuccess);
-        rb.Push(restriction_settings.is_stero_vision_restricted);
+        rb.Push(settings.is_stero_vision_restricted);
     }
 
     void ResetConfirmedStereoVisionPermission(HLERequestContext& ctx) {
@@ -460,30 +358,16 @@ private:
         bool stereo_vision{};
     };
 
-    // This is nn::pctl::RestrictionSettings
-    struct RestrictionSettings {
+    struct ParentalControlSettings {
         bool is_stero_vision_restricted{};
         bool is_free_communication_default_on{};
         bool disabled{};
     };
-    static_assert(sizeof(RestrictionSettings) == 0x3, "RestrictionSettings has incorrect size.");
-
-    // This is nn::pctl::PlayTimerSettings
-    struct PlayTimerSettings {
-        // TODO: RE the actual contents of this struct
-        std::array<u8, 0x34> settings;
-    };
-    static_assert(sizeof(PlayTimerSettings) == 0x34, "PlayTimerSettings has incorrect size.");
 
     States states{};
-    RestrictionSettings restriction_settings{};
+    ParentalControlSettings settings{};
     std::array<char, 8> pin_code{};
     Capability capability{};
-
-    Kernel::KEvent* synchronization_event;
-    Kernel::KEvent* unlinked_event;
-    Kernel::KEvent* request_suspension_event;
-    KernelHelpers::ServiceContext service_context;
 };
 
 void Module::Interface::CreateService(HLERequestContext& ctx) {

src/core/hle/service/set/set.cpp

@@ -11,6 +11,66 @@
 
 namespace Service::Set {
 namespace {
+constexpr std::array<LanguageCode, 18> available_language_codes = {{
+    LanguageCode::JA,
+    LanguageCode::EN_US,
+    LanguageCode::FR,
+    LanguageCode::DE,
+    LanguageCode::IT,
+    LanguageCode::ES,
+    LanguageCode::ZH_CN,
+    LanguageCode::KO,
+    LanguageCode::NL,
+    LanguageCode::PT,
+    LanguageCode::RU,
+    LanguageCode::ZH_TW,
+    LanguageCode::EN_GB,
+    LanguageCode::FR_CA,
+    LanguageCode::ES_419,
+    LanguageCode::ZH_HANS,
+    LanguageCode::ZH_HANT,
+    LanguageCode::PT_BR,
+}};
+
+enum class KeyboardLayout : u64 {
+    Japanese = 0,
+    EnglishUs = 1,
+    EnglishUsInternational = 2,
+    EnglishUk = 3,
+    French = 4,
+    FrenchCa = 5,
+    Spanish = 6,
+    SpanishLatin = 7,
+    German = 8,
+    Italian = 9,
+    Portuguese = 10,
+    Russian = 11,
+    Korean = 12,
+    ChineseSimplified = 13,
+    ChineseTraditional = 14,
+};
+
+constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_layout{{
+    {LanguageCode::JA, KeyboardLayout::Japanese},
+    {LanguageCode::EN_US, KeyboardLayout::EnglishUs},
+    {LanguageCode::FR, KeyboardLayout::French},
+    {LanguageCode::DE, KeyboardLayout::German},
+    {LanguageCode::IT, KeyboardLayout::Italian},
+    {LanguageCode::ES, KeyboardLayout::Spanish},
+    {LanguageCode::ZH_CN, KeyboardLayout::ChineseSimplified},
+    {LanguageCode::KO, KeyboardLayout::Korean},
+    {LanguageCode::NL, KeyboardLayout::EnglishUsInternational},
+    {LanguageCode::PT, KeyboardLayout::Portuguese},
+    {LanguageCode::RU, KeyboardLayout::Russian},
+    {LanguageCode::ZH_TW, KeyboardLayout::ChineseTraditional},
+    {LanguageCode::EN_GB, KeyboardLayout::EnglishUk},
+    {LanguageCode::FR_CA, KeyboardLayout::FrenchCa},
+    {LanguageCode::ES_419, KeyboardLayout::SpanishLatin},
+    {LanguageCode::ZH_HANS, KeyboardLayout::ChineseSimplified},
+    {LanguageCode::ZH_HANT, KeyboardLayout::ChineseTraditional},
+    {LanguageCode::PT_BR, KeyboardLayout::Portuguese},
+}};
+
 constexpr std::size_t PRE_4_0_0_MAX_ENTRIES = 0xF;
 constexpr std::size_t POST_4_0_0_MAX_ENTRIES = 0x40;
 
@@ -33,8 +93,7 @@ void GetAvailableLanguageCodesImpl(HLERequestContext& ctx, std::size_t max_entri
 }
 
 void GetKeyCodeMapImpl(HLERequestContext& ctx) {
-    const auto language_code =
-        available_language_codes[static_cast<s32>(Settings::values.language_index.GetValue())];
+    const auto language_code = available_language_codes[Settings::values.language_index.GetValue()];
     const auto key_code =
         std::find_if(language_to_layout.cbegin(), language_to_layout.cend(),
                      [=](const auto& element) { return element.first == language_code; });
@@ -103,7 +162,7 @@ void SET::GetQuestFlag(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
-    rb.Push(static_cast<s32>(Settings::values.quest_flag.GetValue()));
+    rb.Push(static_cast<u32>(Settings::values.quest_flag.GetValue()));
 }
 
 void SET::GetLanguageCode(HLERequestContext& ctx) {
@@ -111,8 +170,7 @@ void SET::GetLanguageCode(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
-    rb.PushEnum(
-        available_language_codes[static_cast<s32>(Settings::values.language_index.GetValue())]);
+    rb.PushEnum(available_language_codes[Settings::values.language_index.GetValue()]);
 }
 
 void SET::GetRegionCode(HLERequestContext& ctx) {
@@ -120,7 +178,7 @@ void SET::GetRegionCode(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(Settings::values.region_index.GetValue()));
+    rb.Push(Settings::values.region_index.GetValue());
 }
 
 void SET::GetKeyCodeMap(HLERequestContext& ctx) {

src/core/hle/service/set/set.h

@@ -32,67 +32,6 @@ enum class LanguageCode : u64 {
     ZH_HANT = 0x00746E61482D687A,
     PT_BR = 0x00000052422D7470,
 };
-
-enum class KeyboardLayout : u64 {
-    Japanese = 0,
-    EnglishUs = 1,
-    EnglishUsInternational = 2,
-    EnglishUk = 3,
-    French = 4,
-    FrenchCa = 5,
-    Spanish = 6,
-    SpanishLatin = 7,
-    German = 8,
-    Italian = 9,
-    Portuguese = 10,
-    Russian = 11,
-    Korean = 12,
-    ChineseSimplified = 13,
-    ChineseTraditional = 14,
-};
-
-constexpr std::array<LanguageCode, 18> available_language_codes = {{
-    LanguageCode::JA,
-    LanguageCode::EN_US,
-    LanguageCode::FR,
-    LanguageCode::DE,
-    LanguageCode::IT,
-    LanguageCode::ES,
-    LanguageCode::ZH_CN,
-    LanguageCode::KO,
-    LanguageCode::NL,
-    LanguageCode::PT,
-    LanguageCode::RU,
-    LanguageCode::ZH_TW,
-    LanguageCode::EN_GB,
-    LanguageCode::FR_CA,
-    LanguageCode::ES_419,
-    LanguageCode::ZH_HANS,
-    LanguageCode::ZH_HANT,
-    LanguageCode::PT_BR,
-}};
-
-static constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_layout{{
-    {LanguageCode::JA, KeyboardLayout::Japanese},
-    {LanguageCode::EN_US, KeyboardLayout::EnglishUs},
-    {LanguageCode::FR, KeyboardLayout::French},
-    {LanguageCode::DE, KeyboardLayout::German},
-    {LanguageCode::IT, KeyboardLayout::Italian},
-    {LanguageCode::ES, KeyboardLayout::Spanish},
-    {LanguageCode::ZH_CN, KeyboardLayout::ChineseSimplified},
-    {LanguageCode::KO, KeyboardLayout::Korean},
-    {LanguageCode::NL, KeyboardLayout::EnglishUsInternational},
-    {LanguageCode::PT, KeyboardLayout::Portuguese},
-    {LanguageCode::RU, KeyboardLayout::Russian},
-    {LanguageCode::ZH_TW, KeyboardLayout::ChineseTraditional},
-    {LanguageCode::EN_GB, KeyboardLayout::EnglishUk},
-    {LanguageCode::FR_CA, KeyboardLayout::FrenchCa},
-    {LanguageCode::ES_419, KeyboardLayout::SpanishLatin},
-    {LanguageCode::ZH_HANS, KeyboardLayout::ChineseSimplified},
-    {LanguageCode::ZH_HANT, KeyboardLayout::ChineseTraditional},
-    {LanguageCode::PT_BR, KeyboardLayout::Portuguese},
-}};
-
 LanguageCode GetLanguageCodeFromIndex(std::size_t idx);
 
 class SET final : public ServiceFramework<SET> {

src/core/hle/service/set/set_sys.cpp

@@ -4,12 +4,10 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
-#include "common/string_util.h"
 #include "core/file_sys/errors.h"
 #include "core/file_sys/system_archive/system_version.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/set/set.h"
 #include "core/hle/service/set/set_sys.h"
 
 namespace Service::Set {
@@ -75,16 +73,6 @@ void GetFirmwareVersionImpl(HLERequestContext& ctx, GetFirmwareVersionType type)
 }
 } // Anonymous namespace
 
-void SET_SYS::SetLanguageCode(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    language_code_setting = rp.PopEnum<LanguageCode>();
-
-    LOG_INFO(Service_SET, "called, language_code={}", language_code_setting);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 void SET_SYS::GetFirmwareVersion(HLERequestContext& ctx) {
     LOG_DEBUG(Service_SET, "called");
     GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version1);
@@ -95,113 +83,21 @@ void SET_SYS::GetFirmwareVersion2(HLERequestContext& ctx) {
     GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version2);
 }
 
-void SET_SYS::GetAccountSettings(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(account_settings);
-}
-
-void SET_SYS::SetAccountSettings(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    account_settings = rp.PopRaw<AccountSettings>();
-
-    LOG_INFO(Service_SET, "called, account_settings_flags={}", account_settings.flags);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetEulaVersions(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called");
-
-    ctx.WriteBuffer(eula_versions);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(eula_versions.size()));
-}
-
-void SET_SYS::SetEulaVersions(HLERequestContext& ctx) {
-    const auto elements = ctx.GetReadBufferNumElements<EulaVersion>();
-    const auto buffer_data = ctx.ReadBuffer();
-
-    LOG_INFO(Service_SET, "called, elements={}", elements);
-
-    eula_versions.resize(elements);
-    for (std::size_t index = 0; index < elements; index++) {
-        const std::size_t start_index = index * sizeof(EulaVersion);
-        memcpy(eula_versions.data() + start_index, buffer_data.data() + start_index,
-               sizeof(EulaVersion));
-    }
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 void SET_SYS::GetColorSetId(HLERequestContext& ctx) {
     LOG_DEBUG(Service_SET, "called");
 
     IPC::ResponseBuilder rb{ctx, 3};
+
     rb.Push(ResultSuccess);
     rb.PushEnum(color_set);
 }
 
 void SET_SYS::SetColorSetId(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
     IPC::RequestParser rp{ctx};
     color_set = rp.PopEnum<ColorSet>();
 
-    LOG_DEBUG(Service_SET, "called, color_set={}", color_set);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetNotificationSettings(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called");
-
-    IPC::ResponseBuilder rb{ctx, 8};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(notification_settings);
-}
-
-void SET_SYS::SetNotificationSettings(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    notification_settings = rp.PopRaw<NotificationSettings>();
-
-    LOG_INFO(Service_SET, "called, flags={}, volume={}, head_time={}:{}, tailt_time={}:{}",
-             notification_settings.flags.raw, notification_settings.volume,
-             notification_settings.start_time.hour, notification_settings.start_time.minute,
-             notification_settings.stop_time.hour, notification_settings.stop_time.minute);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetAccountNotificationSettings(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called");
-
-    ctx.WriteBuffer(account_notifications);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(account_notifications.size()));
-}
-
-void SET_SYS::SetAccountNotificationSettings(HLERequestContext& ctx) {
-    const auto elements = ctx.GetReadBufferNumElements<AccountNotificationSettings>();
-    const auto buffer_data = ctx.ReadBuffer();
-
-    LOG_INFO(Service_SET, "called, elements={}", elements);
-
-    account_notifications.resize(elements);
-    for (std::size_t index = 0; index < elements; index++) {
-        const std::size_t start_index = index * sizeof(AccountNotificationSettings);
-        memcpy(account_notifications.data() + start_index, buffer_data.data() + start_index,
-               sizeof(AccountNotificationSettings));
-    }
-
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
 }
@@ -281,218 +177,17 @@ void SET_SYS::GetSettingsItemValue(HLERequestContext& ctx) {
     rb.Push(response);
 }
 
-void SET_SYS::GetTvSettings(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called");
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(tv_settings);
-}
-
-void SET_SYS::SetTvSettings(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    tv_settings = rp.PopRaw<TvSettings>();
-
-    LOG_INFO(Service_SET,
-             "called, flags={}, cmu_mode={}, constrast_ratio={}, hdmi_content_type={}, "
-             "rgb_range={}, tv_gama={}, tv_resolution={}, tv_underscan={}",
-             tv_settings.flags.raw, tv_settings.cmu_mode, tv_settings.constrast_ratio,
-             tv_settings.hdmi_content_type, tv_settings.rgb_range, tv_settings.tv_gama,
-             tv_settings.tv_resolution, tv_settings.tv_underscan);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetQuestFlag(HLERequestContext& ctx) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(QuestFlag::Retail);
-}
-
-void SET_SYS::SetRegionCode(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    region_code = rp.PopEnum<RegionCode>();
-
-    LOG_INFO(Service_SET, "called, region_code={}", region_code);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetPrimaryAlbumStorage(HLERequestContext& ctx) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(PrimaryAlbumStorage::SdCard);
-}
-
-void SET_SYS::GetSleepSettings(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called");
-
-    IPC::ResponseBuilder rb{ctx, 5};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(sleep_settings);
-}
-
-void SET_SYS::SetSleepSettings(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    sleep_settings = rp.PopRaw<SleepSettings>();
-
-    LOG_INFO(Service_SET, "called, flags={}, handheld_sleep_plan={}, console_sleep_plan={}",
-             sleep_settings.flags.raw, sleep_settings.handheld_sleep_plan,
-             sleep_settings.console_sleep_plan);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetInitialLaunchSettings(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called");
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(launch_settings);
-}
-
-void SET_SYS::SetInitialLaunchSettings(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    launch_settings = rp.PopRaw<InitialLaunchSettings>();
-
-    LOG_INFO(Service_SET, "called, flags={}, timestamp={}", launch_settings.flags.raw,
-             launch_settings.timestamp.time_point);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 void SET_SYS::GetDeviceNickName(HLERequestContext& ctx) {
     LOG_DEBUG(Service_SET, "called");
-
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
     ctx.WriteBuffer(::Settings::values.device_name.GetValue());
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::SetDeviceNickName(HLERequestContext& ctx) {
-    const std::string device_name = Common::StringFromBuffer(ctx.ReadBuffer());
-
-    LOG_INFO(Service_SET, "called, device_name={}", device_name);
-
-    ::Settings::values.device_name = device_name;
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetProductModel(HLERequestContext& ctx) {
-    const u32 product_model = 1;
-
-    LOG_WARNING(Service_SET, "(STUBBED) called, product_model={}", product_model);
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(product_model);
-}
-
-void SET_SYS::GetMiiAuthorId(HLERequestContext& ctx) {
-    const auto author_id = Common::UUID::MakeDefault();
-
-    LOG_WARNING(Service_SET, "(STUBBED) called, author_id={}", author_id.FormattedString());
-
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(author_id);
-}
-
-void SET_SYS::GetAutoUpdateEnableFlag(HLERequestContext& ctx) {
-    u8 auto_update_flag{};
-
-    LOG_WARNING(Service_SET, "(STUBBED) called, auto_update_flag={}", auto_update_flag);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(auto_update_flag);
-}
-
-void SET_SYS::GetBatteryPercentageFlag(HLERequestContext& ctx) {
-    u8 battery_percentage_flag{1};
-
-    LOG_WARNING(Service_SET, "(STUBBED) called, battery_percentage_flag={}",
-                battery_percentage_flag);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(battery_percentage_flag);
-}
-
-void SET_SYS::GetErrorReportSharePermission(HLERequestContext& ctx) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(ErrorReportSharePermission::Denied);
-}
-
-void SET_SYS::GetAppletLaunchFlags(HLERequestContext& ctx) {
-    LOG_INFO(Service_SET, "called, applet_launch_flag={}", applet_launch_flag);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(applet_launch_flag);
-}
-
-void SET_SYS::SetAppletLaunchFlags(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    applet_launch_flag = rp.Pop<u32>();
-
-    LOG_INFO(Service_SET, "called, applet_launch_flag={}", applet_launch_flag);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void SET_SYS::GetKeyboardLayout(HLERequestContext& ctx) {
-    const auto language_code =
-        available_language_codes[static_cast<s32>(::Settings::values.language_index.GetValue())];
-    const auto key_code =
-        std::find_if(language_to_layout.cbegin(), language_to_layout.cend(),
-                     [=](const auto& element) { return element.first == language_code; });
-
-    KeyboardLayout selected_keyboard_layout = KeyboardLayout::EnglishUs;
-    if (key_code != language_to_layout.end()) {
-        selected_keyboard_layout = key_code->second;
-    }
-
-    LOG_INFO(Service_SET, "called, selected_keyboard_layout={}", selected_keyboard_layout);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(selected_keyboard_layout));
-}
-
-void SET_SYS::GetChineseTraditionalInputMethod(HLERequestContext& ctx) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(ChineseTraditionalInputMethod::Unknown0);
-}
-
-void SET_SYS::GetFieldTestingFlag(HLERequestContext& ctx) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push<u8>(false);
 }
 
 SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, &SET_SYS::SetLanguageCode, "SetLanguageCode"},
+        {0, nullptr, "SetLanguageCode"},
         {1, nullptr, "SetNetworkSettings"},
         {2, nullptr, "GetNetworkSettings"},
         {3, &SET_SYS::GetFirmwareVersion, "GetFirmwareVersion"},
@@ -508,35 +203,35 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {14, nullptr, "SetExternalSteadyClockSourceId"},
         {15, nullptr, "GetUserSystemClockContext"},
         {16, nullptr, "SetUserSystemClockContext"},
-        {17, &SET_SYS::GetAccountSettings, "GetAccountSettings"},
-        {18, &SET_SYS::SetAccountSettings, "SetAccountSettings"},
+        {17, nullptr, "GetAccountSettings"},
+        {18, nullptr, "SetAccountSettings"},
         {19, nullptr, "GetAudioVolume"},
         {20, nullptr, "SetAudioVolume"},
-        {21, &SET_SYS::GetEulaVersions, "GetEulaVersions"},
-        {22, &SET_SYS::SetEulaVersions, "SetEulaVersions"},
+        {21, nullptr, "GetEulaVersions"},
+        {22, nullptr, "SetEulaVersions"},
         {23, &SET_SYS::GetColorSetId, "GetColorSetId"},
         {24, &SET_SYS::SetColorSetId, "SetColorSetId"},
         {25, nullptr, "GetConsoleInformationUploadFlag"},
         {26, nullptr, "SetConsoleInformationUploadFlag"},
         {27, nullptr, "GetAutomaticApplicationDownloadFlag"},
         {28, nullptr, "SetAutomaticApplicationDownloadFlag"},
-        {29, &SET_SYS::GetNotificationSettings, "GetNotificationSettings"},
-        {30, &SET_SYS::SetNotificationSettings, "SetNotificationSettings"},
-        {31, &SET_SYS::GetAccountNotificationSettings, "GetAccountNotificationSettings"},
-        {32, &SET_SYS::SetAccountNotificationSettings, "SetAccountNotificationSettings"},
+        {29, nullptr, "GetNotificationSettings"},
+        {30, nullptr, "SetNotificationSettings"},
+        {31, nullptr, "GetAccountNotificationSettings"},
+        {32, nullptr, "SetAccountNotificationSettings"},
         {35, nullptr, "GetVibrationMasterVolume"},
         {36, nullptr, "SetVibrationMasterVolume"},
         {37, &SET_SYS::GetSettingsItemValueSize, "GetSettingsItemValueSize"},
         {38, &SET_SYS::GetSettingsItemValue, "GetSettingsItemValue"},
-        {39, &SET_SYS::GetTvSettings, "GetTvSettings"},
-        {40, &SET_SYS::SetTvSettings, "SetTvSettings"},
+        {39, nullptr, "GetTvSettings"},
+        {40, nullptr, "SetTvSettings"},
         {41, nullptr, "GetEdid"},
         {42, nullptr, "SetEdid"},
         {43, nullptr, "GetAudioOutputMode"},
         {44, nullptr, "SetAudioOutputMode"},
         {45, nullptr, "IsForceMuteOnHeadphoneRemoved"},
         {46, nullptr, "SetForceMuteOnHeadphoneRemoved"},
-        {47, &SET_SYS::GetQuestFlag, "GetQuestFlag"},
+        {47, nullptr, "GetQuestFlag"},
         {48, nullptr, "SetQuestFlag"},
         {49, nullptr, "GetDataDeletionSettings"},
         {50, nullptr, "SetDataDeletionSettings"},
@@ -546,13 +241,13 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {54, nullptr, "SetDeviceTimeZoneLocationName"},
         {55, nullptr, "GetWirelessCertificationFileSize"},
         {56, nullptr, "GetWirelessCertificationFile"},
-        {57, &SET_SYS::SetRegionCode, "SetRegionCode"},
+        {57, nullptr, "SetRegionCode"},
         {58, nullptr, "GetNetworkSystemClockContext"},
         {59, nullptr, "SetNetworkSystemClockContext"},
         {60, nullptr, "IsUserSystemClockAutomaticCorrectionEnabled"},
         {61, nullptr, "SetUserSystemClockAutomaticCorrectionEnabled"},
         {62, nullptr, "GetDebugModeFlag"},
-        {63, &SET_SYS::GetPrimaryAlbumStorage, "GetPrimaryAlbumStorage"},
+        {63, nullptr, "GetPrimaryAlbumStorage"},
         {64, nullptr, "SetPrimaryAlbumStorage"},
         {65, nullptr, "GetUsb30EnableFlag"},
         {66, nullptr, "SetUsb30EnableFlag"},
@@ -560,15 +255,15 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {68, nullptr, "GetSerialNumber"},
         {69, nullptr, "GetNfcEnableFlag"},
         {70, nullptr, "SetNfcEnableFlag"},
-        {71, &SET_SYS::GetSleepSettings, "GetSleepSettings"},
-        {72, &SET_SYS::SetSleepSettings, "SetSleepSettings"},
+        {71, nullptr, "GetSleepSettings"},
+        {72, nullptr, "SetSleepSettings"},
         {73, nullptr, "GetWirelessLanEnableFlag"},
         {74, nullptr, "SetWirelessLanEnableFlag"},
-        {75, &SET_SYS::GetInitialLaunchSettings, "GetInitialLaunchSettings"},
-        {76, &SET_SYS::SetInitialLaunchSettings, "SetInitialLaunchSettings"},
+        {75, nullptr, "GetInitialLaunchSettings"},
+        {76, nullptr, "SetInitialLaunchSettings"},
         {77, &SET_SYS::GetDeviceNickName, "GetDeviceNickName"},
-        {78, &SET_SYS::SetDeviceNickName, "SetDeviceNickName"},
-        {79, &SET_SYS::GetProductModel, "GetProductModel"},
+        {78, nullptr, "SetDeviceNickName"},
+        {79, nullptr, "GetProductModel"},
         {80, nullptr, "GetLdnChannel"},
         {81, nullptr, "SetLdnChannel"},
         {82, nullptr, "AcquireTelemetryDirtyFlagEventHandle"},
@@ -579,16 +274,16 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {87, nullptr, "SetPtmFuelGaugeParameter"},
         {88, nullptr, "GetBluetoothEnableFlag"},
         {89, nullptr, "SetBluetoothEnableFlag"},
-        {90, &SET_SYS::GetMiiAuthorId, "GetMiiAuthorId"},
+        {90, nullptr, "GetMiiAuthorId"},
         {91, nullptr, "SetShutdownRtcValue"},
         {92, nullptr, "GetShutdownRtcValue"},
         {93, nullptr, "AcquireFatalDirtyFlagEventHandle"},
         {94, nullptr, "GetFatalDirtyFlags"},
-        {95, &SET_SYS::GetAutoUpdateEnableFlag, "GetAutoUpdateEnableFlag"},
+        {95, nullptr, "GetAutoUpdateEnableFlag"},
         {96, nullptr, "SetAutoUpdateEnableFlag"},
         {97, nullptr, "GetNxControllerSettings"},
         {98, nullptr, "SetNxControllerSettings"},
-        {99, &SET_SYS::GetBatteryPercentageFlag, "GetBatteryPercentageFlag"},
+        {99, nullptr, "GetBatteryPercentageFlag"},
         {100, nullptr, "SetBatteryPercentageFlag"},
         {101, nullptr, "GetExternalRtcResetFlag"},
         {102, nullptr, "SetExternalRtcResetFlag"},
@@ -613,10 +308,10 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {121, nullptr, "SetPushNotificationActivityModeOnSleep"},
         {122, nullptr, "GetServiceDiscoveryControlSettings"},
         {123, nullptr, "SetServiceDiscoveryControlSettings"},
-        {124, &SET_SYS::GetErrorReportSharePermission, "GetErrorReportSharePermission"},
+        {124, nullptr, "GetErrorReportSharePermission"},
         {125, nullptr, "SetErrorReportSharePermission"},
-        {126, &SET_SYS::GetAppletLaunchFlags, "GetAppletLaunchFlags"},
-        {127, &SET_SYS::SetAppletLaunchFlags, "SetAppletLaunchFlags"},
+        {126, nullptr, "GetAppletLaunchFlags"},
+        {127, nullptr, "SetAppletLaunchFlags"},
         {128, nullptr, "GetConsoleSixAxisSensorAccelerationBias"},
         {129, nullptr, "SetConsoleSixAxisSensorAccelerationBias"},
         {130, nullptr, "GetConsoleSixAxisSensorAngularVelocityBias"},
@@ -625,7 +320,7 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {133, nullptr, "SetConsoleSixAxisSensorAccelerationGain"},
         {134, nullptr, "GetConsoleSixAxisSensorAngularVelocityGain"},
         {135, nullptr, "SetConsoleSixAxisSensorAngularVelocityGain"},
-        {136, &SET_SYS::GetKeyboardLayout, "GetKeyboardLayout"},
+        {136, nullptr, "GetKeyboardLayout"},
         {137, nullptr, "SetKeyboardLayout"},
         {138, nullptr, "GetWebInspectorFlag"},
         {139, nullptr, "GetAllowedSslHosts"},
@@ -659,7 +354,7 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {167, nullptr, "SetUsb30DeviceEnableFlag"},
         {168, nullptr, "GetThemeId"},
         {169, nullptr, "SetThemeId"},
-        {170, &SET_SYS::GetChineseTraditionalInputMethod, "GetChineseTraditionalInputMethod"},
+        {170, nullptr, "GetChineseTraditionalInputMethod"},
         {171, nullptr, "SetChineseTraditionalInputMethod"},
         {172, nullptr, "GetPtmCycleCountReliability"},
         {173, nullptr, "SetPtmCycleCountReliability"},
@@ -690,16 +385,12 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {198, nullptr, "SetButtonConfigRegisteredSettingsEmbedded"},
         {199, nullptr, "GetButtonConfigRegisteredSettings"},
         {200, nullptr, "SetButtonConfigRegisteredSettings"},
-        {201, &SET_SYS::GetFieldTestingFlag, "GetFieldTestingFlag"},
+        {201, nullptr, "GetFieldTestingFlag"},
         {202, nullptr, "SetFieldTestingFlag"},
         {203, nullptr, "GetPanelCrcMode"},
         {204, nullptr, "SetPanelCrcMode"},
         {205, nullptr, "GetNxControllerSettingsEx"},
         {206, nullptr, "SetNxControllerSettingsEx"},
-        {207, nullptr, "GetHearingProtectionSafeguardFlag"},
-        {208, nullptr, "SetHearingProtectionSafeguardFlag"},
-        {209, nullptr, "GetHearingProtectionSafeguardRemainingTime"},
-        {210, nullptr, "SetHearingProtectionSafeguardRemainingTime"},
     };
     // clang-format on
 

src/core/hle/service/set/set_sys.h

@@ -3,9 +3,7 @@
 
 #pragma once
 
-#include "common/uuid.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/time/clock_types.h"
 
 namespace Core {
 class System;
@@ -25,331 +23,15 @@ private:
         BasicBlack = 1,
     };
 
-    /// Indicates the current console is a retail or kiosk unit
-    enum class QuestFlag : u8 {
-        Retail = 0,
-        Kiosk = 1,
-    };
-
-    /// This is nn::settings::system::TvResolution
-    enum class TvResolution : u32 {
-        Auto,
-        Resolution1080p,
-        Resolution720p,
-        Resolution480p,
-    };
-
-    /// This is nn::settings::system::HdmiContentType
-    enum class HdmiContentType : u32 {
-        None,
-        Graphics,
-        Cinema,
-        Photo,
-        Game,
-    };
-
-    /// This is nn::settings::system::RgbRange
-    enum class RgbRange : u32 {
-        Auto,
-        Full,
-        Limited,
-    };
-
-    /// This is nn::settings::system::CmuMode
-    enum class CmuMode : u32 {
-        None,
-        ColorInvert,
-        HighContrast,
-        GrayScale,
-    };
-
-    /// This is nn::settings::system::PrimaryAlbumStorage
-    enum class PrimaryAlbumStorage : u32 {
-        Nand,
-        SdCard,
-    };
-
-    /// This is nn::settings::system::NotificationVolume
-    enum class NotificationVolume : u32 {
-        Mute,
-        Low,
-        High,
-    };
-
-    /// This is nn::settings::system::ChineseTraditionalInputMethod
-    enum class ChineseTraditionalInputMethod : u32 {
-        Unknown0 = 0,
-        Unknown1 = 1,
-        Unknown2 = 2,
-    };
-
-    /// This is nn::settings::system::ErrorReportSharePermission
-    enum class ErrorReportSharePermission : u32 {
-        NotConfirmed,
-        Granted,
-        Denied,
-    };
-
-    /// This is nn::settings::system::FriendPresenceOverlayPermission
-    enum class FriendPresenceOverlayPermission : u8 {
-        NotConfirmed,
-        NoDisplay,
-        FavoriteFriends,
-        Friends,
-    };
-
-    /// This is nn::settings::system::HandheldSleepPlan
-    enum class HandheldSleepPlan : u32 {
-        Sleep1Min,
-        Sleep3Min,
-        Sleep5Min,
-        Sleep10Min,
-        Sleep30Min,
-        Never,
-    };
-
-    /// This is nn::settings::system::ConsoleSleepPlan
-    enum class ConsoleSleepPlan : u32 {
-        Sleep1Hour,
-        Sleep2Hour,
-        Sleep3Hour,
-        Sleep6Hour,
-        Sleep12Hour,
-        Never,
-    };
-
-    /// This is nn::settings::system::RegionCode
-    enum class RegionCode : u32 {
-        Japan,
-        Usa,
-        Europe,
-        Australia,
-        HongKongTaiwanKorea,
-        China,
-    };
-
-    /// This is nn::settings::system::EulaVersionClockType
-    enum class EulaVersionClockType : u32 {
-        NetworkSystemClock,
-        SteadyClock,
-    };
-
-    /// This is nn::settings::system::SleepFlag
-    struct SleepFlag {
-        union {
-            u32 raw{};
-
-            BitField<0, 1, u32> SleepsWhilePlayingMedia;
-            BitField<1, 1, u32> WakesAtPowerStateChange;
-        };
-    };
-    static_assert(sizeof(SleepFlag) == 4, "TvFlag is an invalid size");
-
-    /// This is nn::settings::system::TvFlag
-    struct TvFlag {
-        union {
-            u32 raw{};
-
-            BitField<0, 1, u32> Allows4k;
-            BitField<1, 1, u32> Allows3d;
-            BitField<2, 1, u32> AllowsCec;
-            BitField<3, 1, u32> PreventsScreenBurnIn;
-        };
-    };
-    static_assert(sizeof(TvFlag) == 4, "TvFlag is an invalid size");
-
-    /// This is nn::settings::system::InitialLaunchFlag
-    struct InitialLaunchFlag {
-        union {
-            u32 raw{};
-
-            BitField<0, 1, u32> InitialLaunchCompletionFlag;
-            BitField<8, 1, u32> InitialLaunchUserAdditionFlag;
-            BitField<16, 1, u32> InitialLaunchTimestampFlag;
-        };
-    };
-    static_assert(sizeof(InitialLaunchFlag) == 4, "InitialLaunchFlag is an invalid size");
-
-    /// This is nn::settings::system::NotificationFlag
-    struct NotificationFlag {
-        union {
-            u32 raw{};
-
-            BitField<0, 1, u32> RingtoneFlag;
-            BitField<1, 1, u32> DownloadCompletionFlag;
-            BitField<8, 1, u32> EnablesNews;
-            BitField<9, 1, u32> IncomingLampFlag;
-        };
-    };
-    static_assert(sizeof(NotificationFlag) == 4, "NotificationFlag is an invalid size");
-
-    /// This is nn::settings::system::AccountNotificationFlag
-    struct AccountNotificationFlag {
-        union {
-            u32 raw{};
-
-            BitField<0, 1, u32> FriendOnlineFlag;
-            BitField<1, 1, u32> FriendRequestFlag;
-            BitField<8, 1, u32> CoralInvitationFlag;
-        };
-    };
-    static_assert(sizeof(AccountNotificationFlag) == 4,
-                  "AccountNotificationFlag is an invalid size");
-
-    /// This is nn::settings::system::TvSettings
-    struct TvSettings {
-        TvFlag flags;
-        TvResolution tv_resolution;
-        HdmiContentType hdmi_content_type;
-        RgbRange rgb_range;
-        CmuMode cmu_mode;
-        u32 tv_underscan;
-        f32 tv_gama;
-        f32 constrast_ratio;
-    };
-    static_assert(sizeof(TvSettings) == 0x20, "TvSettings is an invalid size");
-
-    /// This is nn::settings::system::NotificationTime
-    struct NotificationTime {
-        u32 hour;
-        u32 minute;
-    };
-    static_assert(sizeof(NotificationTime) == 0x8, "NotificationTime is an invalid size");
-
-    /// This is nn::settings::system::NotificationSettings
-    struct NotificationSettings {
-        NotificationFlag flags;
-        NotificationVolume volume;
-        NotificationTime start_time;
-        NotificationTime stop_time;
-    };
-    static_assert(sizeof(NotificationSettings) == 0x18, "NotificationSettings is an invalid size");
-
-    /// This is nn::settings::system::AccountSettings
-    struct AccountSettings {
-        u32 flags;
-    };
-    static_assert(sizeof(AccountSettings) == 0x4, "AccountSettings is an invalid size");
-
-    /// This is nn::settings::system::AccountNotificationSettings
-    struct AccountNotificationSettings {
-        Common::UUID uid;
-        AccountNotificationFlag flags;
-        FriendPresenceOverlayPermission friend_presence_permission;
-        FriendPresenceOverlayPermission friend_invitation_permission;
-        INSERT_PADDING_BYTES(0x2);
-    };
-    static_assert(sizeof(AccountNotificationSettings) == 0x18,
-                  "AccountNotificationSettings is an invalid size");
-
-    /// This is nn::settings::system::InitialLaunchSettings
-    struct SleepSettings {
-        SleepFlag flags;
-        HandheldSleepPlan handheld_sleep_plan;
-        ConsoleSleepPlan console_sleep_plan;
-    };
-    static_assert(sizeof(SleepSettings) == 0xc, "SleepSettings is incorrect size");
-
-    /// This is nn::settings::system::InitialLaunchSettings
-    struct InitialLaunchSettings {
-        InitialLaunchFlag flags;
-        INSERT_PADDING_BYTES(0x4);
-        Time::Clock::SteadyClockTimePoint timestamp;
-    };
-    static_assert(sizeof(InitialLaunchSettings) == 0x20, "InitialLaunchSettings is incorrect size");
-
-    /// This is nn::settings::system::InitialLaunchSettings
-    struct EulaVersion {
-        u32 version;
-        RegionCode region_code;
-        EulaVersionClockType clock_type;
-        INSERT_PADDING_BYTES(0x4);
-        s64 posix_time;
-        Time::Clock::SteadyClockTimePoint timestamp;
-    };
-    static_assert(sizeof(EulaVersion) == 0x30, "EulaVersion is incorrect size");
-
-    void SetLanguageCode(HLERequestContext& ctx);
-    void GetFirmwareVersion(HLERequestContext& ctx);
-    void GetFirmwareVersion2(HLERequestContext& ctx);
-    void GetAccountSettings(HLERequestContext& ctx);
-    void SetAccountSettings(HLERequestContext& ctx);
-    void GetEulaVersions(HLERequestContext& ctx);
-    void SetEulaVersions(HLERequestContext& ctx);
-    void GetColorSetId(HLERequestContext& ctx);
-    void SetColorSetId(HLERequestContext& ctx);
-    void GetNotificationSettings(HLERequestContext& ctx);
-    void SetNotificationSettings(HLERequestContext& ctx);
-    void GetAccountNotificationSettings(HLERequestContext& ctx);
-    void SetAccountNotificationSettings(HLERequestContext& ctx);
     void GetSettingsItemValueSize(HLERequestContext& ctx);
     void GetSettingsItemValue(HLERequestContext& ctx);
-    void GetTvSettings(HLERequestContext& ctx);
-    void SetTvSettings(HLERequestContext& ctx);
-    void GetQuestFlag(HLERequestContext& ctx);
-    void SetRegionCode(HLERequestContext& ctx);
-    void GetPrimaryAlbumStorage(HLERequestContext& ctx);
-    void GetSleepSettings(HLERequestContext& ctx);
-    void SetSleepSettings(HLERequestContext& ctx);
-    void GetInitialLaunchSettings(HLERequestContext& ctx);
-    void SetInitialLaunchSettings(HLERequestContext& ctx);
+    void GetFirmwareVersion(HLERequestContext& ctx);
+    void GetFirmwareVersion2(HLERequestContext& ctx);
+    void GetColorSetId(HLERequestContext& ctx);
+    void SetColorSetId(HLERequestContext& ctx);
     void GetDeviceNickName(HLERequestContext& ctx);
-    void SetDeviceNickName(HLERequestContext& ctx);
-    void GetProductModel(HLERequestContext& ctx);
-    void GetMiiAuthorId(HLERequestContext& ctx);
-    void GetAutoUpdateEnableFlag(HLERequestContext& ctx);
-    void GetBatteryPercentageFlag(HLERequestContext& ctx);
-    void GetErrorReportSharePermission(HLERequestContext& ctx);
-    void GetAppletLaunchFlags(HLERequestContext& ctx);
-    void SetAppletLaunchFlags(HLERequestContext& ctx);
-    void GetKeyboardLayout(HLERequestContext& ctx);
-    void GetChineseTraditionalInputMethod(HLERequestContext& ctx);
-    void GetFieldTestingFlag(HLERequestContext& ctx);
-
-    AccountSettings account_settings{
-        .flags = {},
-    };
 
     ColorSet color_set = ColorSet::BasicWhite;
-
-    NotificationSettings notification_settings{
-        .flags = {0x300},
-        .volume = NotificationVolume::High,
-        .start_time = {.hour = 9, .minute = 0},
-        .stop_time = {.hour = 21, .minute = 0},
-    };
-
-    std::vector<AccountNotificationSettings> account_notifications{};
-
-    TvSettings tv_settings{
-        .flags = {0xc},
-        .tv_resolution = TvResolution::Auto,
-        .hdmi_content_type = HdmiContentType::Game,
-        .rgb_range = RgbRange::Auto,
-        .cmu_mode = CmuMode::None,
-        .tv_underscan = {},
-        .tv_gama = 1.0f,
-        .constrast_ratio = 0.5f,
-    };
-
-    InitialLaunchSettings launch_settings{
-        .flags = {0x10001},
-        .timestamp = {},
-    };
-
-    SleepSettings sleep_settings{
-        .flags = {0x3},
-        .handheld_sleep_plan = HandheldSleepPlan::Sleep10Min,
-        .console_sleep_plan = ConsoleSleepPlan::Sleep1Hour,
-    };
-
-    u32 applet_launch_flag{};
-
-    std::vector<EulaVersion> eula_versions{};
-
-    RegionCode region_code;
-
-    LanguageCode language_code_setting;
 };
 
 } // namespace Service::Set

src/core/hle/service/spl/spl_module.cpp

@@ -19,8 +19,7 @@ namespace Service::SPL {
 Module::Interface::Interface(Core::System& system_, std::shared_ptr<Module> module_,
                              const char* name)
     : ServiceFramework{system_, name}, module{std::move(module_)},
-      rng(Settings::values.rng_seed_enabled ? Settings::values.rng_seed.GetValue()
-                                            : static_cast<u32>(std::time(nullptr))) {}
+      rng(Settings::values.rng_seed.GetValue().value_or(std::time(nullptr))) {}
 
 Module::Interface::~Interface() = default;
 

src/core/hle/service/time/time_zone_content_manager.cpp

@@ -78,8 +78,7 @@ TimeZoneContentManager::TimeZoneContentManager(Core::System& system_)
       location_name_cache{BuildLocationNameCache(time_zone_binary)} {}
 
 void TimeZoneContentManager::Initialize(TimeManager& time_manager) {
-    const auto timezone_setting =
-        Settings::GetTimeZoneString(Settings::values.time_zone_index.GetValue());
+    const auto timezone_setting = Settings::GetTimeZoneString();
 
     if (FileSys::VirtualFile vfs_file;
         GetTimeZoneInfoFile(timezone_setting, vfs_file) == ResultSuccess) {

src/core/telemetry_session.cpp

@@ -61,13 +61,13 @@ static const char* TranslateRenderer(Settings::RendererBackend backend) {
     return "Unknown";
 }
 
-static const char* TranslateGPUAccuracyLevel(Settings::GpuAccuracy backend) {
+static const char* TranslateGPUAccuracyLevel(Settings::GPUAccuracy backend) {
     switch (backend) {
-    case Settings::GpuAccuracy::Normal:
+    case Settings::GPUAccuracy::Normal:
         return "Normal";
-    case Settings::GpuAccuracy::High:
+    case Settings::GPUAccuracy::High:
         return "High";
-    case Settings::GpuAccuracy::Extreme:
+    case Settings::GPUAccuracy::Extreme:
         return "Extreme";
     }
     return "Unknown";
@@ -77,9 +77,9 @@ static const char* TranslateNvdecEmulation(Settings::NvdecEmulation backend) {
     switch (backend) {
     case Settings::NvdecEmulation::Off:
         return "Off";
-    case Settings::NvdecEmulation::Cpu:
+    case Settings::NvdecEmulation::CPU:
         return "CPU";
-    case Settings::NvdecEmulation::Gpu:
+    case Settings::NvdecEmulation::GPU:
         return "GPU";
     }
     return "Unknown";
@@ -91,26 +91,14 @@ static constexpr const char* TranslateVSyncMode(Settings::VSyncMode mode) {
         return "Immediate";
     case Settings::VSyncMode::Mailbox:
         return "Mailbox";
-    case Settings::VSyncMode::Fifo:
+    case Settings::VSyncMode::FIFO:
         return "FIFO";
-    case Settings::VSyncMode::FifoRelaxed:
+    case Settings::VSyncMode::FIFORelaxed:
         return "FIFO Relaxed";
     }
     return "Unknown";
 }
 
-static constexpr const char* TranslateASTCDecodeMode(Settings::AstcDecodeMode mode) {
-    switch (mode) {
-    case Settings::AstcDecodeMode::Cpu:
-        return "CPU";
-    case Settings::AstcDecodeMode::Gpu:
-        return "GPU";
-    case Settings::AstcDecodeMode::CpuAsynchronous:
-        return "CPU Asynchronous";
-    }
-    return "Unknown";
-}
-
 u64 GetTelemetryId() {
     u64 telemetry_id{};
     const auto filename = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir) / "telemetry_id";
@@ -252,8 +240,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
 
     // Log user configuration information
     constexpr auto field_type = Telemetry::FieldType::UserConfig;
-    AddField(field_type, "Audio_SinkId",
-             Settings::CanonicalizeEnum(Settings::values.sink_id.GetValue()));
+    AddField(field_type, "Audio_SinkId", Settings::values.sink_id.GetValue());
     AddField(field_type, "Core_UseMultiCore", Settings::values.use_multi_core.GetValue());
     AddField(field_type, "Renderer_Backend",
              TranslateRenderer(Settings::values.renderer_backend.GetValue()));
@@ -267,8 +254,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
              Settings::values.use_asynchronous_gpu_emulation.GetValue());
     AddField(field_type, "Renderer_NvdecEmulation",
              TranslateNvdecEmulation(Settings::values.nvdec_emulation.GetValue()));
-    AddField(field_type, "Renderer_AccelerateASTC",
-             TranslateASTCDecodeMode(Settings::values.accelerate_astc.GetValue()));
+    AddField(field_type, "Renderer_AccelerateASTC", Settings::values.accelerate_astc.GetValue());
     AddField(field_type, "Renderer_UseVsync",
              TranslateVSyncMode(Settings::values.vsync_mode.GetValue()));
     AddField(field_type, "Renderer_ShaderBackend",

src/shader_recompiler/environment.h

@@ -39,7 +39,7 @@ public:
     [[nodiscard]] virtual std::optional<ReplaceConstant> GetReplaceConstBuffer(u32 bank,
                                                                                u32 offset) = 0;
 
-    virtual void Dump(u64 pipeline_hash, u64 shader_hash) = 0;
+    virtual void Dump(u64 hash) = 0;
 
     [[nodiscard]] const ProgramHeader& SPH() const noexcept {
         return sph;

src/video_core/host1x/codecs/codec.cpp

@@ -247,7 +247,7 @@ void Codec::Initialize() {
     av_codec = avcodec_find_decoder(codec);
 
     InitializeAvCodecContext();
-    if (Settings::values.nvdec_emulation.GetValue() == Settings::NvdecEmulation::Gpu) {
+    if (Settings::values.nvdec_emulation.GetValue() == Settings::NvdecEmulation::GPU) {
         InitializeGpuDecoder();
     }
     if (const int res = avcodec_open2(av_codec_ctx, av_codec, nullptr); res < 0) {

src/video_core/host1x/codecs/h264.cpp

@@ -84,7 +84,7 @@ std::span<const u8> H264::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters
 
     // TODO (ameerj): Where do we get this number, it seems to be particular for each stream
     const auto nvdec_decoding = Settings::values.nvdec_emulation.GetValue();
-    const bool uses_gpu_decoding = nvdec_decoding == Settings::NvdecEmulation::Gpu;
+    const bool uses_gpu_decoding = nvdec_decoding == Settings::NvdecEmulation::GPU;
     const u32 max_num_ref_frames = uses_gpu_decoding ? 6u : 16u;
     writer.WriteUe(max_num_ref_frames);
     writer.WriteBit(false);

src/video_core/renderer_opengl/gl_compute_pipeline.cpp

@@ -34,13 +34,13 @@ ComputePipeline::ComputePipeline(const Device& device, TextureCache& texture_cac
     : texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
       program_manager{program_manager_}, info{info_} {
     switch (device.GetShaderBackend()) {
-    case Settings::ShaderBackend::Glsl:
+    case Settings::ShaderBackend::GLSL:
         source_program = CreateProgram(code, GL_COMPUTE_SHADER);
         break;
-    case Settings::ShaderBackend::Glasm:
+    case Settings::ShaderBackend::GLASM:
         assembly_program = CompileProgram(code, GL_COMPUTE_PROGRAM_NV);
         break;
-    case Settings::ShaderBackend::SpirV:
+    case Settings::ShaderBackend::SPIRV:
         source_program = CreateProgram(code_v, GL_COMPUTE_SHADER);
         break;
     }

src/video_core/renderer_opengl/gl_device.cpp

@@ -106,43 +106,6 @@ bool IsASTCSupported() {
     return true;
 }
 
-static bool HasSlowSoftwareAstc(std::string_view vendor_name, std::string_view renderer) {
-// ifdef for Unix reduces string comparisons for non-Windows drivers, and Intel
-#ifdef YUZU_UNIX
-    // Sorted vaguely by how likely a vendor is to appear
-    if (vendor_name == "AMD") {
-        // RadeonSI
-        return true;
-    }
-    if (vendor_name == "Intel") {
-        // Must be inside YUZU_UNIX ifdef as the Windows driver uses the same vendor string
-        // iris, crocus
-        const bool is_intel_dg = (renderer.find("DG") != std::string_view::npos);
-        return is_intel_dg;
-    }
-    if (vendor_name == "nouveau") {
-        return true;
-    }
-    if (vendor_name == "X.Org") {
-        // R600
-        return true;
-    }
-#endif
-    if (vendor_name == "Collabora Ltd") {
-        // Zink
-        return true;
-    }
-    if (vendor_name == "Microsoft Corporation") {
-        // d3d12
-        return true;
-    }
-    if (vendor_name == "Mesa/X.org") {
-        // llvmpipe, softpipe, virgl
-        return true;
-    }
-    return false;
-}
-
 [[nodiscard]] bool IsDebugToolAttached(std::span<const std::string_view> extensions) {
     const bool nsight = std::getenv("NVTX_INJECTION64_PATH") || std::getenv("NSIGHT_LAUNCHED");
     return nsight || HasExtension(extensions, "GL_EXT_debug_tool") ||
@@ -157,16 +120,12 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     }
     vendor_name = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
     const std::string_view version = reinterpret_cast<const char*>(glGetString(GL_VERSION));
-    const std::string_view renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
     const std::vector extensions = GetExtensions();
 
     const bool is_nvidia = vendor_name == "NVIDIA Corporation";
     const bool is_amd = vendor_name == "ATI Technologies Inc.";
     const bool is_intel = vendor_name == "Intel";
 
-    const bool has_slow_software_astc =
-        !is_nvidia && !is_amd && HasSlowSoftwareAstc(vendor_name, renderer);
-
 #ifdef __unix__
     constexpr bool is_linux = true;
 #else
@@ -193,7 +152,7 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     has_vertex_viewport_layer = GLAD_GL_ARB_shader_viewport_layer_array;
     has_image_load_formatted = HasExtension(extensions, "GL_EXT_shader_image_load_formatted");
     has_texture_shadow_lod = HasExtension(extensions, "GL_EXT_texture_shadow_lod");
-    has_astc = !has_slow_software_astc && IsASTCSupported();
+    has_astc = IsASTCSupported();
     has_variable_aoffi = TestVariableAoffi();
     has_component_indexing_bug = is_amd;
     has_precise_bug = TestPreciseBug();
@@ -218,15 +177,15 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     has_fast_buffer_sub_data = is_nvidia && !disable_fast_buffer_sub_data;
 
     shader_backend = Settings::values.shader_backend.GetValue();
-    use_assembly_shaders = shader_backend == Settings::ShaderBackend::Glasm &&
+    use_assembly_shaders = shader_backend == Settings::ShaderBackend::GLASM &&
                            GLAD_GL_NV_gpu_program5 && GLAD_GL_NV_compute_program5 &&
                            GLAD_GL_NV_transform_feedback && GLAD_GL_NV_transform_feedback2;
-    if (shader_backend == Settings::ShaderBackend::Glasm && !use_assembly_shaders) {
+    if (shader_backend == Settings::ShaderBackend::GLASM && !use_assembly_shaders) {
         LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported");
-        shader_backend = Settings::ShaderBackend::Glsl;
+        shader_backend = Settings::ShaderBackend::GLSL;
     }
 
-    if (shader_backend == Settings::ShaderBackend::Glsl && is_nvidia) {
+    if (shader_backend == Settings::ShaderBackend::GLSL && is_nvidia) {
         const std::string_view driver_version = version.substr(13);
         const int version_major =
             std::atoi(driver_version.substr(0, driver_version.find(".")).data());

src/video_core/renderer_opengl/gl_graphics_pipeline.cpp

@@ -236,18 +236,18 @@ GraphicsPipeline::GraphicsPipeline(const Device& device, TextureCache& texture_c
                force_context_flush](ShaderContext::Context*) mutable {
         for (size_t stage = 0; stage < 5; ++stage) {
             switch (backend) {
-            case Settings::ShaderBackend::Glsl:
+            case Settings::ShaderBackend::GLSL:
                 if (!sources_[stage].empty()) {
                     source_programs[stage] = CreateProgram(sources_[stage], Stage(stage));
                 }
                 break;
-            case Settings::ShaderBackend::Glasm:
+            case Settings::ShaderBackend::GLASM:
                 if (!sources_[stage].empty()) {
                     assembly_programs[stage] =
                         CompileProgram(sources_[stage], AssemblyStage(stage));
                 }
                 break;
-            case Settings::ShaderBackend::SpirV:
+            case Settings::ShaderBackend::SPIRV:
                 if (!sources_spirv_[stage].empty()) {
                     source_programs[stage] = CreateProgram(sources_spirv_[stage], Stage(stage));
                 }

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -445,8 +445,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
     ShaderContext::ShaderPools& pools, const GraphicsPipelineKey& key,
     std::span<Shader::Environment* const> envs, bool use_shader_workers,
     bool force_context_flush) try {
-    auto hash = key.Hash();
-    LOG_INFO(Render_OpenGL, "0x{:016x}", hash);
+    LOG_INFO(Render_OpenGL, "0x{:016x}", key.Hash());
     size_t env_index{};
     u32 total_storage_buffers{};
     std::array<Shader::IR::Program, Maxwell::MaxShaderProgram> programs;
@@ -475,7 +474,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
         Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
 
         if (Settings::values.dump_shaders) {
-            env.Dump(hash, key.unique_hashes[index]);
+            env.Dump(key.unique_hashes[index]);
         }
 
         if (!uses_vertex_a || index != 1) {
@@ -523,14 +522,14 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
         const auto runtime_info{
             MakeRuntimeInfo(key, program, previous_program, glasm_use_storage_buffers, use_glasm)};
         switch (device.GetShaderBackend()) {
-        case Settings::ShaderBackend::Glsl:
+        case Settings::ShaderBackend::GLSL:
             ConvertLegacyToGeneric(program, runtime_info);
             sources[stage_index] = EmitGLSL(profile, runtime_info, program, binding);
             break;
-        case Settings::ShaderBackend::Glasm:
+        case Settings::ShaderBackend::GLASM:
             sources[stage_index] = EmitGLASM(profile, runtime_info, program, binding);
             break;
-        case Settings::ShaderBackend::SpirV:
+        case Settings::ShaderBackend::SPIRV:
             ConvertLegacyToGeneric(program, runtime_info);
             sources_spirv[stage_index] = EmitSPIRV(profile, runtime_info, program, binding);
             break;
@@ -567,13 +566,12 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
 std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
     ShaderContext::ShaderPools& pools, const ComputePipelineKey& key, Shader::Environment& env,
     bool force_context_flush) try {
-    auto hash = key.Hash();
-    LOG_INFO(Render_OpenGL, "0x{:016x}", hash);
+    LOG_INFO(Render_OpenGL, "0x{:016x}", key.Hash());
 
     Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
 
     if (Settings::values.dump_shaders) {
-        env.Dump(hash, key.unique_hash);
+        env.Dump(key.Hash());
     }
 
     auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
@@ -584,13 +582,13 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
     std::string code{};
     std::vector<u32> code_spirv;
     switch (device.GetShaderBackend()) {
-    case Settings::ShaderBackend::Glsl:
+    case Settings::ShaderBackend::GLSL:
         code = EmitGLSL(profile, program);
         break;
-    case Settings::ShaderBackend::Glasm:
+    case Settings::ShaderBackend::GLASM:
         code = EmitGLASM(profile, info, program);
         break;
-    case Settings::ShaderBackend::SpirV:
+    case Settings::ShaderBackend::SPIRV:
         code_spirv = EmitSPIRV(profile, program);
         break;
     }

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -232,9 +232,10 @@ void ApplySwizzle(GLuint handle, PixelFormat format, std::array<SwizzleSource, 4
 [[nodiscard]] bool CanBeAccelerated(const TextureCacheRuntime& runtime,
                                     const VideoCommon::ImageInfo& info) {
     if (IsPixelFormatASTC(info.format) && info.size.depth == 1 && !runtime.HasNativeASTC()) {
-        return Settings::values.accelerate_astc.GetValue() == Settings::AstcDecodeMode::Gpu &&
+        return Settings::values.accelerate_astc.GetValue() &&
                Settings::values.astc_recompression.GetValue() ==
-                   Settings::AstcRecompression::Uncompressed;
+                   Settings::AstcRecompression::Uncompressed &&
+               !Settings::values.async_astc.GetValue();
     }
     // Disable other accelerated uploads for now as they don't implement swizzled uploads
     return false;
@@ -266,8 +267,7 @@ void ApplySwizzle(GLuint handle, PixelFormat format, std::array<SwizzleSource, 4
 [[nodiscard]] bool CanBeDecodedAsync(const TextureCacheRuntime& runtime,
                                      const VideoCommon::ImageInfo& info) {
     if (IsPixelFormatASTC(info.format) && !runtime.HasNativeASTC()) {
-        return Settings::values.accelerate_astc.GetValue() ==
-               Settings::AstcDecodeMode::CpuAsynchronous;
+        return Settings::values.async_astc.GetValue();
     }
     return false;
 }

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -473,7 +473,7 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
     glBindTextureUnit(0, screen_info.display_texture);
 
     auto anti_aliasing = Settings::values.anti_aliasing.GetValue();
-    if (anti_aliasing >= Settings::AntiAliasing::MaxEnum) {
+    if (anti_aliasing > Settings::AntiAliasing::LastAA) {
         LOG_ERROR(Render_OpenGL, "Invalid antialiasing option selected {}", anti_aliasing);
         anti_aliasing = Settings::AntiAliasing::None;
         Settings::values.anti_aliasing.SetValue(anti_aliasing);

src/video_core/renderer_vulkan/blit_image.cpp

@@ -3,8 +3,6 @@
 
 #include <algorithm>
 
-#include "video_core/renderer_vulkan/vk_texture_cache.h"
-
 #include "common/settings.h"
 #include "video_core/host_shaders/blit_color_float_frag_spv.h"
 #include "video_core/host_shaders/convert_abgr8_to_d24s8_frag_spv.h"
@@ -21,6 +19,7 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_shader_util.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
+#include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/surface.h"
 #include "video_core/vulkan_common/vulkan_device.h"

src/video_core/renderer_vulkan/renderer_vulkan.h

@@ -7,12 +7,11 @@
 #include <string>
 #include <variant>
 
-#include "video_core/renderer_vulkan/vk_rasterizer.h"
-
 #include "common/dynamic_library.h"
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_vulkan/vk_blit_screen.h"
 #include "video_core/renderer_vulkan/vk_present_manager.h"
+#include "video_core/renderer_vulkan/vk_rasterizer.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -7,9 +7,8 @@
 #include <span>
 #include <vector>
 
-#include "video_core/renderer_vulkan/vk_buffer_cache.h"
-
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
+#include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -6,8 +6,6 @@
 #include <optional>
 #include <utility>
 
-#include "video_core/renderer_vulkan/vk_texture_cache.h"
-
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/div_ceil.h"
@@ -18,6 +16,7 @@
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
+#include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/texture_cache/accelerated_swizzle.h"
 #include "video_core/texture_cache/types.h"

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -7,10 +7,9 @@
 #include <boost/container/small_vector.hpp>
 #include <boost/container/static_vector.hpp>
 
-#include "video_core/renderer_vulkan/pipeline_helper.h"
-
 #include "common/bit_field.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
+#include "video_core/renderer_vulkan/pipeline_helper.h"
 #include "video_core/renderer_vulkan/pipeline_statistics.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_graphics_pipeline.h"

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -584,8 +584,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
     ShaderPools& pools, const GraphicsPipelineCacheKey& key,
     std::span<Shader::Environment* const> envs, PipelineStatistics* statistics,
     bool build_in_parallel) try {
-    auto hash = key.Hash();
-    LOG_INFO(Render_Vulkan, "0x{:016x}", hash);
+    LOG_INFO(Render_Vulkan, "0x{:016x}", key.Hash());
     size_t env_index{0};
     std::array<Shader::IR::Program, Maxwell::MaxShaderProgram> programs;
     const bool uses_vertex_a{key.unique_hashes[0] != 0};
@@ -612,7 +611,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
         const u32 cfg_offset{static_cast<u32>(env.StartAddress() + sizeof(Shader::ProgramHeader))};
         Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
         if (Settings::values.dump_shaders) {
-            env.Dump(hash, key.unique_hashes[index]);
+            env.Dump(key.unique_hashes[index]);
         }
         if (!uses_vertex_a || index != 1) {
             // Normal path
@@ -713,19 +712,18 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
 std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     ShaderPools& pools, const ComputePipelineCacheKey& key, Shader::Environment& env,
     PipelineStatistics* statistics, bool build_in_parallel) try {
-    auto hash = key.Hash();
     if (device.HasBrokenCompute()) {
-        LOG_ERROR(Render_Vulkan, "Skipping 0x{:016x}", hash);
+        LOG_ERROR(Render_Vulkan, "Skipping 0x{:016x}", key.Hash());
         return nullptr;
     }
 
-    LOG_INFO(Render_Vulkan, "0x{:016x}", hash);
+    LOG_INFO(Render_Vulkan, "0x{:016x}", key.Hash());
 
     Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
 
     // Dump it before error.
     if (Settings::values.dump_shaders) {
-        env.Dump(hash, key.unique_hash);
+        env.Dump(key.Hash());
     }
 
     auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -6,8 +6,6 @@
 #include <memory>
 #include <mutex>
 
-#include "video_core/renderer_vulkan/renderer_vulkan.h"
-
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
@@ -20,6 +18,7 @@
 #include "video_core/renderer_vulkan/blit_image.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
+#include "video_core/renderer_vulkan/renderer_vulkan.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -7,14 +7,13 @@
 
 #include <boost/container/static_vector.hpp>
 
-#include "video_core/renderer_vulkan/vk_buffer_cache.h"
-
 #include "common/common_types.h"
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/engines/maxwell_dma.h"
 #include "video_core/rasterizer_accelerated.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_vulkan/blit_image.h"
+#include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_fence_manager.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -6,12 +6,11 @@
 #include <thread>
 #include <utility>
 
-#include "video_core/renderer_vulkan/vk_query_cache.h"
-
 #include "common/microprofile.h"
 #include "common/thread.h"
 #include "video_core/renderer_vulkan/vk_command_pool.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
+#include "video_core/renderer_vulkan/vk_query_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -45,8 +45,8 @@ static VkPresentModeKHR ChooseSwapPresentMode(bool has_imm, bool has_mailbox,
             return mode;
         }
         switch (mode) {
-        case Settings::VSyncMode::Fifo:
-        case Settings::VSyncMode::FifoRelaxed:
+        case Settings::VSyncMode::FIFO:
+        case Settings::VSyncMode::FIFORelaxed:
             if (has_mailbox) {
                 return Settings::VSyncMode::Mailbox;
             } else if (has_imm) {
@@ -59,8 +59,8 @@ static VkPresentModeKHR ChooseSwapPresentMode(bool has_imm, bool has_mailbox,
     }();
     if ((setting == Settings::VSyncMode::Mailbox && !has_mailbox) ||
         (setting == Settings::VSyncMode::Immediate && !has_imm) ||
-        (setting == Settings::VSyncMode::FifoRelaxed && !has_fifo_relaxed)) {
-        setting = Settings::VSyncMode::Fifo;
+        (setting == Settings::VSyncMode::FIFORelaxed && !has_fifo_relaxed)) {
+        setting = Settings::VSyncMode::FIFO;
     }
 
     switch (setting) {
@@ -68,9 +68,9 @@ static VkPresentModeKHR ChooseSwapPresentMode(bool has_imm, bool has_mailbox,
         return VK_PRESENT_MODE_IMMEDIATE_KHR;
     case Settings::VSyncMode::Mailbox:
         return VK_PRESENT_MODE_MAILBOX_KHR;
-    case Settings::VSyncMode::Fifo:
+    case Settings::VSyncMode::FIFO:
         return VK_PRESENT_MODE_FIFO_KHR;
-    case Settings::VSyncMode::FifoRelaxed:
+    case Settings::VSyncMode::FIFORelaxed:
         return VK_PRESENT_MODE_FIFO_RELAXED_KHR;
     default:
         return VK_PRESENT_MODE_FIFO_KHR;

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -11,8 +11,6 @@
 #include "common/bit_util.h"
 #include "common/settings.h"
 
-#include "video_core/renderer_vulkan/vk_texture_cache.h"
-
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/renderer_vulkan/blit_image.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
@@ -20,6 +18,7 @@
 #include "video_core/renderer_vulkan/vk_render_pass_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
+#include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/texture_cache/formatter.h"
 #include "video_core/texture_cache/samples_helper.h"
 #include "video_core/texture_cache/util.h"
@@ -818,7 +817,7 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
     : device{device_}, scheduler{scheduler_}, memory_allocator{memory_allocator_},
       staging_buffer_pool{staging_buffer_pool_}, blit_image_helper{blit_image_helper_},
       render_pass_cache{render_pass_cache_}, resolution{Settings::values.resolution_info} {
-    if (Settings::values.accelerate_astc.GetValue() == Settings::AstcDecodeMode::Gpu) {
+    if (Settings::values.accelerate_astc) {
         astc_decoder_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
                                   compute_pass_descriptor_queue, memory_allocator);
     }
@@ -1302,19 +1301,12 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
                                                    runtime->ViewFormats(info.format))),
       aspect_mask(ImageAspectMask(info.format)) {
     if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported()) {
-        switch (Settings::values.accelerate_astc.GetValue()) {
-        case Settings::AstcDecodeMode::Gpu:
-            if (Settings::values.astc_recompression.GetValue() ==
-                    Settings::AstcRecompression::Uncompressed &&
-                info.size.depth == 1) {
-                flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
-            }
-            break;
-        case Settings::AstcDecodeMode::CpuAsynchronous:
+        if (Settings::values.async_astc.GetValue()) {
             flags |= VideoCommon::ImageFlagBits::AsynchronousDecode;
-            break;
-        default:
-            break;
+        } else if (Settings::values.astc_recompression.GetValue() ==
+                       Settings::AstcRecompression::Uncompressed &&
+                   Settings::values.accelerate_astc.GetValue() && info.size.depth == 1) {
+            flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
         }
         flags |= VideoCommon::ImageFlagBits::Converted;
         flags |= VideoCommon::ImageFlagBits::CostlyLoad;

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -5,12 +5,11 @@
 
 #include <span>
 
-#include "video_core/texture_cache/texture_cache_base.h"
-
 #include "shader_recompiler/shader_info.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
 #include "video_core/texture_cache/image_view_base.h"
+#include "video_core/texture_cache/texture_cache_base.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 

src/video_core/shader_cache.cpp

@@ -51,11 +51,6 @@ bool ShaderCache::RefreshStages(std::array<u64, 6>& unique_hashes) {
         }
         const auto& shader_config{maxwell3d->regs.pipelines[index]};
         const auto program{static_cast<Tegra::Engines::Maxwell3D::Regs::ShaderType>(index)};
-        if (program == Tegra::Engines::Maxwell3D::Regs::ShaderType::Pixel &&
-            !maxwell3d->regs.rasterize_enable) {
-            unique_hashes[index] = 0;
-            continue;
-        }
         const GPUVAddr shader_addr{base_addr + shader_config.offset};
         const std::optional<VAddr> cpu_shader_addr{gpu_memory->GpuToCpuAddress(shader_addr)};
         if (!cpu_shader_addr) {

src/video_core/shader_cache.h

@@ -70,7 +70,7 @@ public:
 protected:
     struct GraphicsEnvironments {
         std::array<GraphicsEnvironment, NUM_PROGRAMS> envs;
-        std::array<Shader::Environment*, NUM_PROGRAMS> env_ptrs{};
+        std::array<Shader::Environment*, NUM_PROGRAMS> env_ptrs;
 
         std::span<Shader::Environment* const> Span() const noexcept {
             return std::span(env_ptrs.begin(), std::ranges::find(env_ptrs, nullptr));

src/video_core/shader_environment.cpp

@@ -102,8 +102,7 @@ static std::string_view StageToPrefix(Shader::Stage stage) {
     }
 }
 
-static void DumpImpl(u64 pipeline_hash, u64 shader_hash, std::span<const u64> code,
-                     [[maybe_unused]] u32 read_highest, [[maybe_unused]] u32 read_lowest,
+static void DumpImpl(u64 hash, const u64* code, u32 read_highest, u32 read_lowest,
                      u32 initial_offset, Shader::Stage stage) {
     const auto shader_dir{Common::FS::GetYuzuPath(Common::FS::YuzuPath::DumpDir)};
     const auto base_dir{shader_dir / "shaders"};
@@ -112,18 +111,13 @@ static void DumpImpl(u64 pipeline_hash, u64 shader_hash, std::span<const u64> co
         return;
     }
     const auto prefix = StageToPrefix(stage);
-    const auto name{base_dir /
-                    fmt::format("{:016x}_{}_{:016x}.ash", pipeline_hash, prefix, shader_hash)};
+    const auto name{base_dir / fmt::format("{}{:016x}.ash", prefix, hash)};
+    const size_t real_size = read_highest - read_lowest + initial_offset;
+    const size_t padding_needed = ((32 - (real_size % 32)) % 32);
     std::fstream shader_file(name, std::ios::out | std::ios::binary);
-    ASSERT(initial_offset % sizeof(u64) == 0);
     const size_t jump_index = initial_offset / sizeof(u64);
-    const size_t code_size = code.size_bytes() - initial_offset;
-    shader_file.write(reinterpret_cast<const char*>(&code[jump_index]), code_size);
-
-    // + 1 instruction, due to the fact that we skip the final self branch instruction in the code,
-    // but we need to consider it for padding, otherwise nvdisasm rages.
-    const size_t padding_needed = (32 - ((code_size + INST_SIZE) % 32)) % 32;
-    for (size_t i = 0; i < INST_SIZE + padding_needed; i++) {
+    shader_file.write(reinterpret_cast<const char*>(code + jump_index), real_size);
+    for (size_t i = 0; i < padding_needed; i++) {
         shader_file.put(0);
     }
 }
@@ -203,8 +197,8 @@ u64 GenericEnvironment::CalculateHash() const {
     return Common::CityHash64(data.get(), size);
 }
 
-void GenericEnvironment::Dump(u64 pipeline_hash, u64 shader_hash) {
-    DumpImpl(pipeline_hash, shader_hash, code, read_highest, read_lowest, initial_offset, stage);
+void GenericEnvironment::Dump(u64 hash) {
+    DumpImpl(hash, code.data(), read_highest, read_lowest, initial_offset, stage);
 }
 
 void GenericEnvironment::Serialize(std::ofstream& file) const {
@@ -288,7 +282,6 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
 Tegra::Texture::TICEntry GenericEnvironment::ReadTextureInfo(GPUVAddr tic_addr, u32 tic_limit,
                                                              bool via_header_index, u32 raw) {
     const auto handle{Tegra::Texture::TexturePair(raw, via_header_index)};
-    ASSERT(handle.first <= tic_limit);
     const GPUVAddr descriptor_addr{tic_addr + handle.first * sizeof(Tegra::Texture::TICEntry)};
     Tegra::Texture::TICEntry entry;
     gpu_memory->ReadBlock(descriptor_addr, &entry, sizeof(entry));
@@ -472,8 +465,8 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
         .read(reinterpret_cast<char*>(&read_highest), sizeof(read_highest))
         .read(reinterpret_cast<char*>(&viewport_transform_state), sizeof(viewport_transform_state))
         .read(reinterpret_cast<char*>(&stage), sizeof(stage));
-    code.resize(Common::DivCeil(code_size, sizeof(u64)));
-    file.read(reinterpret_cast<char*>(code.data()), code_size);
+    code = std::make_unique<u64[]>(Common::DivCeil(code_size, sizeof(u64)));
+    file.read(reinterpret_cast<char*>(code.get()), code_size);
     for (size_t i = 0; i < num_texture_types; ++i) {
         u32 key;
         Shader::TextureType type;
@@ -516,8 +509,8 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
     is_propietary_driver = texture_bound == 2;
 }
 
-void FileEnvironment::Dump(u64 pipeline_hash, u64 shader_hash) {
-    DumpImpl(pipeline_hash, shader_hash, code, read_highest, read_lowest, initial_offset, stage);
+void FileEnvironment::Dump(u64 hash) {
+    DumpImpl(hash, code.get(), read_highest, read_lowest, initial_offset, stage);
 }
 
 u64 FileEnvironment::ReadInstruction(u32 address) {

src/video_core/shader_environment.h

@@ -58,7 +58,7 @@ public:
 
     [[nodiscard]] u64 CalculateHash() const;
 
-    void Dump(u64 pipeline_hash, u64 shader_hash) override;
+    void Dump(u64 hash) override;
 
     void Serialize(std::ofstream& file) const;
 
@@ -188,10 +188,10 @@ public:
         return cbuf_replacements.size() != 0;
     }
 
-    void Dump(u64 pipeline_hash, u64 shader_hash) override;
+    void Dump(u64 hash) override;
 
 private:
-    std::vector<u64> code;
+    std::unique_ptr<u64[]> code;
     std::unordered_map<u32, Shader::TextureType> texture_types;
     std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
     std::unordered_map<u64, u32> cbuf_values;

src/video_core/textures/texture.cpp

@@ -72,12 +72,12 @@ float TSCEntry::MaxAnisotropy() const noexcept {
     }
     const auto anisotropic_settings = Settings::values.max_anisotropy.GetValue();
     s32 added_anisotropic{};
-    if (anisotropic_settings == Settings::AnisotropyMode::Automatic) {
+    if (anisotropic_settings == 0) {
         added_anisotropic = Settings::values.resolution_info.up_scale >>
                             Settings::values.resolution_info.down_shift;
         added_anisotropic = std::max(added_anisotropic - 1, 0);
     } else {
-        added_anisotropic = static_cast<u32>(Settings::values.max_anisotropy.GetValue()) - 1U;
+        added_anisotropic = Settings::values.max_anisotropy.GetValue() - 1U;
     }
     return static_cast<float>(1U << (max_anisotropy + added_anisotropic));
 }

src/video_core/vulkan_common/vulkan.h

@@ -8,19 +8,6 @@
 #define VK_USE_PLATFORM_WIN32_KHR
 #elif defined(__APPLE__)
 #define VK_USE_PLATFORM_METAL_EXT
-#elif defined(__ANDROID__)
-#define VK_USE_PLATFORM_ANDROID_KHR
-#else
-#define VK_USE_PLATFORM_XLIB_KHR
-#define VK_USE_PLATFORM_WAYLAND_KHR
 #endif
 
 #include <vulkan/vulkan.h>
-
-// Sanitize macros
-#undef CreateEvent
-#undef CreateSemaphore
-#undef Always
-#undef False
-#undef None
-#undef True

src/video_core/vulkan_common/vulkan_device.cpp

@@ -525,13 +525,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             dynamic_state3_enables = false;
         }
     }
-    if (extensions.extended_dynamic_state3 && is_amd_driver) {
-        LOG_WARNING(Render_Vulkan,
-                    "AMD drivers have broken extendedDynamicState3ColorBlendEquation");
-        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
@@ -560,6 +553,14 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     }
 
     sets_per_pool = 64;
+    if (extensions.extended_dynamic_state3 && is_amd_driver &&
+        !features.shader_float16_int8.shaderFloat16 &&
+        properties.properties.driverVersion >= VK_MAKE_API_VERSION(0, 2, 0, 258)) {
+        LOG_WARNING(Render_Vulkan, "AMD GCN4 has broken extendedDynamicState3ColorBlendEquation");
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+        dynamic_state3_blending = false;
+    }
     if (is_amd_driver) {
         // AMD drivers need a higher amount of Sets per Pool in certain circumstances like in XC2.
         sets_per_pool = 96;
@@ -963,7 +964,7 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
         SetNext(next, properties.push_descriptor);
     }
-    if (extensions.subgroup_size_control || features.subgroup_size_control.subgroupSizeControl) {
+    if (extensions.subgroup_size_control) {
         properties.subgroup_size_control.sType =
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
         SetNext(next, properties.subgroup_size_control);

src/video_core/vulkan_common/vulkan_device.h

@@ -20,6 +20,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
 // Vulkan version in the macro describes the minimum version required for feature availability.
 // If the Vulkan version is lower than the required version, the named extension is required.
 #define FOR_EACH_VK_FEATURE_1_1(FEATURE)                                                           \
+    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
     FEATURE(KHR, 16BitStorage, 16BIT_STORAGE, bit16_storage)                                       \
     FEATURE(KHR, ShaderAtomicInt64, SHADER_ATOMIC_INT64, shader_atomic_int64)                      \
     FEATURE(KHR, ShaderDrawParameters, SHADER_DRAW_PARAMETERS, shader_draw_parameters)             \
@@ -35,8 +36,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
 
 #define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
     FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
-            shader_demote_to_helper_invocation)                                                    \
-    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)
+            shader_demote_to_helper_invocation)
 
 // Define all features which may be used by the implementation and require an extension here.
 #define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \

src/video_core/vulkan_common/vulkan_instance.cpp

@@ -14,6 +14,19 @@
 #include "video_core/vulkan_common/vulkan_instance.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
+// Include these late to avoid polluting previous headers
+#if defined(_WIN32)
+#include <windows.h>
+// ensure include order
+#include <vulkan/vulkan_win32.h>
+#elif defined(__ANDROID__)
+#include <vulkan/vulkan_android.h>
+#elif !defined(__APPLE__)
+#include <X11/Xlib.h>
+#include <vulkan/vulkan_wayland.h>
+#include <vulkan/vulkan_xlib.h>
+#endif
+
 namespace Vulkan {
 namespace {
 

src/video_core/vulkan_common/vulkan_surface.cpp

@@ -6,6 +6,19 @@
 #include "video_core/vulkan_common/vulkan_surface.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
+// Include these late to avoid polluting previous headers
+#ifdef _WIN32
+#include <windows.h>
+// ensure include order
+#include <vulkan/vulkan_win32.h>
+#elif defined(__ANDROID__)
+#include <vulkan/vulkan_android.h>
+#elif !defined(__APPLE__)
+#include <X11/Xlib.h>
+#include <vulkan/vulkan_wayland.h>
+#include <vulkan/vulkan_xlib.h>
+#endif
+
 namespace Vulkan {
 
 vk::SurfaceKHR CreateSurface(

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -15,6 +15,14 @@
 #include "common/common_types.h"
 #include "video_core/vulkan_common/vulkan.h"
 
+// Sanitize macros
+#ifdef CreateEvent
+#undef CreateEvent
+#endif
+#ifdef CreateSemaphore
+#undef CreateSemaphore
+#endif
+
 #ifdef _MSC_VER
 #pragma warning(disable : 26812) // Disable prefer enum class over enum
 #endif

src/yuzu/CMakeLists.txt

@@ -143,10 +143,6 @@ add_executable(yuzu
     configuration/configure_web.ui
     configuration/input_profiles.cpp
     configuration/input_profiles.h
-    configuration/shared_translation.cpp
-    configuration/shared_translation.h
-    configuration/shared_widget.cpp
-    configuration/shared_widget.h
     debugger/console.cpp
     debugger/console.h
     debugger/controller.cpp
@@ -235,12 +231,6 @@ if (WIN32 AND YUZU_CRASH_DUMPS)
     target_compile_definitions(yuzu PRIVATE -DYUZU_DBGHELP)
 endif()
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    target_compile_definitions(yuzu PRIVATE
-        $<$<VERSION_LESS:$<CXX_COMPILER_VERSION>,15>:CANNOT_EXPLICITLY_INSTANTIATE>
-    )
-endif()
-
 file(GLOB COMPAT_LIST
      ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
      ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)

src/yuzu/configuration/config.h

@@ -52,7 +52,7 @@ public:
     static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map;
     static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map;
     static const std::map<bool, QString> use_docked_mode_texts_map;
-    static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map;
+    static const std::map<Settings::GPUAccuracy, QString> gpu_accuracy_texts_map;
     static const std::map<Settings::RendererBackend, QString> renderer_backend_texts_map;
     static const std::map<Settings::ShaderBackend, QString> shader_backend_texts_map;
 
@@ -74,6 +74,7 @@ private:
     void ReadKeyboardValues();
     void ReadMouseValues();
     void ReadTouchscreenValues();
+    void ReadMousePanningValues();
     void ReadMotionTouchValues();
     void ReadHidbusValues();
     void ReadIrCameraValues();
@@ -98,13 +99,13 @@ private:
     void ReadUILayoutValues();
     void ReadWebServiceValues();
     void ReadMultiplayerValues();
-    void ReadNetworkValues();
 
     void SaveValues();
     void SavePlayerValue(std::size_t player_index);
     void SaveDebugValues();
     void SaveMouseValues();
     void SaveTouchscreenValues();
+    void SaveMousePanningValues();
     void SaveMotionTouchValues();
     void SaveHidbusValues();
     void SaveIrCameraValues();
@@ -139,6 +140,18 @@ private:
     QVariant ReadSetting(const QString& name) const;
     QVariant ReadSetting(const QString& name, const QVariant& default_value) const;
 
+    /**
+     * Only reads a setting from the qt_config if the current config is a global config, or if the
+     * current config is a custom config and the setting is overriding the global setting. Otherwise
+     * it does nothing.
+     *
+     * @param setting The variable to be modified
+     * @param name The setting's identifier
+     * @param default_value The value to use when the setting is not already present in the config
+     */
+    template <typename Type>
+    void ReadSettingGlobal(Type& setting, const QString& name, const QVariant& default_value) const;
+
     /**
      * Writes a setting to the qt_config.
      *
@@ -153,20 +166,50 @@ private:
     void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value,
                       bool use_global);
 
-    void ReadCategory(Settings::Category category);
-    void WriteCategory(Settings::Category category);
-    void ReadSettingGeneric(Settings::BasicSetting* const setting);
-    void WriteSettingGeneric(Settings::BasicSetting* const setting) const;
+    /**
+     * Reads a value from the qt_config and applies it to the setting, using its label and default
+     * value. If the config is a custom config, this will also read the global state of the setting
+     * and apply that information to it.
+     *
+     * @param The setting
+     */
+    template <typename Type, bool ranged>
+    void ReadGlobalSetting(Settings::SwitchableSetting<Type, ranged>& setting);
 
-    const ConfigType type;
+    /**
+     * Sets a value to the qt_config using the setting's label and default value. If the config is a
+     * custom config, it will apply the global state, and the custom value if needed.
+     *
+     * @param The setting
+     */
+    template <typename Type, bool ranged>
+    void WriteGlobalSetting(const Settings::SwitchableSetting<Type, ranged>& setting);
+
+    /**
+     * Reads a value from the qt_config using the setting's label and default value and applies the
+     * value to the setting.
+     *
+     * @param The setting
+     */
+    template <typename Type, bool ranged>
+    void ReadBasicSetting(Settings::Setting<Type, ranged>& setting);
+
+    /** Sets a value from the setting in the qt_config using the setting's label and default value.
+     *
+     * @param The setting
+     */
+    template <typename Type, bool ranged>
+    void WriteBasicSetting(const Settings::Setting<Type, ranged>& setting);
+
+    ConfigType type;
     std::unique_ptr<QSettings> qt_config;
     std::string qt_config_loc;
-    const bool global;
+    bool global;
 };
 
 // These metatype declarations cannot be in common/settings.h because core is devoid of QT
-Q_DECLARE_METATYPE(Settings::CpuAccuracy);
-Q_DECLARE_METATYPE(Settings::GpuAccuracy);
+Q_DECLARE_METATYPE(Settings::CPUAccuracy);
+Q_DECLARE_METATYPE(Settings::GPUAccuracy);
 Q_DECLARE_METATYPE(Settings::FullscreenMode);
 Q_DECLARE_METATYPE(Settings::NvdecEmulation);
 Q_DECLARE_METATYPE(Settings::ResolutionSetup);
@@ -175,4 +218,3 @@ Q_DECLARE_METATYPE(Settings::AntiAliasing);
 Q_DECLARE_METATYPE(Settings::RendererBackend);
 Q_DECLARE_METATYPE(Settings::ShaderBackend);
 Q_DECLARE_METATYPE(Settings::AstcRecompression);
-Q_DECLARE_METATYPE(Settings::AstcDecodeMode);

src/yuzu/configuration/configuration_shared.cpp

@@ -1,19 +1,104 @@
 // SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <memory>
-#include <type_traits>
-#include <vector>
+#include <QCheckBox>
+#include <QObject>
+#include <QString>
+#include "common/settings.h"
 #include "yuzu/configuration/configuration_shared.h"
+#include "yuzu/configuration/configure_per_game.h"
 
-namespace ConfigurationShared {
-
-Tab::Tab(std::shared_ptr<std::vector<Tab*>> group, QWidget* parent) : QWidget(parent) {
-    if (group != nullptr) {
-        group->push_back(this);
+void ConfigurationShared::ApplyPerGameSetting(Settings::SwitchableSetting<bool>* setting,
+                                              const QCheckBox* checkbox,
+                                              const CheckState& tracker) {
+    if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) {
+        setting->SetValue(checkbox->checkState());
+    } else if (!Settings::IsConfiguringGlobal()) {
+        if (tracker == CheckState::Global) {
+            setting->SetGlobal(true);
+        } else {
+            setting->SetGlobal(false);
+            setting->SetValue(checkbox->checkState());
+        }
     }
 }
 
-Tab::~Tab() = default;
+void ConfigurationShared::SetPerGameSetting(QCheckBox* checkbox,
+                                            const Settings::SwitchableSetting<bool>* setting) {
+    if (setting->UsingGlobal()) {
+        checkbox->setCheckState(Qt::PartiallyChecked);
+    } else {
+        checkbox->setCheckState(setting->GetValue() ? Qt::Checked : Qt::Unchecked);
+    }
+}
 
-} // namespace ConfigurationShared
+void ConfigurationShared::SetHighlight(QWidget* widget, bool highlighted) {
+    if (highlighted) {
+        widget->setStyleSheet(QStringLiteral("QWidget#%1 { background-color:rgba(0,203,255,0.5) }")
+                                  .arg(widget->objectName()));
+    } else {
+        widget->setStyleSheet(QStringLiteral("QWidget#%1 { background-color:rgba(0,0,0,0) }")
+                                  .arg(widget->objectName()));
+    }
+    widget->show();
+}
+
+void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox,
+                                             const Settings::SwitchableSetting<bool>& setting,
+                                             CheckState& tracker) {
+    if (setting.UsingGlobal()) {
+        tracker = CheckState::Global;
+    } else {
+        tracker = (setting.GetValue() == setting.GetValue(true)) ? CheckState::On : CheckState::Off;
+    }
+    SetHighlight(checkbox, tracker != CheckState::Global);
+    QObject::connect(checkbox, &QCheckBox::clicked, checkbox, [checkbox, setting, &tracker] {
+        tracker = static_cast<CheckState>((static_cast<int>(tracker) + 1) %
+                                          static_cast<int>(CheckState::Count));
+        if (tracker == CheckState::Global) {
+            checkbox->setChecked(setting.GetValue(true));
+        }
+        SetHighlight(checkbox, tracker != CheckState::Global);
+    });
+}
+
+void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox, bool global, bool state,
+                                             bool global_state, CheckState& tracker) {
+    if (global) {
+        tracker = CheckState::Global;
+    } else {
+        tracker = (state == global_state) ? CheckState::On : CheckState::Off;
+    }
+    SetHighlight(checkbox, tracker != CheckState::Global);
+    QObject::connect(checkbox, &QCheckBox::clicked, checkbox, [checkbox, global_state, &tracker] {
+        tracker = static_cast<CheckState>((static_cast<int>(tracker) + 1) %
+                                          static_cast<int>(CheckState::Count));
+        if (tracker == CheckState::Global) {
+            checkbox->setChecked(global_state);
+        }
+        SetHighlight(checkbox, tracker != CheckState::Global);
+    });
+}
+
+void ConfigurationShared::SetColoredComboBox(QComboBox* combobox, QWidget* target, int global) {
+    InsertGlobalItem(combobox, global);
+    QObject::connect(combobox, qOverload<int>(&QComboBox::activated), target,
+                     [target](int index) { SetHighlight(target, index != 0); });
+}
+
+void ConfigurationShared::InsertGlobalItem(QComboBox* combobox, int global_index) {
+    const QString use_global_text =
+        ConfigurePerGame::tr("Use global configuration (%1)").arg(combobox->itemText(global_index));
+    combobox->insertItem(ConfigurationShared::USE_GLOBAL_INDEX, use_global_text);
+    combobox->insertSeparator(ConfigurationShared::USE_GLOBAL_SEPARATOR_INDEX);
+}
+
+int ConfigurationShared::GetComboboxIndex(int global_setting_index, const QComboBox* combobox) {
+    if (Settings::IsConfiguringGlobal()) {
+        return combobox->currentIndex();
+    }
+    if (combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+        return global_setting_index;
+    }
+    return combobox->currentIndex() - ConfigurationShared::USE_GLOBAL_OFFSET;
+}

src/yuzu/configuration/configuration_shared.h

@@ -3,25 +3,73 @@
 
 #pragma once
 
-#include <memory>
-#include <vector>
-#include <QString>
-#include <QWidget>
-#include <qobjectdefs.h>
-
-class QObject;
+#include <QCheckBox>
+#include <QComboBox>
+#include "common/settings.h"
 
 namespace ConfigurationShared {
 
-class Tab : public QWidget {
-    Q_OBJECT
+constexpr int USE_GLOBAL_INDEX = 0;
+constexpr int USE_GLOBAL_SEPARATOR_INDEX = 1;
+constexpr int USE_GLOBAL_OFFSET = 2;
 
-public:
-    explicit Tab(std::shared_ptr<std::vector<Tab*>> group, QWidget* parent = nullptr);
-    ~Tab();
-
-    virtual void ApplyConfiguration() = 0;
-    virtual void SetConfiguration() = 0;
+// CheckBoxes require a tracker for their state since we emulate a tristate CheckBox
+enum class CheckState {
+    Off,    // Checkbox overrides to off/false
+    On,     // Checkbox overrides to on/true
+    Global, // Checkbox defers to the global state
+    Count,  // Simply the number of states, not a valid checkbox state
 };
 
+// Global-aware apply and set functions
+
+// ApplyPerGameSetting, given a Settings::Setting and a Qt UI element, properly applies a Setting
+void ApplyPerGameSetting(Settings::SwitchableSetting<bool>* setting, const QCheckBox* checkbox,
+                         const CheckState& tracker);
+template <typename Type, bool ranged>
+void ApplyPerGameSetting(Settings::SwitchableSetting<Type, ranged>* setting,
+                         const QComboBox* combobox) {
+    if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) {
+        setting->SetValue(static_cast<Type>(combobox->currentIndex()));
+    } else if (!Settings::IsConfiguringGlobal()) {
+        if (combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            setting->SetGlobal(true);
+        } else {
+            setting->SetGlobal(false);
+            setting->SetValue(static_cast<Type>(combobox->currentIndex() -
+                                                ConfigurationShared::USE_GLOBAL_OFFSET));
+        }
+    }
+}
+
+// Sets a Qt UI element given a Settings::Setting
+void SetPerGameSetting(QCheckBox* checkbox, const Settings::SwitchableSetting<bool>* setting);
+
+template <typename Type, bool ranged>
+void SetPerGameSetting(QComboBox* combobox,
+                       const Settings::SwitchableSetting<Type, ranged>* setting) {
+    combobox->setCurrentIndex(setting->UsingGlobal() ? ConfigurationShared::USE_GLOBAL_INDEX
+                                                     : static_cast<int>(setting->GetValue()) +
+                                                           ConfigurationShared::USE_GLOBAL_OFFSET);
+}
+
+// (Un)highlights a Qt UI element
+void SetHighlight(QWidget* widget, bool highlighted);
+
+// Sets up a QCheckBox like a tristate one, given a Setting
+void SetColoredTristate(QCheckBox* checkbox, const Settings::SwitchableSetting<bool>& setting,
+                        CheckState& tracker);
+void SetColoredTristate(QCheckBox* checkbox, bool global, bool state, bool global_state,
+                        CheckState& tracker);
+
+// Sets up coloring of a QWidget `target` based on the state of a QComboBox, and calls
+// InsertGlobalItem
+void SetColoredComboBox(QComboBox* combobox, QWidget* target, int global);
+
+// Adds the "Use Global Configuration" selection and separator to the beginning of a QComboBox
+void InsertGlobalItem(QComboBox* combobox, int global_index);
+
+// Returns the correct index of a QComboBox taking into account global configuration
+int GetComboboxIndex(int global_setting_index, const QComboBox* combobox);
+
 } // namespace ConfigurationShared

src/yuzu/configuration/configure.ui

@@ -47,27 +47,6 @@
      </item>
     </layout>
    </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout_2">
-     <property name="leftMargin">
-      <number>0</number>
-     </property>
-     <property name="topMargin">
-      <number>0</number>
-     </property>
-     <property name="rightMargin">
-      <number>0</number>
-     </property>
-     <property name="bottomMargin">
-      <number>0</number>
-     </property>
-     <item>
-      <widget class="QLabel" name="label">
-       <property name="text">
-        <string>Some settings are only available when a game is not running.</string>
-       </property>
-      </widget>
-     </item>
    <item>
     <widget class="QDialogButtonBox" name="buttonBox">
      <property name="standardButtons">
@@ -76,8 +55,6 @@
     </widget>
    </item>
   </layout>
-   </item>
-  </layout>
  </widget>
  <resources/>
  <connections>

src/yuzu/configuration/configure_audio.cpp

@@ -1,112 +1,87 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <map>
 #include <memory>
-#include <vector>
-#include <QComboBox>
 
 #include "audio_core/sink/sink.h"
 #include "audio_core/sink/sink_details.h"
-#include "common/common_types.h"
 #include "common/settings.h"
-#include "common/settings_common.h"
 #include "core/core.h"
 #include "ui_configure_audio.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_audio.h"
-#include "yuzu/configuration/shared_translation.h"
-#include "yuzu/configuration/shared_widget.h"
 #include "yuzu/uisettings.h"
 
-ConfigureAudio::ConfigureAudio(const Core::System& system_,
-                               std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group_,
-                               const ConfigurationShared::Builder& builder, QWidget* parent)
-    : Tab(group_, parent), ui(std::make_unique<Ui::ConfigureAudio>()), system{system_} {
+ConfigureAudio::ConfigureAudio(const Core::System& system_, QWidget* parent)
+    : QWidget(parent), ui(std::make_unique<Ui::ConfigureAudio>()), system{system_} {
     ui->setupUi(this);
-    Setup(builder);
+
+    InitializeAudioSinkComboBox();
+
+    connect(ui->volume_slider, &QSlider::valueChanged, this,
+            &ConfigureAudio::SetVolumeIndicatorText);
+    connect(ui->sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
+            &ConfigureAudio::UpdateAudioDevices);
+
+    ui->volume_label->setVisible(Settings::IsConfiguringGlobal());
+    ui->volume_combo_box->setVisible(!Settings::IsConfiguringGlobal());
+
+    SetupPerGameUI();
 
     SetConfiguration();
+
+    const bool is_powered_on = system_.IsPoweredOn();
+    ui->sink_combo_box->setEnabled(!is_powered_on);
+    ui->output_combo_box->setEnabled(!is_powered_on);
+    ui->input_combo_box->setEnabled(!is_powered_on);
 }
 
 ConfigureAudio::~ConfigureAudio() = default;
 
-void ConfigureAudio::Setup(const ConfigurationShared::Builder& builder) {
-    auto& layout = *ui->audio_widget->layout();
-
-    std::vector<Settings::BasicSetting*> settings;
-
-    std::map<u32, QWidget*> hold;
-
-    auto push = [&](Settings::Category category) {
-        for (auto* setting : Settings::values.linkage.by_category[category]) {
-            settings.push_back(setting);
-        }
-    };
-
-    push(Settings::Category::Audio);
-    push(Settings::Category::SystemAudio);
-
-    for (auto* setting : settings) {
-        auto* widget = builder.BuildWidget(setting, apply_funcs);
-
-        if (widget == nullptr) {
-            continue;
-        }
-        if (!widget->Valid()) {
-            widget->deleteLater();
-            continue;
-        }
-
-        hold.emplace(std::pair{setting->Id(), widget});
-
-        if (setting->Id() == Settings::values.sink_id.Id()) {
-            // TODO (lat9nq): Let the system manage sink_id
-            sink_combo_box = widget->combobox;
-            InitializeAudioSinkComboBox();
-
-            connect(sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
-                    &ConfigureAudio::UpdateAudioDevices);
-        } else if (setting->Id() == Settings::values.audio_output_device_id.Id()) {
-            // Keep track of output (and input) device comboboxes to populate them with system
-            // devices, which are determined at run time
-            output_device_combo_box = widget->combobox;
-        } else if (setting->Id() == Settings::values.audio_input_device_id.Id()) {
-            input_device_combo_box = widget->combobox;
-        }
-    }
-
-    for (const auto& [id, widget] : hold) {
-        layout.addWidget(widget);
-    }
-}
-
 void ConfigureAudio::SetConfiguration() {
-    if (!Settings::IsConfiguringGlobal()) {
-        return;
-    }
-
     SetOutputSinkFromSinkID();
 
     // The device list cannot be pre-populated (nor listed) until the output sink is known.
-    UpdateAudioDevices(sink_combo_box->currentIndex());
+    UpdateAudioDevices(ui->sink_combo_box->currentIndex());
 
     SetAudioDevicesFromDeviceID();
+
+    const auto volume_value = static_cast<int>(Settings::values.volume.GetValue());
+    ui->volume_slider->setValue(volume_value);
+    ui->toggle_background_mute->setChecked(UISettings::values.mute_when_in_background.GetValue());
+
+    if (!Settings::IsConfiguringGlobal()) {
+        if (Settings::values.volume.UsingGlobal()) {
+            ui->volume_combo_box->setCurrentIndex(0);
+            ui->volume_slider->setEnabled(false);
+        } else {
+            ui->volume_combo_box->setCurrentIndex(1);
+            ui->volume_slider->setEnabled(true);
+        }
+        ConfigurationShared::SetPerGameSetting(ui->combo_sound, &Settings::values.sound_index);
+        ConfigurationShared::SetHighlight(ui->mode_label,
+                                          !Settings::values.sound_index.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->volume_layout,
+                                          !Settings::values.volume.UsingGlobal());
+    } else {
+        ui->combo_sound->setCurrentIndex(Settings::values.sound_index.GetValue());
+    }
+    SetVolumeIndicatorText(ui->volume_slider->sliderPosition());
 }
 
 void ConfigureAudio::SetOutputSinkFromSinkID() {
-    [[maybe_unused]] const QSignalBlocker blocker(sink_combo_box);
+    [[maybe_unused]] const QSignalBlocker blocker(ui->sink_combo_box);
 
     int new_sink_index = 0;
-    const QString sink_id = QString::fromStdString(Settings::values.sink_id.ToString());
-    for (int index = 0; index < sink_combo_box->count(); index++) {
-        if (sink_combo_box->itemText(index) == sink_id) {
+    const QString sink_id = QString::fromStdString(Settings::values.sink_id.GetValue());
+    for (int index = 0; index < ui->sink_combo_box->count(); index++) {
+        if (ui->sink_combo_box->itemText(index) == sink_id) {
             new_sink_index = index;
             break;
         }
     }
 
-    sink_combo_box->setCurrentIndex(new_sink_index);
+    ui->sink_combo_box->setCurrentIndex(new_sink_index);
 }
 
 void ConfigureAudio::SetAudioDevicesFromDeviceID() {
@@ -114,42 +89,57 @@ void ConfigureAudio::SetAudioDevicesFromDeviceID() {
 
     const QString output_device_id =
         QString::fromStdString(Settings::values.audio_output_device_id.GetValue());
-    for (int index = 0; index < output_device_combo_box->count(); index++) {
-        if (output_device_combo_box->itemText(index) == output_device_id) {
+    for (int index = 0; index < ui->output_combo_box->count(); index++) {
+        if (ui->output_combo_box->itemText(index) == output_device_id) {
             new_device_index = index;
             break;
         }
     }
 
-    output_device_combo_box->setCurrentIndex(new_device_index);
+    ui->output_combo_box->setCurrentIndex(new_device_index);
 
     new_device_index = -1;
     const QString input_device_id =
         QString::fromStdString(Settings::values.audio_input_device_id.GetValue());
-    for (int index = 0; index < input_device_combo_box->count(); index++) {
-        if (input_device_combo_box->itemText(index) == input_device_id) {
+    for (int index = 0; index < ui->input_combo_box->count(); index++) {
+        if (ui->input_combo_box->itemText(index) == input_device_id) {
             new_device_index = index;
             break;
         }
     }
 
-    input_device_combo_box->setCurrentIndex(new_device_index);
+    ui->input_combo_box->setCurrentIndex(new_device_index);
+}
+
+void ConfigureAudio::SetVolumeIndicatorText(int percentage) {
+    ui->volume_indicator->setText(tr("%1%", "Volume percentage (e.g. 50%)").arg(percentage));
 }
 
 void ConfigureAudio::ApplyConfiguration() {
-    const bool is_powered_on = system.IsPoweredOn();
-    for (const auto& apply_func : apply_funcs) {
-        apply_func(is_powered_on);
-    }
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.sound_index, ui->combo_sound);
 
     if (Settings::IsConfiguringGlobal()) {
-        Settings::values.sink_id.LoadString(
-            sink_combo_box->itemText(sink_combo_box->currentIndex()).toStdString());
+        Settings::values.sink_id =
+            ui->sink_combo_box->itemText(ui->sink_combo_box->currentIndex()).toStdString();
         Settings::values.audio_output_device_id.SetValue(
-            output_device_combo_box->itemText(output_device_combo_box->currentIndex())
-                .toStdString());
+            ui->output_combo_box->itemText(ui->output_combo_box->currentIndex()).toStdString());
         Settings::values.audio_input_device_id.SetValue(
-            input_device_combo_box->itemText(input_device_combo_box->currentIndex()).toStdString());
+            ui->input_combo_box->itemText(ui->input_combo_box->currentIndex()).toStdString());
+        UISettings::values.mute_when_in_background = ui->toggle_background_mute->isChecked();
+
+        // Guard if during game and set to game-specific value
+        if (Settings::values.volume.UsingGlobal()) {
+            const auto volume = static_cast<u8>(ui->volume_slider->value());
+            Settings::values.volume.SetValue(volume);
+        }
+    } else {
+        if (ui->volume_combo_box->currentIndex() == 0) {
+            Settings::values.volume.SetGlobal(true);
+        } else {
+            Settings::values.volume.SetGlobal(false);
+            const auto volume = static_cast<u8>(ui->volume_slider->value());
+            Settings::values.volume.SetValue(volume);
+        }
     }
 }
 
@@ -162,31 +152,54 @@ void ConfigureAudio::changeEvent(QEvent* event) {
 }
 
 void ConfigureAudio::UpdateAudioDevices(int sink_index) {
-    output_device_combo_box->clear();
-    output_device_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
+    ui->output_combo_box->clear();
+    ui->output_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
 
-    const auto sink_id =
-        Settings::ToEnum<Settings::AudioEngine>(sink_combo_box->itemText(sink_index).toStdString());
+    const std::string sink_id = ui->sink_combo_box->itemText(sink_index).toStdString();
     for (const auto& device : AudioCore::Sink::GetDeviceListForSink(sink_id, false)) {
-        output_device_combo_box->addItem(QString::fromStdString(device));
+        ui->output_combo_box->addItem(QString::fromStdString(device));
     }
 
-    input_device_combo_box->clear();
-    input_device_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
+    ui->input_combo_box->clear();
+    ui->input_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
     for (const auto& device : AudioCore::Sink::GetDeviceListForSink(sink_id, true)) {
-        input_device_combo_box->addItem(QString::fromStdString(device));
+        ui->input_combo_box->addItem(QString::fromStdString(device));
     }
 }
 
 void ConfigureAudio::InitializeAudioSinkComboBox() {
-    sink_combo_box->clear();
-    sink_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
+    ui->sink_combo_box->clear();
+    ui->sink_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
 
     for (const auto& id : AudioCore::Sink::GetSinkIDs()) {
-        sink_combo_box->addItem(QString::fromStdString(Settings::CanonicalizeEnum(id)));
+        ui->sink_combo_box->addItem(QString::fromUtf8(id.data(), static_cast<s32>(id.length())));
     }
 }
 
 void ConfigureAudio::RetranslateUI() {
     ui->retranslateUi(this);
+    SetVolumeIndicatorText(ui->volume_slider->sliderPosition());
+}
+
+void ConfigureAudio::SetupPerGameUI() {
+    if (Settings::IsConfiguringGlobal()) {
+        ui->combo_sound->setEnabled(Settings::values.sound_index.UsingGlobal());
+        ui->volume_slider->setEnabled(Settings::values.volume.UsingGlobal());
+        return;
+    }
+
+    ConfigurationShared::SetColoredComboBox(ui->combo_sound, ui->mode_label,
+                                            Settings::values.sound_index.GetValue(true));
+
+    connect(ui->volume_combo_box, qOverload<int>(&QComboBox::activated), this, [this](int index) {
+        ui->volume_slider->setEnabled(index == 1);
+        ConfigurationShared::SetHighlight(ui->volume_layout, index == 1);
+    });
+
+    ui->sink_combo_box->setVisible(false);
+    ui->sink_label->setVisible(false);
+    ui->output_combo_box->setVisible(false);
+    ui->output_label->setVisible(false);
+    ui->input_combo_box->setVisible(false);
+    ui->input_label->setVisible(false);
 }

src/yuzu/configuration/configure_audio.h

@@ -3,35 +3,30 @@
 
 #pragma once
 
-#include <functional>
 #include <memory>
-#include <vector>
 #include <QWidget>
-#include "yuzu/configuration/configuration_shared.h"
-
-class QComboBox;
 
 namespace Core {
 class System;
 }
 
+namespace ConfigurationShared {
+enum class CheckState;
+}
+
 namespace Ui {
 class ConfigureAudio;
 }
 
-namespace ConfigurationShared {
-class Builder;
-}
+class ConfigureAudio : public QWidget {
+    Q_OBJECT
 
-class ConfigureAudio : public ConfigurationShared::Tab {
 public:
-    explicit ConfigureAudio(const Core::System& system_,
-                            std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group,
-                            const ConfigurationShared::Builder& builder, QWidget* parent = nullptr);
+    explicit ConfigureAudio(const Core::System& system_, QWidget* parent = nullptr);
     ~ConfigureAudio() override;
 
-    void ApplyConfiguration() override;
-    void SetConfiguration() override;
+    void ApplyConfiguration();
+    void SetConfiguration();
 
 private:
     void changeEvent(QEvent* event) override;
@@ -44,16 +39,11 @@ private:
 
     void SetOutputSinkFromSinkID();
     void SetAudioDevicesFromDeviceID();
+    void SetVolumeIndicatorText(int percentage);
 
-    void Setup(const ConfigurationShared::Builder& builder);
+    void SetupPerGameUI();
 
     std::unique_ptr<Ui::ConfigureAudio> ui;
 
     const Core::System& system;
-
-    std::vector<std::function<void(bool)>> apply_funcs{};
-
-    QComboBox* sink_combo_box;
-    QComboBox* output_device_combo_box;
-    QComboBox* input_device_combo_box;
 };

src/yuzu/configuration/configure_audio.ui

@@ -21,14 +21,80 @@
      </property>
      <layout class="QVBoxLayout">
       <item>
-       <widget class="QWidget" name="audio_widget" native="true">
-        <property name="maximumSize">
-         <size>
-          <width>16777215</width>
-          <height>16777213</height>
-         </size>
+       <layout class="QHBoxLayout" name="engine_layout">
+        <item>
+         <widget class="QLabel" name="sink_label">
+          <property name="text">
+           <string>Output Engine:</string>
           </property>
-        <layout class="QVBoxLayout" name="verticalLayout">
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="sink_combo_box"/>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="output_layout">
+        <item>
+         <widget class="QLabel" name="output_label">
+          <property name="text">
+           <string>Output Device:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="output_combo_box"/>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="input_layout">
+        <item>
+         <widget class="QLabel" name="input_label">
+          <property name="text">
+           <string>Input Device:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="input_combo_box"/>
+        </item>
+       </layout>
+      </item>
+       <item>
+       <layout class="QHBoxLayout" name="mode_layout">
+        <item>
+         <widget class="QLabel" name="mode_label">
+          <property name="text">
+           <string>Sound Output Mode:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+          <widget class="QComboBox" name="combo_sound">
+            <item>
+              <property name="text">
+                <string>Mono</string>
+              </property>
+            </item>
+            <item>
+              <property name="text">
+                <string>Stereo</string>
+              </property>
+            </item>
+            <item>
+              <property name="text">
+                <string>Surround</string>
+              </property>
+            </item>
+          </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <widget class="QWidget" name="volume_layout" native="true">
+        <layout class="QHBoxLayout" name="horizontalLayout_2">
          <property name="leftMargin">
           <number>0</number>
          </property>
@@ -41,9 +107,89 @@
          <property name="bottomMargin">
           <number>0</number>
          </property>
+         <item>
+          <widget class="QComboBox" name="volume_combo_box">
+           <item>
+            <property name="text">
+             <string>Use global volume</string>
+            </property>
+           </item>
+           <item>
+            <property name="text">
+             <string>Set volume:</string>
+            </property>
+           </item>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLabel" name="volume_label">
+           <property name="text">
+            <string>Volume:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <spacer name="horizontalSpacer">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>30</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QSlider" name="volume_slider">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="maximum">
+            <number>200</number>
+           </property>
+           <property name="pageStep">
+            <number>5</number>
+           </property>
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLabel" name="volume_indicator">
+           <property name="minimumSize">
+            <size>
+             <width>32</width>
+             <height>0</height>
+            </size>
+           </property>
+           <property name="text">
+            <string>0 %</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignCenter</set>
+           </property>
+          </widget>
+         </item>
         </layout>
        </widget>
       </item>
+      <item>
+       <layout class="QHBoxLayout" name="mute_layout">
+         <item>
+           <widget class="QCheckBox" name="toggle_background_mute">
+             <property name="text">
+               <string>Mute audio when in background</string>
+             </property>
+           </widget>
+         </item>
+       </layout>
+      </item>
      </layout>
     </widget>
    </item>

src/yuzu/configuration/configure_cpu.cpp

@@ -1,92 +1,88 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <memory>
-#include <typeinfo>
-#include <vector>
-#include <QComboBox>
 #include "common/common_types.h"
 #include "common/settings.h"
-#include "common/settings_enums.h"
-#include "configuration/shared_widget.h"
 #include "core/core.h"
 #include "ui_configure_cpu.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_cpu.h"
 
-ConfigureCpu::ConfigureCpu(const Core::System& system_,
-                           std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group_,
-                           const ConfigurationShared::Builder& builder, QWidget* parent)
-    : Tab(group_, parent), ui{std::make_unique<Ui::ConfigureCpu>()}, system{system_},
-      combobox_translations(builder.ComboboxTranslations()) {
+ConfigureCpu::ConfigureCpu(const Core::System& system_, QWidget* parent)
+    : QWidget(parent), ui{std::make_unique<Ui::ConfigureCpu>()}, system{system_} {
     ui->setupUi(this);
 
-    Setup(builder);
+    SetupPerGameUI();
 
     SetConfiguration();
 
-    connect(accuracy_combobox, qOverload<int>(&QComboBox::currentIndexChanged), this,
+    connect(ui->accuracy, qOverload<int>(&QComboBox::currentIndexChanged), this,
             &ConfigureCpu::UpdateGroup);
 }
 
 ConfigureCpu::~ConfigureCpu() = default;
 
-void ConfigureCpu::SetConfiguration() {}
-void ConfigureCpu::Setup(const ConfigurationShared::Builder& builder) {
-    auto* accuracy_layout = ui->widget_accuracy->layout();
-    auto* unsafe_layout = ui->unsafe_widget->layout();
-    std::map<u32, QWidget*> unsafe_hold{};
+void ConfigureCpu::SetConfiguration() {
+    const bool runtime_lock = !system.IsPoweredOn();
 
-    std::vector<Settings::BasicSetting*> settings;
-    const auto push = [&](Settings::Category category) {
-        for (const auto setting : Settings::values.linkage.by_category[category]) {
-            settings.push_back(setting);
-        }
-    };
+    ui->accuracy->setEnabled(runtime_lock);
+    ui->cpuopt_unsafe_unfuse_fma->setEnabled(runtime_lock);
+    ui->cpuopt_unsafe_reduce_fp_error->setEnabled(runtime_lock);
+    ui->cpuopt_unsafe_ignore_standard_fpcr->setEnabled(runtime_lock);
+    ui->cpuopt_unsafe_inaccurate_nan->setEnabled(runtime_lock);
+    ui->cpuopt_unsafe_fastmem_check->setEnabled(runtime_lock);
+    ui->cpuopt_unsafe_ignore_global_monitor->setEnabled(runtime_lock);
 
-    push(Settings::Category::Cpu);
-    push(Settings::Category::CpuUnsafe);
+    ui->cpuopt_unsafe_unfuse_fma->setChecked(Settings::values.cpuopt_unsafe_unfuse_fma.GetValue());
+    ui->cpuopt_unsafe_reduce_fp_error->setChecked(
+        Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue());
+    ui->cpuopt_unsafe_ignore_standard_fpcr->setChecked(
+        Settings::values.cpuopt_unsafe_ignore_standard_fpcr.GetValue());
+    ui->cpuopt_unsafe_inaccurate_nan->setChecked(
+        Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue());
+    ui->cpuopt_unsafe_fastmem_check->setChecked(
+        Settings::values.cpuopt_unsafe_fastmem_check.GetValue());
+    ui->cpuopt_unsafe_ignore_global_monitor->setChecked(
+        Settings::values.cpuopt_unsafe_ignore_global_monitor.GetValue());
 
-    for (const auto setting : settings) {
-        auto* widget = builder.BuildWidget(setting, apply_funcs);
-
-        if (widget == nullptr) {
-            continue;
-        }
-        if (!widget->Valid()) {
-            widget->deleteLater();
-            continue;
-        }
-
-        if (setting->Id() == Settings::values.cpu_accuracy.Id()) {
-            // Keep track of cpu_accuracy combobox to display/hide the unsafe settings
-            accuracy_layout->addWidget(widget);
-            accuracy_combobox = widget->combobox;
+    if (Settings::IsConfiguringGlobal()) {
+        ui->accuracy->setCurrentIndex(static_cast<int>(Settings::values.cpu_accuracy.GetValue()));
     } else {
-            // Presently, all other settings here are unsafe checkboxes
-            unsafe_hold.insert({setting->Id(), widget});
+        ConfigurationShared::SetPerGameSetting(ui->accuracy, &Settings::values.cpu_accuracy);
+        ConfigurationShared::SetHighlight(ui->widget_accuracy,
+                                          !Settings::values.cpu_accuracy.UsingGlobal());
     }
-    }
-
-    for (const auto& [label, widget] : unsafe_hold) {
-        unsafe_layout->addWidget(widget);
-    }
-
-    UpdateGroup(accuracy_combobox->currentIndex());
+    UpdateGroup(ui->accuracy->currentIndex());
 }
 
 void ConfigureCpu::UpdateGroup(int index) {
-    const auto accuracy = static_cast<Settings::CpuAccuracy>(
-        combobox_translations.at(Settings::EnumMetadata<Settings::CpuAccuracy>::Index())[index]
-            .first);
-    ui->unsafe_group->setVisible(accuracy == Settings::CpuAccuracy::Unsafe);
+    if (!Settings::IsConfiguringGlobal()) {
+        index -= ConfigurationShared::USE_GLOBAL_OFFSET;
+    }
+    const auto accuracy = static_cast<Settings::CPUAccuracy>(index);
+    ui->unsafe_group->setVisible(accuracy == Settings::CPUAccuracy::Unsafe);
 }
 
 void ConfigureCpu::ApplyConfiguration() {
-    const bool is_powered_on = system.IsPoweredOn();
-    for (const auto& apply_func : apply_funcs) {
-        apply_func(is_powered_on);
-    }
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpu_accuracy, ui->accuracy);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_unfuse_fma,
+                                             ui->cpuopt_unsafe_unfuse_fma,
+                                             cpuopt_unsafe_unfuse_fma);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_reduce_fp_error,
+                                             ui->cpuopt_unsafe_reduce_fp_error,
+                                             cpuopt_unsafe_reduce_fp_error);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_ignore_standard_fpcr,
+                                             ui->cpuopt_unsafe_ignore_standard_fpcr,
+                                             cpuopt_unsafe_ignore_standard_fpcr);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_inaccurate_nan,
+                                             ui->cpuopt_unsafe_inaccurate_nan,
+                                             cpuopt_unsafe_inaccurate_nan);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_fastmem_check,
+                                             ui->cpuopt_unsafe_fastmem_check,
+                                             cpuopt_unsafe_fastmem_check);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_ignore_global_monitor,
+                                             ui->cpuopt_unsafe_ignore_global_monitor,
+                                             cpuopt_unsafe_ignore_global_monitor);
 }
 
 void ConfigureCpu::changeEvent(QEvent* event) {
@@ -100,3 +96,32 @@ void ConfigureCpu::changeEvent(QEvent* event) {
 void ConfigureCpu::RetranslateUI() {
     ui->retranslateUi(this);
 }
+
+void ConfigureCpu::SetupPerGameUI() {
+    if (Settings::IsConfiguringGlobal()) {
+        return;
+    }
+
+    ConfigurationShared::SetColoredComboBox(
+        ui->accuracy, ui->widget_accuracy,
+        static_cast<u32>(Settings::values.cpu_accuracy.GetValue(true)));
+
+    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_unfuse_fma,
+                                            Settings::values.cpuopt_unsafe_unfuse_fma,
+                                            cpuopt_unsafe_unfuse_fma);
+    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_reduce_fp_error,
+                                            Settings::values.cpuopt_unsafe_reduce_fp_error,
+                                            cpuopt_unsafe_reduce_fp_error);
+    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_ignore_standard_fpcr,
+                                            Settings::values.cpuopt_unsafe_ignore_standard_fpcr,
+                                            cpuopt_unsafe_ignore_standard_fpcr);
+    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_inaccurate_nan,
+                                            Settings::values.cpuopt_unsafe_inaccurate_nan,
+                                            cpuopt_unsafe_inaccurate_nan);
+    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_fastmem_check,
+                                            Settings::values.cpuopt_unsafe_fastmem_check,
+                                            cpuopt_unsafe_fastmem_check);
+    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_ignore_global_monitor,
+                                            Settings::values.cpuopt_unsafe_ignore_global_monitor,
+                                            cpuopt_unsafe_ignore_global_monitor);
+}

src/yuzu/configuration/configure_cpu.h

@@ -4,34 +4,29 @@
 #pragma once
 
 #include <memory>
-#include <vector>
 #include <QWidget>
-#include "yuzu/configuration/configuration_shared.h"
-#include "yuzu/configuration/shared_translation.h"
-
-class QComboBox;
 
 namespace Core {
 class System;
 }
 
+namespace ConfigurationShared {
+enum class CheckState;
+}
+
 namespace Ui {
 class ConfigureCpu;
 }
 
-namespace ConfigurationShared {
-class Builder;
-}
+class ConfigureCpu : public QWidget {
+    Q_OBJECT
 
-class ConfigureCpu : public ConfigurationShared::Tab {
 public:
-    explicit ConfigureCpu(const Core::System& system_,
-                          std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group,
-                          const ConfigurationShared::Builder& builder, QWidget* parent = nullptr);
+    explicit ConfigureCpu(const Core::System& system_, QWidget* parent = nullptr);
     ~ConfigureCpu() override;
 
-    void ApplyConfiguration() override;
-    void SetConfiguration() override;
+    void ApplyConfiguration();
+    void SetConfiguration();
 
 private:
     void changeEvent(QEvent* event) override;
@@ -39,14 +34,16 @@ private:
 
     void UpdateGroup(int index);
 
-    void Setup(const ConfigurationShared::Builder& builder);
+    void SetupPerGameUI();
 
     std::unique_ptr<Ui::ConfigureCpu> ui;
 
+    ConfigurationShared::CheckState cpuopt_unsafe_unfuse_fma;
+    ConfigurationShared::CheckState cpuopt_unsafe_reduce_fp_error;
+    ConfigurationShared::CheckState cpuopt_unsafe_ignore_standard_fpcr;
+    ConfigurationShared::CheckState cpuopt_unsafe_inaccurate_nan;
+    ConfigurationShared::CheckState cpuopt_unsafe_fastmem_check;
+    ConfigurationShared::CheckState cpuopt_unsafe_ignore_global_monitor;
+
     const Core::System& system;
-
-    const ConfigurationShared::ComboboxTranslationMap& combobox_translations;
-    std::vector<std::function<void(bool)>> apply_funcs{};
-
-    QComboBox* accuracy_combobox;
 };

src/yuzu/configuration/configure_cpu.ui

@@ -16,12 +16,9 @@
   <property name="accessibleName">
    <string>CPU</string>
   </property>
-  <layout class="QVBoxLayout" name="vboxlayout_2" stretch="0">
+  <layout class="QVBoxLayout">
    <item>
-    <layout class="QVBoxLayout" name="vboxlayout">
-     <property name="bottomMargin">
-      <number>0</number>
-     </property>
+    <layout class="QVBoxLayout">
      <item>
       <widget class="QGroupBox" name="groupBox">
        <property name="title">
@@ -30,19 +27,38 @@
        <layout class="QVBoxLayout">
         <item>
          <widget class="QWidget" name="widget_accuracy" native="true">
-          <layout class="QVBoxLayout" name="verticalLayout">
-           <property name="leftMargin">
-            <number>0</number>
+          <layout class="QHBoxLayout" name="layout_accuracy">
+           <item>
+            <widget class="QLabel" name="label_accuracy">
+             <property name="text">
+              <string>Accuracy:</string>
              </property>
-           <property name="topMargin">
-            <number>0</number>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="accuracy">
+             <item>
+              <property name="text">
+               <string>Auto</string>
               </property>
-           <property name="rightMargin">
-            <number>0</number>
+             </item>
+             <item>
+              <property name="text">
+               <string>Accurate</string>
               </property>
-           <property name="bottomMargin">
-            <number>0</number>
+             </item>
+             <item>
+              <property name="text">
+               <string>Unsafe</string>
               </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Paranoid (disables most optimizations)</string>
+              </property>
+             </item>
+            </widget>
+           </item>
           </layout>
          </widget>
         </item>
@@ -59,6 +75,10 @@
        </layout>
       </widget>
      </item>
+    </layout>
+   </item>
+   <item>
+    <layout class="QVBoxLayout">
      <item>
       <widget class="QGroupBox" name="unsafe_group">
        <property name="title">
@@ -76,34 +96,87 @@
          </widget>
         </item>
         <item>
-         <widget class="QWidget" name="unsafe_widget" native="true">
-          <layout class="QVBoxLayout" name="unsafe_layout">
-           <property name="leftMargin">
-            <number>0</number>
+         <widget class="QCheckBox" name="cpuopt_unsafe_unfuse_fma">
+          <property name="toolTip">
+           <string>
+            &lt;div&gt;This option improves speed by reducing accuracy of fused-multiply-add instructions on CPUs without native FMA support.&lt;/div&gt;
+           </string>
           </property>
-           <property name="topMargin">
-            <number>0</number>
+          <property name="text">
+           <string>Unfuse FMA (improve performance on CPUs without FMA)</string>
           </property>
-           <property name="rightMargin">
-            <number>0</number>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="cpuopt_unsafe_reduce_fp_error">
+          <property name="toolTip">
+           <string>
+            &lt;div&gt;This option improves the speed of some approximate floating-point functions by using less accurate native approximations.&lt;/div&gt;
+           </string>
           </property>
-           <property name="bottomMargin">
-            <number>0</number>
+          <property name="text">
+           <string>Faster FRSQRTE and FRECPE</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="cpuopt_unsafe_ignore_standard_fpcr">
+          <property name="toolTip">
+           <string>
+            &lt;div&gt;This option improves the speed of 32 bits ASIMD floating-point functions by running with incorrect rounding modes.&lt;/div&gt;
+           </string>
+          </property>
+          <property name="text">
+           <string>Faster ASIMD instructions (32 bits only)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="cpuopt_unsafe_inaccurate_nan">
+          <property name="toolTip">
+           <string>
+            &lt;div&gt;This option improves speed by removing NaN checking. Please note this also reduces accuracy of certain floating-point instructions.&lt;/div&gt;
+           </string>
+          </property>
+          <property name="text">
+           <string>Inaccurate NaN handling</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="cpuopt_unsafe_fastmem_check">
+          <property name="toolTip">
+           <string>
+            &lt;div&gt;This option improves speed by eliminating a safety check before every memory read/write in guest. Disabling it may allow a game to read/write the emulator's memory.&lt;/div&gt;
+           </string>
+          </property>
+          <property name="text">
+           <string>Disable address space checks</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="cpuopt_unsafe_ignore_global_monitor">
+          <property name="toolTip">
+           <string>
+            &lt;div&gt;This option improves speed by relying only on the semantics of cmpxchg to ensure safety of exclusive access instructions. Please note this may result in deadlocks and other race conditions.&lt;/div&gt;
+           </string>
+          </property>
+          <property name="text">
+           <string>Ignore global monitor</string>
           </property>
-          </layout>
          </widget>
         </item>
        </layout>
       </widget>
      </item>
+    </layout>
+   </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
-       <property name="sizeType">
-        <enum>QSizePolicy::Expanding</enum>
-       </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
@@ -112,7 +185,15 @@
      </property>
     </spacer>
    </item>
-    </layout>
+   <item>
+    <widget class="QLabel" name="label_disable_info">
+     <property name="text">
+      <string>CPU settings are available only when game is not running.</string>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
    </item>
   </layout>
  </widget>

src/yuzu/configuration/configure_debug.ui

@@ -2,119 +2,43 @@
 <ui version="4.0">
  <class>ConfigureDebug</class>
  <widget class="QScrollArea" name="ConfigureDebug">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>831</width>
-    <height>760</height>
-   </rect>
-  </property>
   <property name="widgetResizable">
    <bool>true</bool>
   </property>
-  <widget class="QWidget" name="widget">
-   <property name="geometry">
-    <rect>
-     <x>0</x>
-     <y>0</y>
-     <width>829</width>
-     <height>758</height>
-    </rect>
-   </property>
+ <widget class="QWidget">
   <layout class="QVBoxLayout" name="verticalLayout_1">
    <item>
-     <layout class="QHBoxLayout" name="horizontalLayout">
-      <property name="topMargin">
-       <number>0</number>
-      </property>
+    <layout class="QVBoxLayout" name="verticalLayout_2">
      <item>
       <widget class="QGroupBox" name="groupBox">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
        <property name="title">
         <string>Debugger</string>
        </property>
-        <property name="alignment">
-         <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
-        </property>
-        <property name="flat">
-         <bool>false</bool>
-        </property>
-        <property name="checkable">
-         <bool>false</bool>
-        </property>
        <layout class="QVBoxLayout" name="verticalLayout_3">
         <item>
-          <widget class="QWidget" name="debug_widget" native="true">
-           <property name="sizePolicy">
-            <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
-             <horstretch>0</horstretch>
-             <verstretch>0</verstretch>
-            </sizepolicy>
-           </property>
-           <layout class="QVBoxLayout" name="verticalLayout">
-            <property name="sizeConstraint">
-             <enum>QLayout::SetDefaultConstraint</enum>
-            </property>
-            <property name="leftMargin">
-             <number>0</number>
-            </property>
-            <property name="topMargin">
-             <number>0</number>
-            </property>
-            <property name="rightMargin">
-             <number>0</number>
-            </property>
-            <property name="bottomMargin">
-             <number>0</number>
-            </property>
+         <layout class="QHBoxLayout" name="horizontalLayout_11">
           <item>
            <widget class="QCheckBox" name="toggle_gdbstub">
-              <property name="sizePolicy">
-               <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
-                <horstretch>0</horstretch>
-                <verstretch>0</verstretch>
-               </sizepolicy>
-              </property>
             <property name="text">
              <string>Enable GDB Stub</string>
             </property>
            </widget>
           </item>
           <item>
-             <widget class="QWidget" name="horizontalWidget_3" native="true">
-              <property name="sizePolicy">
-               <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
-                <horstretch>0</horstretch>
-                <verstretch>0</verstretch>
-               </sizepolicy>
+           <spacer name="horizontalSpacer">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
             </property>
-              <layout class="QHBoxLayout" name="horizontalLayout_3">
-               <property name="leftMargin">
-                <number>0</number>
-               </property>
-               <property name="topMargin">
-                <number>0</number>
-               </property>
-               <property name="rightMargin">
-                <number>0</number>
-               </property>
-               <property name="bottomMargin">
-                <number>0</number>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
             </property>
+           </spacer>
+          </item>
           <item>
            <widget class="QLabel" name="label_11">
-                 <property name="sizePolicy">
-                  <sizepolicy hsizetype="Minimum" vsizetype="Maximum">
-                   <horstretch>0</horstretch>
-                   <verstretch>0</verstretch>
-                  </sizepolicy>
-                 </property>
             <property name="text">
              <string>Port:</string>
             </property>
@@ -122,12 +46,6 @@
           </item>
           <item>
            <widget class="QSpinBox" name="gdbport_spinbox">
-                 <property name="sizePolicy">
-                  <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
-                   <horstretch>0</horstretch>
-                   <verstretch>0</verstretch>
-                  </sizepolicy>
-                 </property>
             <property name="minimum">
              <number>1024</number>
             </property>
@@ -137,62 +55,22 @@
            </widget>
           </item>
          </layout>
-             </widget>
         </item>
        </layout>
       </widget>
      </item>
     </layout>
-       </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_2">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
      <property name="title">
       <string>Logging</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_1">
-         <item row="1" column="1">
-          <widget class="QPushButton" name="open_log_button">
-           <property name="text">
-            <string>Open Log Location</string>
-           </property>
-          </widget>
-         </item>
       <item row="0" column="0" colspan="2">
-          <widget class="QWidget" name="logging_widget" native="true">
-           <property name="sizePolicy">
-            <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
-             <horstretch>0</horstretch>
-             <verstretch>0</verstretch>
-            </sizepolicy>
-           </property>
        <layout class="QHBoxLayout" name="horizontalLayout_1">
-            <property name="leftMargin">
-             <number>0</number>
-            </property>
-            <property name="topMargin">
-             <number>0</number>
-            </property>
-            <property name="rightMargin">
-             <number>0</number>
-            </property>
-            <property name="bottomMargin">
-             <number>0</number>
-            </property>
         <item>
          <widget class="QLabel" name="label_1">
-              <property name="sizePolicy">
-               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-                <horstretch>0</horstretch>
-                <verstretch>0</verstretch>
-               </sizepolicy>
-              </property>
           <property name="text">
            <string>Global Log Filter</string>
           </property>
@@ -202,6 +80,19 @@
          <widget class="QLineEdit" name="log_filter_edit"/>
         </item>
        </layout>
+      </item>
+      <item row="1" column="0">
+       <widget class="QCheckBox" name="toggle_console">
+        <property name="text">
+         <string>Show Log in Console</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QPushButton" name="open_log_button">
+        <property name="text">
+         <string>Open Log Location</string>
+        </property>
        </widget>
       </item>
       <item row="2" column="0">
@@ -217,18 +108,9 @@
         </property>
        </widget>
       </item>
-         <item row="1" column="0">
-          <widget class="QCheckBox" name="toggle_console">
-           <property name="text">
-            <string>Show Log in Console</string>
-           </property>
-          </widget>
-         </item>
      </layout>
     </widget>
    </item>
-     </layout>
-    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_3">
      <property name="title">
@@ -252,63 +134,12 @@
      </layout>
     </widget>
    </item>
-    <item>
-     <layout class="QHBoxLayout" name="horizontalLayout_2">
    <item>
     <widget class="QGroupBox" name="groupBox_4">
      <property name="title">
       <string>Graphics</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
-         <item row="3" column="0">
-          <widget class="QCheckBox" name="disable_loop_safety_checks">
-           <property name="toolTip">
-            <string>When checked, it executes shaders without loop logic changes</string>
-           </property>
-           <property name="text">
-            <string>Disable Loop safety checks</string>
-           </property>
-          </widget>
-         </item>
-         <item row="4" column="0">
-          <widget class="QCheckBox" name="dump_shaders">
-           <property name="enabled">
-            <bool>true</bool>
-           </property>
-           <property name="toolTip">
-            <string>When checked, it will dump all the original assembler shaders from the disk shader cache or game as found</string>
-           </property>
-           <property name="text">
-            <string>Dump Game Shaders</string>
-           </property>
-          </widget>
-         </item>
-         <item row="7" column="0">
-          <widget class="QCheckBox" name="disable_macro_hle">
-           <property name="enabled">
-            <bool>true</bool>
-           </property>
-           <property name="toolTip">
-            <string>When checked, it disables the macro HLE functions. Enabling this makes games run slower</string>
-           </property>
-           <property name="text">
-            <string>Disable Macro HLE</string>
-           </property>
-          </widget>
-         </item>
-         <item row="5" column="0">
-          <widget class="QCheckBox" name="disable_macro_jit">
-           <property name="enabled">
-            <bool>true</bool>
-           </property>
-           <property name="toolTip">
-            <string>When checked, it disables the macro Just In Time compiler. Enabling this makes games run slower</string>
-           </property>
-           <property name="text">
-            <string>Disable Macro JIT</string>
-           </property>
-          </widget>
-         </item>
       <item row="0" column="0">
        <widget class="QCheckBox" name="enable_graphics_debugging">
         <property name="enabled">
@@ -322,7 +153,30 @@
         </property>
        </widget>
       </item>
-         <item row="6" column="0">
+      <item row="2" column="0">
+       <widget class="QCheckBox" name="enable_nsight_aftermath">
+        <property name="toolTip">
+         <string>When checked, it enables Nsight Aftermath crash dumps</string>
+        </property>
+        <property name="text">
+         <string>Enable Nsight Aftermath</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QCheckBox" name="dump_shaders">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+        <property name="toolTip">
+         <string>When checked, it will dump all the original assembler shaders from the disk shader cache or game as found</string>
+        </property>
+        <property name="text">
+         <string>Dump Game Shaders</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="2">
        <widget class="QCheckBox" name="dump_macros">
         <property name="enabled">
          <bool>true</bool>
@@ -335,6 +189,32 @@
         </property>
        </widget>
       </item>
+      <item row="0" column="1">
+       <widget class="QCheckBox" name="disable_macro_jit">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+        <property name="toolTip">
+         <string>When checked, it disables the macro Just In Time compiler. Enabling this makes games run slower</string>
+        </property>
+        <property name="text">
+         <string>Disable Macro JIT</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="2">
+       <widget class="QCheckBox" name="disable_macro_hle">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+        <property name="toolTip">
+         <string>When checked, it disables the macro HLE functions. Enabling this makes games run slower</string>
+        </property>
+        <property name="text">
+         <string>Disable Macro HLE</string>
+        </property>
+       </widget>
+      </item>
       <item row="1" column="0">
        <widget class="QCheckBox" name="enable_shader_feedback">
         <property name="toolTip">
@@ -345,31 +225,55 @@
         </property>
        </widget>
       </item>
-         <item row="2" column="0">
-          <widget class="QCheckBox" name="enable_nsight_aftermath">
+      <item row="1" column="1">
+       <widget class="QCheckBox" name="disable_loop_safety_checks">
         <property name="toolTip">
-            <string>When checked, it enables Nsight Aftermath crash dumps</string>
+         <string>When checked, it executes shaders without loop logic changes</string>
         </property>
         <property name="text">
-            <string>Enable Nsight Aftermath</string>
+         <string>Disable Loop safety checks</string>
         </property>
        </widget>
       </item>
-         <item row="8" column="0">
-          <spacer name="verticalSpacer_5">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox_5">
+     <property name="title">
+      <string>Debugging</string>
      </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Preferred</enum>
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="2" column="0">
+       <widget class="QCheckBox" name="reporting_services">
+        <property name="text">
+         <string>Enable Verbose Reporting Services**</string>
         </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>20</width>
-             <height>0</height>
-            </size>
+       </widget>
+      </item>
+      <item row="0" column="0">
+       <widget class="QCheckBox" name="fs_access_log">
+        <property name="text">
+         <string>Enable FS Access Log</string>
         </property>
-          </spacer>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QCheckBox" name="dump_audio_commands">
+        <property name="toolTip">
+         <string>Enable this to output the latest generated audio command list to the console. Only affects games using the audio renderer.</string>
+        </property>
+        <property name="text">
+         <string>Dump Audio Commands To Console**</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QCheckBox" name="create_crash_dumps">
+        <property name="text">
+         <string>Create Minidump After Crash</string>
+        </property>
+       </widget>
       </item>
      </layout>
     </widget>
@@ -380,37 +284,6 @@
       <string>Advanced</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_4">
-         <item row="3" column="0">
-          <widget class="QCheckBox" name="perform_vulkan_check">
-           <property name="toolTip">
-            <string>Enables yuzu to check for a working Vulkan environment when the program starts up. Disable this if this is causing issues with external programs seeing yuzu.</string>
-           </property>
-           <property name="text">
-            <string>Perform Startup Vulkan Check</string>
-           </property>
-          </widget>
-         </item>
-         <item row="4" column="0">
-          <widget class="QCheckBox" name="disable_web_applet">
-           <property name="text">
-            <string>Disable Web Applet</string>
-           </property>
-          </widget>
-         </item>
-         <item row="5" column="0">
-          <widget class="QCheckBox" name="enable_all_controllers">
-           <property name="text">
-            <string>Enable All Controller Types</string>
-           </property>
-          </widget>
-         </item>
-         <item row="6" column="0">
-          <widget class="QCheckBox" name="use_auto_stub">
-           <property name="text">
-            <string>Enable Auto-Stub**</string>
-           </property>
-          </widget>
-         </item>
       <item row="0" column="0">
        <widget class="QCheckBox" name="quest_flag">
         <property name="text">
@@ -432,104 +305,42 @@
         </property>
        </widget>
       </item>
-         <item row="7" column="0">
-          <spacer name="verticalSpacer_4">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Expanding</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>20</width>
-             <height>0</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
-        </layout>
-       </widget>
-      </item>
-      <item>
-       <widget class="QGroupBox" name="groupBox_5">
-        <property name="title">
-         <string>Debugging</string>
-        </property>
-        <layout class="QGridLayout" name="gridLayout_3">
-         <item row="0" column="0">
-          <widget class="QCheckBox" name="fs_access_log">
+      <item row="0" column="1">
+       <widget class="QCheckBox" name="use_auto_stub">
         <property name="text">
-            <string>Enable FS Access Log</string>
+         <string>Enable Auto-Stub**</string>
         </property>
        </widget>
       </item>
-         <item row="4" column="0">
-          <widget class="QCheckBox" name="create_crash_dumps">
+      <item row="1" column="1">
+       <widget class="QCheckBox" name="enable_all_controllers">
         <property name="text">
-            <string>Create Minidump After Crash</string>
+         <string>Enable All Controller Types</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QCheckBox" name="disable_web_applet">
+        <property name="text">
+         <string>Disable Web Applet</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
-          <widget class="QCheckBox" name="dump_audio_commands">
+       <widget class="QCheckBox" name="perform_vulkan_check">
         <property name="toolTip">
-            <string>Enable this to output the latest generated audio command list to the console. Only affects games using the audio renderer.</string>
+         <string>Enables yuzu to check for a working Vulkan environment when the program starts up. Disable this if this is causing issues with external programs seeing yuzu.</string>
         </property>
         <property name="text">
-            <string>Dump Audio Commands To Console**</string>
+         <string>Perform Startup Vulkan Check</string>
         </property>
        </widget>
       </item>
-         <item row="2" column="0">
-          <widget class="QCheckBox" name="reporting_services">
-           <property name="text">
-            <string>Enable Verbose Reporting Services**</string>
-           </property>
-          </widget>
-         </item>
-         <item row="5" column="0">
-          <spacer name="verticalSpacer_3">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Expanding</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>20</width>
-             <height>0</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
      </layout>
     </widget>
    </item>
-     </layout>
-    </item>
-    <item>
-     <spacer name="verticalSpacer">
-      <property name="orientation">
-       <enum>Qt::Vertical</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>0</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
    <item>
     <widget class="QLabel" name="label_5">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
-        <horstretch>0</horstretch>
-        <verstretch>0</verstretch>
-       </sizepolicy>
-      </property>
      <property name="font">
       <font>
        <italic>true</italic>
@@ -555,11 +366,14 @@
   <tabstop>enable_graphics_debugging</tabstop>
   <tabstop>enable_shader_feedback</tabstop>
   <tabstop>enable_nsight_aftermath</tabstop>
+  <tabstop>disable_macro_jit</tabstop>
+  <tabstop>disable_loop_safety_checks</tabstop>
   <tabstop>fs_access_log</tabstop>
   <tabstop>reporting_services</tabstop>
   <tabstop>quest_flag</tabstop>
   <tabstop>enable_cpu_debugging</tabstop>
   <tabstop>use_debug_asserts</tabstop>
+  <tabstop>use_auto_stub</tabstop>
  </tabstops>
  <resources/>
  <connections/>

src/yuzu/configuration/configure_dialog.cpp

@@ -32,23 +32,21 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
                                  std::vector<VkDeviceInfo::Record>& vk_device_records,
                                  Core::System& system_, bool enable_web_config)
     : QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()},
-      registry(registry_), system{system_}, builder{std::make_unique<ConfigurationShared::Builder>(
-                                                this, !system_.IsPoweredOn())},
-      audio_tab{std::make_unique<ConfigureAudio>(system_, nullptr, *builder, this)},
-      cpu_tab{std::make_unique<ConfigureCpu>(system_, nullptr, *builder, this)},
+      registry(registry_), system{system_}, audio_tab{std::make_unique<ConfigureAudio>(system_,
+                                                                                       this)},
+      cpu_tab{std::make_unique<ConfigureCpu>(system_, this)},
       debug_tab_tab{std::make_unique<ConfigureDebugTab>(system_, this)},
       filesystem_tab{std::make_unique<ConfigureFilesystem>(this)},
-      general_tab{std::make_unique<ConfigureGeneral>(system_, nullptr, *builder, this)},
-      graphics_advanced_tab{
-          std::make_unique<ConfigureGraphicsAdvanced>(system_, nullptr, *builder, this)},
+      general_tab{std::make_unique<ConfigureGeneral>(system_, this)},
+      graphics_advanced_tab{std::make_unique<ConfigureGraphicsAdvanced>(system_, this)},
       graphics_tab{std::make_unique<ConfigureGraphics>(
           system_, vk_device_records, [&]() { graphics_advanced_tab->ExposeComputeOption(); },
-          nullptr, *builder, this)},
+          this)},
       hotkeys_tab{std::make_unique<ConfigureHotkeys>(system_.HIDCore(), this)},
       input_tab{std::make_unique<ConfigureInput>(system_, this)},
       network_tab{std::make_unique<ConfigureNetwork>(system_, this)},
       profile_tab{std::make_unique<ConfigureProfileManager>(system_, this)},
-      system_tab{std::make_unique<ConfigureSystem>(system_, nullptr, *builder, this)},
+      system_tab{std::make_unique<ConfigureSystem>(system_, this)},
       ui_tab{std::make_unique<ConfigureUi>(system_, this)}, web_tab{std::make_unique<ConfigureWeb>(
                                                                 this)} {
     Settings::SetConfiguringGlobal(true);
@@ -97,9 +95,6 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
 
     adjustSize();
     ui->selectorList->setCurrentRow(0);
-
-    // Selects the leftmost button on the bottom bar (Cancel as of writing)
-    ui->buttonBox->setFocus();
 }
 
 ConfigureDialog::~ConfigureDialog() = default;

src/yuzu/configuration/configure_dialog.h

@@ -6,9 +6,6 @@
 #include <memory>
 #include <vector>
 #include <QDialog>
-#include "configuration/shared_widget.h"
-#include "yuzu/configuration/configuration_shared.h"
-#include "yuzu/configuration/shared_translation.h"
 #include "yuzu/vk_device_info.h"
 
 namespace Core {
@@ -72,8 +69,6 @@ private:
     HotkeyRegistry& registry;
 
     Core::System& system;
-    std::unique_ptr<ConfigurationShared::Builder> builder;
-    std::vector<ConfigurationShared::Tab*> tab_group;
 
     std::unique_ptr<ConfigureAudio> audio_tab;
     std::unique_ptr<ConfigureCpu> cpu_tab;

src/yuzu/configuration/configure_general.cpp

@@ -3,60 +3,57 @@
 
 #include <functional>
 #include <utility>
-#include <vector>
 #include <QMessageBox>
 #include "common/settings.h"
 #include "core/core.h"
 #include "ui_configure_general.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_general.h"
-#include "yuzu/configuration/shared_widget.h"
 #include "yuzu/uisettings.h"
 
-ConfigureGeneral::ConfigureGeneral(const Core::System& system_,
-                                   std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group_,
-                                   const ConfigurationShared::Builder& builder, QWidget* parent)
-    : Tab(group_, parent), ui{std::make_unique<Ui::ConfigureGeneral>()}, system{system_} {
+ConfigureGeneral::ConfigureGeneral(const Core::System& system_, QWidget* parent)
+    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGeneral>()}, system{system_} {
     ui->setupUi(this);
 
-    Setup(builder);
+    SetupPerGameUI();
 
     SetConfiguration();
 
+    if (Settings::IsConfiguringGlobal()) {
+        connect(ui->toggle_speed_limit, &QCheckBox::clicked, ui->speed_limit,
+                [this]() { ui->speed_limit->setEnabled(ui->toggle_speed_limit->isChecked()); });
+    }
+
     connect(ui->button_reset_defaults, &QPushButton::clicked, this,
             &ConfigureGeneral::ResetDefaults);
-
-    if (!Settings::IsConfiguringGlobal()) {
-        ui->button_reset_defaults->setVisible(false);
-    }
 }
 
 ConfigureGeneral::~ConfigureGeneral() = default;
 
-void ConfigureGeneral::SetConfiguration() {}
+void ConfigureGeneral::SetConfiguration() {
+    const bool runtime_lock = !system.IsPoweredOn();
 
-void ConfigureGeneral::Setup(const ConfigurationShared::Builder& builder) {
-    QLayout& layout = *ui->general_widget->layout();
+    ui->use_multi_core->setEnabled(runtime_lock);
+    ui->use_multi_core->setChecked(Settings::values.use_multi_core.GetValue());
 
-    std::map<u32, QWidget*> hold{};
+    ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing.GetValue());
+    ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot.GetValue());
+    ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background.GetValue());
+    ui->toggle_hide_mouse->setChecked(UISettings::values.hide_mouse.GetValue());
+    ui->toggle_controller_applet_disabled->setEnabled(runtime_lock);
+    ui->toggle_controller_applet_disabled->setChecked(
+        UISettings::values.controller_applet_disabled.GetValue());
 
-    for (const auto setting :
-         UISettings::values.linkage.by_category[Settings::Category::UiGeneral]) {
-        auto* widget = builder.BuildWidget(setting, apply_funcs);
+    ui->toggle_speed_limit->setChecked(Settings::values.use_speed_limit.GetValue());
+    ui->speed_limit->setValue(Settings::values.speed_limit.GetValue());
 
-        if (widget == nullptr) {
-            continue;
-        }
-        if (!widget->Valid()) {
-            widget->deleteLater();
-            continue;
-        }
+    ui->button_reset_defaults->setEnabled(runtime_lock);
 
-        hold.emplace(setting->Id(), widget);
-    }
-
-    for (const auto& [id, widget] : hold) {
-        layout.addWidget(widget);
+    if (Settings::IsConfiguringGlobal()) {
+        ui->speed_limit->setEnabled(Settings::values.use_speed_limit.GetValue());
+    } else {
+        ui->speed_limit->setEnabled(Settings::values.use_speed_limit.GetValue() &&
+                                    use_speed_limit != ConfigurationShared::CheckState::Global);
     }
 }
 
@@ -80,9 +77,32 @@ void ConfigureGeneral::ResetDefaults() {
 }
 
 void ConfigureGeneral::ApplyConfiguration() {
-    bool powered_on = system.IsPoweredOn();
-    for (const auto& func : apply_funcs) {
-        func(powered_on);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_multi_core, ui->use_multi_core,
+                                             use_multi_core);
+
+    if (Settings::IsConfiguringGlobal()) {
+        UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
+        UISettings::values.select_user_on_boot = ui->toggle_user_on_boot->isChecked();
+        UISettings::values.pause_when_in_background = ui->toggle_background_pause->isChecked();
+        UISettings::values.hide_mouse = ui->toggle_hide_mouse->isChecked();
+        UISettings::values.controller_applet_disabled =
+            ui->toggle_controller_applet_disabled->isChecked();
+
+        // Guard if during game and set to game-specific value
+        if (Settings::values.use_speed_limit.UsingGlobal()) {
+            Settings::values.use_speed_limit.SetValue(ui->toggle_speed_limit->checkState() ==
+                                                      Qt::Checked);
+            Settings::values.speed_limit.SetValue(ui->speed_limit->value());
+        }
+    } else {
+        bool global_speed_limit = use_speed_limit == ConfigurationShared::CheckState::Global;
+        Settings::values.use_speed_limit.SetGlobal(global_speed_limit);
+        Settings::values.speed_limit.SetGlobal(global_speed_limit);
+        if (!global_speed_limit) {
+            Settings::values.use_speed_limit.SetValue(ui->toggle_speed_limit->checkState() ==
+                                                      Qt::Checked);
+            Settings::values.speed_limit.SetValue(ui->speed_limit->value());
+        }
     }
 }
 
@@ -97,3 +117,33 @@ void ConfigureGeneral::changeEvent(QEvent* event) {
 void ConfigureGeneral::RetranslateUI() {
     ui->retranslateUi(this);
 }
+
+void ConfigureGeneral::SetupPerGameUI() {
+    if (Settings::IsConfiguringGlobal()) {
+        // Disables each setting if:
+        //  - A game is running (thus settings in use), and
+        //  - A non-global setting is applied.
+        ui->toggle_speed_limit->setEnabled(Settings::values.use_speed_limit.UsingGlobal());
+        ui->speed_limit->setEnabled(Settings::values.speed_limit.UsingGlobal());
+
+        return;
+    }
+
+    ui->toggle_check_exit->setVisible(false);
+    ui->toggle_user_on_boot->setVisible(false);
+    ui->toggle_background_pause->setVisible(false);
+    ui->toggle_hide_mouse->setVisible(false);
+    ui->toggle_controller_applet_disabled->setVisible(false);
+
+    ui->button_reset_defaults->setVisible(false);
+
+    ConfigurationShared::SetColoredTristate(ui->toggle_speed_limit,
+                                            Settings::values.use_speed_limit, use_speed_limit);
+    ConfigurationShared::SetColoredTristate(ui->use_multi_core, Settings::values.use_multi_core,
+                                            use_multi_core);
+
+    connect(ui->toggle_speed_limit, &QCheckBox::clicked, ui->speed_limit, [this]() {
+        ui->speed_limit->setEnabled(ui->toggle_speed_limit->isChecked() &&
+                                    (use_speed_limit != ConfigurationShared::CheckState::Global));
+    });
+}

src/yuzu/configuration/configure_general.h

@@ -5,49 +5,48 @@
 
 #include <functional>
 #include <memory>
-#include <vector>
 #include <QWidget>
-#include "yuzu/configuration/configuration_shared.h"
 
 namespace Core {
 class System;
 }
 
 class ConfigureDialog;
+
+namespace ConfigurationShared {
+enum class CheckState;
+}
+
 class HotkeyRegistry;
 
 namespace Ui {
 class ConfigureGeneral;
 }
 
-namespace ConfigurationShared {
-class Builder;
-}
+class ConfigureGeneral : public QWidget {
+    Q_OBJECT
 
-class ConfigureGeneral : public ConfigurationShared::Tab {
 public:
-    explicit ConfigureGeneral(const Core::System& system_,
-                              std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group,
-                              const ConfigurationShared::Builder& builder,
-                              QWidget* parent = nullptr);
+    explicit ConfigureGeneral(const Core::System& system_, QWidget* parent = nullptr);
     ~ConfigureGeneral() override;
 
     void SetResetCallback(std::function<void()> callback);
     void ResetDefaults();
-    void ApplyConfiguration() override;
-    void SetConfiguration() override;
+    void ApplyConfiguration();
+    void SetConfiguration();
 
 private:
-    void Setup(const ConfigurationShared::Builder& builder);
-
     void changeEvent(QEvent* event) override;
     void RetranslateUI();
 
+    void SetupPerGameUI();
+
     std::function<void()> reset_callback;
 
     std::unique_ptr<Ui::ConfigureGeneral> ui;
 
-    std::vector<std::function<void(bool)>> apply_funcs{};
+    ConfigurationShared::CheckState use_speed_limit;
+    ConfigurationShared::CheckState use_multi_core;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_general.ui

@@ -26,23 +26,78 @@
        </property>
        <layout class="QHBoxLayout" name="GeneralHorizontalLayout">
         <item>
-         <widget class="QWidget" name="general_widget" native="true">
          <layout class="QVBoxLayout" name="GeneralVerticalLayout">
-           <property name="leftMargin">
-            <number>0</number>
+          <item>
+           <layout class="QHBoxLayout" name="horizontalLayout_2">
+            <item>
+             <widget class="QCheckBox" name="toggle_speed_limit">
+              <property name="text">
+               <string>Limit Speed Percent</string>
               </property>
-           <property name="topMargin">
-            <number>0</number>
-           </property>
-           <property name="rightMargin">
-            <number>0</number>
-           </property>
-           <property name="bottomMargin">
-            <number>0</number>
-           </property>
-          </layout>
              </widget>
             </item>
+            <item>
+             <widget class="QSpinBox" name="speed_limit">
+              <property name="suffix">
+               <string>%</string>
+              </property>
+              <property name="minimum">
+               <number>1</number>
+              </property>
+              <property name="maximum">
+               <number>9999</number>
+              </property>
+              <property name="value">
+               <number>100</number>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="use_multi_core">
+            <property name="text">
+             <string>Multicore CPU Emulation</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="toggle_check_exit">
+            <property name="text">
+             <string>Confirm exit while emulation is running</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="toggle_user_on_boot">
+            <property name="text">
+             <string>Prompt for user on game boot</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="toggle_background_pause">
+            <property name="text">
+             <string>Pause emulation when in background</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="toggle_hide_mouse">
+            <property name="text">
+             <string>Hide mouse on inactivity</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="toggle_controller_applet_disabled">
+            <property name="text">
+             <string>Disable controller applet</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
        </layout>
       </widget>
      </item>

src/yuzu/configuration/configure_graphics.cpp

@@ -7,7 +7,6 @@
 #include <iterator>
 #include <string>
 #include <tuple>
-#include <typeinfo>
 #include <utility>
 #include <vector>
 #include <QBoxLayout>
@@ -16,29 +15,23 @@
 #include <QComboBox>
 #include <QIcon>
 #include <QLabel>
-#include <QLineEdit>
 #include <QPixmap>
 #include <QPushButton>
 #include <QSlider>
 #include <QStringLiteral>
 #include <QtCore/qobjectdefs.h>
-#include <qabstractbutton.h>
-#include <qboxlayout.h>
 #include <qcoreevent.h>
 #include <qglobal.h>
-#include <qgridlayout.h>
 #include <vulkan/vulkan_core.h>
 
 #include "common/common_types.h"
 #include "common/dynamic_library.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
-#include "common/settings_enums.h"
 #include "core/core.h"
 #include "ui_configure_graphics.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_graphics.h"
-#include "yuzu/configuration/shared_widget.h"
 #include "yuzu/qt_common.h"
 #include "yuzu/uisettings.h"
 #include "yuzu/vk_device_info.h"
@@ -53,9 +46,9 @@ static constexpr VkPresentModeKHR VSyncSettingToMode(Settings::VSyncMode mode) {
         return VK_PRESENT_MODE_IMMEDIATE_KHR;
     case Settings::VSyncMode::Mailbox:
         return VK_PRESENT_MODE_MAILBOX_KHR;
-    case Settings::VSyncMode::Fifo:
+    case Settings::VSyncMode::FIFO:
         return VK_PRESENT_MODE_FIFO_KHR;
-    case Settings::VSyncMode::FifoRelaxed:
+    case Settings::VSyncMode::FIFORelaxed:
         return VK_PRESENT_MODE_FIFO_RELAXED_KHR;
     default:
         return VK_PRESENT_MODE_FIFO_KHR;
@@ -69,67 +62,50 @@ static constexpr Settings::VSyncMode PresentModeToSetting(VkPresentModeKHR mode)
     case VK_PRESENT_MODE_MAILBOX_KHR:
         return Settings::VSyncMode::Mailbox;
     case VK_PRESENT_MODE_FIFO_KHR:
-        return Settings::VSyncMode::Fifo;
+        return Settings::VSyncMode::FIFO;
     case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
-        return Settings::VSyncMode::FifoRelaxed;
+        return Settings::VSyncMode::FIFORelaxed;
     default:
-        return Settings::VSyncMode::Fifo;
+        return Settings::VSyncMode::FIFO;
     }
 }
 
 ConfigureGraphics::ConfigureGraphics(const Core::System& system_,
                                      std::vector<VkDeviceInfo::Record>& records_,
                                      const std::function<void()>& expose_compute_option_,
-                                     std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group_,
-                                     const ConfigurationShared::Builder& builder, QWidget* parent)
-    : ConfigurationShared::Tab(group_, parent), ui{std::make_unique<Ui::ConfigureGraphics>()},
-      records{records_}, expose_compute_option{expose_compute_option_}, system{system_},
-      combobox_translations{builder.ComboboxTranslations()},
-      shader_mapping{
-          combobox_translations.at(Settings::EnumMetadata<Settings::ShaderBackend>::Index())} {
+                                     QWidget* parent)
+    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGraphics>()}, records{records_},
+      expose_compute_option{expose_compute_option_}, system{system_} {
     vulkan_device = Settings::values.vulkan_device.GetValue();
     RetrieveVulkanDevices();
 
     ui->setupUi(this);
 
-    Setup(builder);
-
     for (const auto& device : vulkan_devices) {
-        vulkan_device_combobox->addItem(device);
+        ui->device->addItem(device);
     }
 
-    UpdateBackgroundColorButton(QColor::fromRgb(Settings::values.bg_red.GetValue(),
-                                                Settings::values.bg_green.GetValue(),
-                                                Settings::values.bg_blue.GetValue()));
-    UpdateAPILayout();
-    PopulateVSyncModeSelection(); //< must happen after UpdateAPILayout
+    ui->backend->addItem(QStringLiteral("GLSL"));
+    ui->backend->addItem(tr("GLASM (Assembly Shaders, NVIDIA Only)"));
+    ui->backend->addItem(tr("SPIR-V (Experimental, Mesa Only)"));
 
-    // 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);
-        }
-    }
+    SetupPerGameUI();
 
-    connect(api_combobox, qOverload<int>(&QComboBox::activated), this, [this] {
+    SetConfiguration();
+
+    connect(ui->api, qOverload<int>(&QComboBox::currentIndexChanged), this, [this] {
         UpdateAPILayout();
         PopulateVSyncModeSelection();
+        if (!Settings::IsConfiguringGlobal()) {
+            ConfigurationShared::SetHighlight(
+                ui->api_widget, ui->api->currentIndex() != ConfigurationShared::USE_GLOBAL_INDEX);
+        }
     });
-    connect(vulkan_device_combobox, qOverload<int>(&QComboBox::activated), this,
-            [this](int device) {
+    connect(ui->device, qOverload<int>(&QComboBox::activated), this, [this](int device) {
         UpdateDeviceSelection(device);
         PopulateVSyncModeSelection();
     });
-    connect(shader_backend_combobox, qOverload<int>(&QComboBox::activated), this,
+    connect(ui->backend, qOverload<int>(&QComboBox::activated), this,
             [this](int backend) { UpdateShaderBackendSelection(backend); });
 
     connect(ui->bg_button, &QPushButton::clicked, this, [this] {
@@ -140,45 +116,39 @@ ConfigureGraphics::ConfigureGraphics(const Core::System& system_,
         UpdateBackgroundColorButton(new_bg_color);
     });
 
-    api_combobox->setEnabled(!UISettings::values.has_broken_vulkan && api_combobox->isEnabled());
+    ui->api->setEnabled(!UISettings::values.has_broken_vulkan && ui->api->isEnabled());
     ui->api_widget->setEnabled(
         (!UISettings::values.has_broken_vulkan || Settings::IsConfiguringGlobal()) &&
         ui->api_widget->isEnabled());
+    ui->bg_label->setVisible(Settings::IsConfiguringGlobal());
+    ui->bg_combobox->setVisible(!Settings::IsConfiguringGlobal());
 
-    if (Settings::IsConfiguringGlobal()) {
-        ui->bg_widget->setEnabled(Settings::values.bg_red.UsingGlobal());
-    }
+    connect(ui->fsr_sharpening_slider, &QSlider::valueChanged, this,
+            &ConfigureGraphics::SetFSRIndicatorText);
+    ui->fsr_sharpening_combobox->setVisible(!Settings::IsConfiguringGlobal());
+    ui->fsr_sharpening_label->setVisible(Settings::IsConfiguringGlobal());
 }
 
 void ConfigureGraphics::PopulateVSyncModeSelection() {
-    if (!Settings::IsConfiguringGlobal()) {
-        return;
-    }
-
     const Settings::RendererBackend backend{GetCurrentGraphicsBackend()};
     if (backend == Settings::RendererBackend::Null) {
-        vsync_mode_combobox->setEnabled(false);
+        ui->vsync_mode_combobox->setEnabled(false);
         return;
     }
-    vsync_mode_combobox->setEnabled(true);
+    ui->vsync_mode_combobox->setEnabled(true);
 
     const int current_index = //< current selected vsync mode from combobox
-        vsync_mode_combobox->currentIndex();
+        ui->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];
     int index{};
-    const int device{vulkan_device_combobox->currentIndex()}; //< current selected Vulkan device
-    if (device == -1) {
-        // Invalid device
-        return;
-    }
-
+    const int device{ui->device->currentIndex()}; //< current selected Vulkan device
     const auto& present_modes = //< relevant vector of present modes for the selected device or API
         backend == Settings::RendererBackend::Vulkan ? device_present_modes[device]
                                                      : default_present_modes;
 
-    vsync_mode_combobox->clear();
+    ui->vsync_mode_combobox->clear();
     vsync_mode_combobox_enum_map.clear();
     vsync_mode_combobox_enum_map.reserve(present_modes.size());
     for (const auto present_mode : present_modes) {
@@ -187,10 +157,10 @@ void ConfigureGraphics::PopulateVSyncModeSelection() {
             continue;
         }
 
-        vsync_mode_combobox->insertItem(index, mode_name);
+        ui->vsync_mode_combobox->insertItem(index, mode_name);
         vsync_mode_combobox_enum_map.push_back(present_mode);
         if (present_mode == current_mode) {
-            vsync_mode_combobox->setCurrentIndex(index);
+            ui->vsync_mode_combobox->setCurrentIndex(index);
         }
         index++;
     }
@@ -216,124 +186,112 @@ void ConfigureGraphics::UpdateShaderBackendSelection(int backend) {
 
 ConfigureGraphics::~ConfigureGraphics() = default;
 
-void ConfigureGraphics::SetConfiguration() {}
+void ConfigureGraphics::SetConfiguration() {
+    const bool runtime_lock = !system.IsPoweredOn();
 
-void ConfigureGraphics::Setup(const ConfigurationShared::Builder& builder) {
-    QLayout* api_layout = ui->api_widget->layout();
-    QWidget* api_grid_widget = new QWidget(this);
-    QVBoxLayout* api_grid_layout = new QVBoxLayout(api_grid_widget);
-    api_grid_layout->setContentsMargins(0, 0, 0, 0);
-    api_layout->addWidget(api_grid_widget);
+    ui->api_widget->setEnabled(runtime_lock);
+    ui->use_asynchronous_gpu_emulation->setEnabled(runtime_lock);
+    ui->use_disk_shader_cache->setEnabled(runtime_lock);
+    ui->nvdec_emulation_widget->setEnabled(runtime_lock);
+    ui->resolution_combobox->setEnabled(runtime_lock);
+    ui->accelerate_astc->setEnabled(runtime_lock);
+    ui->vsync_mode_layout->setEnabled(runtime_lock ||
+                                      Settings::values.renderer_backend.GetValue() ==
+                                          Settings::RendererBackend::Vulkan);
+    ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache.GetValue());
+    ui->use_asynchronous_gpu_emulation->setChecked(
+        Settings::values.use_asynchronous_gpu_emulation.GetValue());
+    ui->accelerate_astc->setChecked(Settings::values.accelerate_astc.GetValue());
 
-    QLayout& graphics_layout = *ui->graphics_widget->layout();
-
-    std::map<u32, QWidget*> hold_graphics;
-    std::vector<QWidget*> hold_api;
-
-    for (const auto setting : Settings::values.linkage.by_category[Settings::Category::Renderer]) {
-        ConfigurationShared::Widget* widget = [&]() {
-            if (setting->Id() == Settings::values.fsr_sharpening_slider.Id()) {
-                // FSR needs a reversed slider and a 0.5 multiplier
-                return builder.BuildWidget(
-                    setting, apply_funcs, ConfigurationShared::RequestType::ReverseSlider, true,
-                    0.5f, nullptr, tr("%", "FSR sharpening percentage (e.g. 50%)"));
-            } else {
-                return builder.BuildWidget(setting, apply_funcs);
-            }
-        }();
-
-        if (widget == nullptr) {
-            continue;
-        }
-        if (!widget->Valid()) {
-            widget->deleteLater();
-            continue;
-        }
-
-        if (setting->Id() == Settings::values.renderer_backend.Id()) {
-            // Add the renderer combobox now so it's at the top
-            api_grid_layout->addWidget(widget);
-            api_combobox = widget->combobox;
-            api_restore_global_button = widget->restore_button;
-
-            if (!Settings::IsConfiguringGlobal()) {
-                QObject::connect(api_restore_global_button, &QAbstractButton::clicked,
-                                 [this](bool) { UpdateAPILayout(); });
-
-                // Detach API's restore button and place it where we want
-                // Lets us put it on the side, and it will automatically scale if there's a
-                // second combobox (shader_backend, vulkan_device)
-                widget->layout()->removeWidget(api_restore_global_button);
-                api_layout->addWidget(api_restore_global_button);
-            }
-        } else if (setting->Id() == Settings::values.vulkan_device.Id()) {
-            // Keep track of vulkan_device's combobox so we can populate it
-            hold_api.push_back(widget);
-            vulkan_device_combobox = widget->combobox;
-            vulkan_device_widget = widget;
-        } else if (setting->Id() == Settings::values.shader_backend.Id()) {
-            // Keep track of shader_backend's combobox so we can populate it
-            hold_api.push_back(widget);
-            shader_backend_combobox = widget->combobox;
-            shader_backend_widget = widget;
-        } 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;
-            hold_graphics.emplace(setting->Id(), widget);
-        } else {
-            hold_graphics.emplace(setting->Id(), widget);
-        }
-    }
-
-    for (const auto& [id, widget] : hold_graphics) {
-        graphics_layout.addWidget(widget);
-    }
-
-    for (auto widget : hold_api) {
-        api_grid_layout->addWidget(widget);
-    }
-
-    // Background color is too specific to build into the new system, so we manage it here
-    // (3 settings, all collected into a single widget with a QColor to manage on top)
     if (Settings::IsConfiguringGlobal()) {
-        apply_funcs.push_back([this](bool powered_on) {
-            Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));
-            Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));
-            Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));
-        });
+        ui->api->setCurrentIndex(static_cast<int>(Settings::values.renderer_backend.GetValue()));
+        ui->fullscreen_mode_combobox->setCurrentIndex(
+            static_cast<int>(Settings::values.fullscreen_mode.GetValue()));
+        ui->nvdec_emulation->setCurrentIndex(
+            static_cast<int>(Settings::values.nvdec_emulation.GetValue()));
+        ui->aspect_ratio_combobox->setCurrentIndex(Settings::values.aspect_ratio.GetValue());
+        ui->resolution_combobox->setCurrentIndex(
+            static_cast<int>(Settings::values.resolution_setup.GetValue()));
+        ui->scaling_filter_combobox->setCurrentIndex(
+            static_cast<int>(Settings::values.scaling_filter.GetValue()));
+        ui->fsr_sharpening_slider->setValue(Settings::values.fsr_sharpening_slider.GetValue());
+        ui->anti_aliasing_combobox->setCurrentIndex(
+            static_cast<int>(Settings::values.anti_aliasing.GetValue()));
     } else {
-        QPushButton* bg_restore_button = ConfigurationShared::Widget::CreateRestoreGlobalButton(
-            Settings::values.bg_red.UsingGlobal(), ui->bg_widget);
-        ui->bg_widget->layout()->addWidget(bg_restore_button);
+        ConfigurationShared::SetPerGameSetting(ui->api, &Settings::values.renderer_backend);
+        ConfigurationShared::SetHighlight(ui->api_widget,
+                                          !Settings::values.renderer_backend.UsingGlobal());
 
-        QObject::connect(bg_restore_button, &QAbstractButton::clicked,
-                         [bg_restore_button, this](bool) {
-                             const int r = Settings::values.bg_red.GetValue(true);
-                             const int g = Settings::values.bg_green.GetValue(true);
-                             const int b = Settings::values.bg_blue.GetValue(true);
-                             UpdateBackgroundColorButton(QColor::fromRgb(r, g, b));
+        ConfigurationShared::SetPerGameSetting(ui->nvdec_emulation,
+                                               &Settings::values.nvdec_emulation);
+        ConfigurationShared::SetHighlight(ui->nvdec_emulation_widget,
+                                          !Settings::values.nvdec_emulation.UsingGlobal());
 
-                             bg_restore_button->setVisible(false);
-                             bg_restore_button->setEnabled(false);
-                         });
+        ConfigurationShared::SetPerGameSetting(ui->fullscreen_mode_combobox,
+                                               &Settings::values.fullscreen_mode);
+        ConfigurationShared::SetHighlight(ui->fullscreen_mode_label,
+                                          !Settings::values.fullscreen_mode.UsingGlobal());
 
-        QObject::connect(ui->bg_button, &QAbstractButton::clicked, [bg_restore_button](bool) {
-            bg_restore_button->setVisible(true);
-            bg_restore_button->setEnabled(true);
-        });
+        ConfigurationShared::SetPerGameSetting(ui->aspect_ratio_combobox,
+                                               &Settings::values.aspect_ratio);
+        ConfigurationShared::SetHighlight(ui->ar_label,
+                                          !Settings::values.aspect_ratio.UsingGlobal());
 
-        apply_funcs.push_back([bg_restore_button, this](bool powered_on) {
-            const bool using_global = !bg_restore_button->isEnabled();
-            Settings::values.bg_red.SetGlobal(using_global);
-            Settings::values.bg_green.SetGlobal(using_global);
-            Settings::values.bg_blue.SetGlobal(using_global);
-            if (!using_global) {
-                Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));
-                Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));
-                Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));
+        ConfigurationShared::SetPerGameSetting(ui->resolution_combobox,
+                                               &Settings::values.resolution_setup);
+        ConfigurationShared::SetHighlight(ui->resolution_label,
+                                          !Settings::values.resolution_setup.UsingGlobal());
+
+        ConfigurationShared::SetPerGameSetting(ui->scaling_filter_combobox,
+                                               &Settings::values.scaling_filter);
+        ConfigurationShared::SetHighlight(ui->scaling_filter_label,
+                                          !Settings::values.scaling_filter.UsingGlobal());
+
+        ConfigurationShared::SetPerGameSetting(ui->anti_aliasing_combobox,
+                                               &Settings::values.anti_aliasing);
+        ConfigurationShared::SetHighlight(ui->anti_aliasing_label,
+                                          !Settings::values.anti_aliasing.UsingGlobal());
+
+        ui->fsr_sharpening_combobox->setCurrentIndex(
+            Settings::values.fsr_sharpening_slider.UsingGlobal() ? 0 : 1);
+        ui->fsr_sharpening_slider->setEnabled(
+            !Settings::values.fsr_sharpening_slider.UsingGlobal());
+        ui->fsr_sharpening_value->setEnabled(!Settings::values.fsr_sharpening_slider.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->fsr_sharpening_layout,
+                                          !Settings::values.fsr_sharpening_slider.UsingGlobal());
+        ui->fsr_sharpening_slider->setValue(Settings::values.fsr_sharpening_slider.GetValue());
+
+        ui->bg_combobox->setCurrentIndex(Settings::values.bg_red.UsingGlobal() ? 0 : 1);
+        ui->bg_button->setEnabled(!Settings::values.bg_red.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->bg_layout, !Settings::values.bg_red.UsingGlobal());
     }
-        });
+    UpdateBackgroundColorButton(QColor::fromRgb(Settings::values.bg_red.GetValue(),
+                                                Settings::values.bg_green.GetValue(),
+                                                Settings::values.bg_blue.GetValue()));
+    UpdateAPILayout();
+    PopulateVSyncModeSelection(); //< must happen after UpdateAPILayout
+    SetFSRIndicatorText(ui->fsr_sharpening_slider->sliderPosition());
+
+    // 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()) {
+            ui->vsync_mode_combobox->setCurrentIndex(index);
+        }
+    }
+}
+
+void ConfigureGraphics::SetFSRIndicatorText(int percentage) {
+    ui->fsr_sharpening_value->setText(
+        tr("%1%", "FSR sharpening percentage (e.g. 50%)").arg(100 - (percentage / 2)));
 }
 
 const QString ConfigureGraphics::TranslateVSyncMode(VkPresentModeKHR mode,
@@ -357,50 +315,132 @@ const QString ConfigureGraphics::TranslateVSyncMode(VkPresentModeKHR mode,
     }
 }
 
-int ConfigureGraphics::FindIndex(u32 enumeration, int value) const {
-    for (u32 i = 0; i < combobox_translations.at(enumeration).size(); i++) {
-        if (combobox_translations.at(enumeration)[i].first == static_cast<u32>(value)) {
-            return i;
-        }
-    }
-    return -1;
-}
-
 void ConfigureGraphics::ApplyConfiguration() {
-    const bool powered_on = system.IsPoweredOn();
-    for (const auto& func : apply_funcs) {
-        func(powered_on);
-    }
+    const auto resolution_setup = static_cast<Settings::ResolutionSetup>(
+        ui->resolution_combobox->currentIndex() -
+        ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
+
+    const auto scaling_filter = static_cast<Settings::ScalingFilter>(
+        ui->scaling_filter_combobox->currentIndex() -
+        ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
+
+    const auto anti_aliasing = static_cast<Settings::AntiAliasing>(
+        ui->anti_aliasing_combobox->currentIndex() -
+        ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
+
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.fullscreen_mode,
+                                             ui->fullscreen_mode_combobox);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.aspect_ratio,
+                                             ui->aspect_ratio_combobox);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_disk_shader_cache,
+                                             ui->use_disk_shader_cache, use_disk_shader_cache);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_gpu_emulation,
+                                             ui->use_asynchronous_gpu_emulation,
+                                             use_asynchronous_gpu_emulation);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.accelerate_astc, ui->accelerate_astc,
+                                             accelerate_astc);
 
     if (Settings::IsConfiguringGlobal()) {
-        const auto mode = vsync_mode_combobox_enum_map[vsync_mode_combobox->currentIndex()];
+        // Guard if during game and set to game-specific value
+        if (Settings::values.renderer_backend.UsingGlobal()) {
+            Settings::values.renderer_backend.SetValue(GetCurrentGraphicsBackend());
+        }
+        if (Settings::values.nvdec_emulation.UsingGlobal()) {
+            Settings::values.nvdec_emulation.SetValue(GetCurrentNvdecEmulation());
+        }
+        if (Settings::values.shader_backend.UsingGlobal()) {
+            Settings::values.shader_backend.SetValue(shader_backend);
+        }
+        if (Settings::values.vulkan_device.UsingGlobal()) {
+            Settings::values.vulkan_device.SetValue(vulkan_device);
+        }
+        if (Settings::values.bg_red.UsingGlobal()) {
+            Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));
+            Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));
+            Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));
+        }
+        if (Settings::values.resolution_setup.UsingGlobal()) {
+            Settings::values.resolution_setup.SetValue(resolution_setup);
+        }
+        if (Settings::values.scaling_filter.UsingGlobal()) {
+            Settings::values.scaling_filter.SetValue(scaling_filter);
+        }
+        if (Settings::values.anti_aliasing.UsingGlobal()) {
+            Settings::values.anti_aliasing.SetValue(anti_aliasing);
+        }
+        Settings::values.fsr_sharpening_slider.SetValue(ui->fsr_sharpening_slider->value());
+
+        const auto mode = vsync_mode_combobox_enum_map[ui->vsync_mode_combobox->currentIndex()];
         const auto vsync_mode = PresentModeToSetting(mode);
         Settings::values.vsync_mode.SetValue(vsync_mode);
+    } else {
+        if (ui->resolution_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            Settings::values.resolution_setup.SetGlobal(true);
+        } else {
+            Settings::values.resolution_setup.SetGlobal(false);
+            Settings::values.resolution_setup.SetValue(resolution_setup);
         }
-
-    Settings::values.vulkan_device.SetGlobal(true);
+        if (ui->scaling_filter_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            Settings::values.scaling_filter.SetGlobal(true);
+        } else {
+            Settings::values.scaling_filter.SetGlobal(false);
+            Settings::values.scaling_filter.SetValue(scaling_filter);
+        }
+        if (ui->anti_aliasing_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            Settings::values.anti_aliasing.SetGlobal(true);
+        } else {
+            Settings::values.anti_aliasing.SetGlobal(false);
+            Settings::values.anti_aliasing.SetValue(anti_aliasing);
+        }
+        if (ui->api->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            Settings::values.renderer_backend.SetGlobal(true);
             Settings::values.shader_backend.SetGlobal(true);
-    if (Settings::IsConfiguringGlobal() ||
-        (!Settings::IsConfiguringGlobal() && api_restore_global_button->isEnabled())) {
-        auto backend = static_cast<Settings::RendererBackend>(
-            combobox_translations
-                .at(Settings::EnumMetadata<
-                    Settings::RendererBackend>::Index())[api_combobox->currentIndex()]
-                .first);
-        switch (backend) {
+            Settings::values.vulkan_device.SetGlobal(true);
+        } else {
+            Settings::values.renderer_backend.SetGlobal(false);
+            Settings::values.renderer_backend.SetValue(GetCurrentGraphicsBackend());
+            switch (GetCurrentGraphicsBackend()) {
             case Settings::RendererBackend::OpenGL:
-            Settings::values.shader_backend.SetGlobal(Settings::IsConfiguringGlobal());
-            Settings::values.shader_backend.SetValue(static_cast<Settings::ShaderBackend>(
-                shader_mapping[shader_backend_combobox->currentIndex()].first));
+            case Settings::RendererBackend::Null:
+                Settings::values.shader_backend.SetGlobal(false);
+                Settings::values.vulkan_device.SetGlobal(true);
+                Settings::values.shader_backend.SetValue(shader_backend);
                 break;
             case Settings::RendererBackend::Vulkan:
-            Settings::values.vulkan_device.SetGlobal(Settings::IsConfiguringGlobal());
-            Settings::values.vulkan_device.SetValue(vulkan_device_combobox->currentIndex());
-            break;
-        case Settings::RendererBackend::Null:
+                Settings::values.shader_backend.SetGlobal(true);
+                Settings::values.vulkan_device.SetGlobal(false);
+                Settings::values.vulkan_device.SetValue(vulkan_device);
                 break;
             }
         }
+
+        if (ui->nvdec_emulation->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            Settings::values.nvdec_emulation.SetGlobal(true);
+        } else {
+            Settings::values.nvdec_emulation.SetGlobal(false);
+            Settings::values.nvdec_emulation.SetValue(GetCurrentNvdecEmulation());
+        }
+
+        if (ui->bg_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            Settings::values.bg_red.SetGlobal(true);
+            Settings::values.bg_green.SetGlobal(true);
+            Settings::values.bg_blue.SetGlobal(true);
+        } else {
+            Settings::values.bg_red.SetGlobal(false);
+            Settings::values.bg_green.SetGlobal(false);
+            Settings::values.bg_blue.SetGlobal(false);
+            Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));
+            Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));
+            Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));
+        }
+
+        if (ui->fsr_sharpening_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            Settings::values.fsr_sharpening_slider.SetGlobal(true);
+        } else {
+            Settings::values.fsr_sharpening_slider.SetGlobal(false);
+            Settings::values.fsr_sharpening_slider.SetValue(ui->fsr_sharpening_slider->value());
+        }
+    }
 }
 
 void ConfigureGraphics::changeEvent(QEvent* event) {
@@ -426,26 +466,36 @@ void ConfigureGraphics::UpdateBackgroundColorButton(QColor color) {
 }
 
 void ConfigureGraphics::UpdateAPILayout() {
-    bool runtime_lock = !system.IsPoweredOn();
-    bool need_global = !(Settings::IsConfiguringGlobal() || api_restore_global_button->isEnabled());
-    vulkan_device = Settings::values.vulkan_device.GetValue(need_global);
-    shader_backend = Settings::values.shader_backend.GetValue(need_global);
-    vulkan_device_widget->setEnabled(!need_global && runtime_lock);
-    shader_backend_widget->setEnabled(!need_global && runtime_lock);
+    if (!Settings::IsConfiguringGlobal() &&
+        ui->api->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+        vulkan_device = Settings::values.vulkan_device.GetValue(true);
+        shader_backend = Settings::values.shader_backend.GetValue(true);
+        ui->device_widget->setEnabled(false);
+        ui->backend_widget->setEnabled(false);
+    } else {
+        vulkan_device = Settings::values.vulkan_device.GetValue();
+        shader_backend = Settings::values.shader_backend.GetValue();
+        ui->device_widget->setEnabled(true);
+        ui->backend_widget->setEnabled(true);
+    }
 
-    const auto current_backend = GetCurrentGraphicsBackend();
-    const bool is_opengl = current_backend == Settings::RendererBackend::OpenGL;
-    const bool is_vulkan = current_backend == Settings::RendererBackend::Vulkan;
-
-    vulkan_device_widget->setVisible(is_vulkan);
-    shader_backend_widget->setVisible(is_opengl);
-
-    if (is_opengl) {
-        shader_backend_combobox->setCurrentIndex(
-            FindIndex(Settings::EnumMetadata<Settings::ShaderBackend>::Index(),
-                      static_cast<int>(shader_backend)));
-    } else if (is_vulkan && static_cast<int>(vulkan_device) < vulkan_device_combobox->count()) {
-        vulkan_device_combobox->setCurrentIndex(vulkan_device);
+    switch (GetCurrentGraphicsBackend()) {
+    case Settings::RendererBackend::OpenGL:
+        ui->backend->setCurrentIndex(static_cast<u32>(shader_backend));
+        ui->device_widget->setVisible(false);
+        ui->backend_widget->setVisible(true);
+        break;
+    case Settings::RendererBackend::Vulkan:
+        if (static_cast<int>(vulkan_device) < ui->device->count()) {
+            ui->device->setCurrentIndex(vulkan_device);
+        }
+        ui->device_widget->setVisible(true);
+        ui->backend_widget->setVisible(false);
+        break;
+    case Settings::RendererBackend::Null:
+        ui->device_widget->setVisible(false);
+        ui->backend_widget->setVisible(false);
+        break;
     }
 }
 
@@ -465,11 +515,92 @@ void ConfigureGraphics::RetrieveVulkanDevices() {
 }
 
 Settings::RendererBackend ConfigureGraphics::GetCurrentGraphicsBackend() const {
-    if (!Settings::IsConfiguringGlobal() && !api_restore_global_button->isEnabled()) {
-        return Settings::values.renderer_backend.GetValue(true);
+    if (Settings::IsConfiguringGlobal()) {
+        return static_cast<Settings::RendererBackend>(ui->api->currentIndex());
     }
-    return static_cast<Settings::RendererBackend>(
-        combobox_translations.at(Settings::EnumMetadata<Settings::RendererBackend>::Index())
-            .at(api_combobox->currentIndex())
-            .first);
+
+    if (ui->api->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+        Settings::values.renderer_backend.SetGlobal(true);
+        return Settings::values.renderer_backend.GetValue();
+    }
+    Settings::values.renderer_backend.SetGlobal(false);
+    return static_cast<Settings::RendererBackend>(ui->api->currentIndex() -
+                                                  ConfigurationShared::USE_GLOBAL_OFFSET);
+}
+
+Settings::NvdecEmulation ConfigureGraphics::GetCurrentNvdecEmulation() const {
+    if (Settings::IsConfiguringGlobal()) {
+        return static_cast<Settings::NvdecEmulation>(ui->nvdec_emulation->currentIndex());
+    }
+
+    if (ui->nvdec_emulation->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+        Settings::values.nvdec_emulation.SetGlobal(true);
+        return Settings::values.nvdec_emulation.GetValue();
+    }
+    Settings::values.nvdec_emulation.SetGlobal(false);
+    return static_cast<Settings::NvdecEmulation>(ui->nvdec_emulation->currentIndex() -
+                                                 ConfigurationShared::USE_GLOBAL_OFFSET);
+}
+
+void ConfigureGraphics::SetupPerGameUI() {
+    if (Settings::IsConfiguringGlobal()) {
+        ui->api->setEnabled(Settings::values.renderer_backend.UsingGlobal());
+        ui->device->setEnabled(Settings::values.renderer_backend.UsingGlobal());
+        ui->fullscreen_mode_combobox->setEnabled(Settings::values.fullscreen_mode.UsingGlobal());
+        ui->aspect_ratio_combobox->setEnabled(Settings::values.aspect_ratio.UsingGlobal());
+        ui->resolution_combobox->setEnabled(Settings::values.resolution_setup.UsingGlobal());
+        ui->scaling_filter_combobox->setEnabled(Settings::values.scaling_filter.UsingGlobal());
+        ui->fsr_sharpening_slider->setEnabled(Settings::values.fsr_sharpening_slider.UsingGlobal());
+        ui->anti_aliasing_combobox->setEnabled(Settings::values.anti_aliasing.UsingGlobal());
+        ui->use_asynchronous_gpu_emulation->setEnabled(
+            Settings::values.use_asynchronous_gpu_emulation.UsingGlobal());
+        ui->nvdec_emulation->setEnabled(Settings::values.nvdec_emulation.UsingGlobal());
+        ui->accelerate_astc->setEnabled(Settings::values.accelerate_astc.UsingGlobal());
+        ui->use_disk_shader_cache->setEnabled(Settings::values.use_disk_shader_cache.UsingGlobal());
+        ui->bg_button->setEnabled(Settings::values.bg_red.UsingGlobal());
+        ui->fsr_slider_layout->setEnabled(Settings::values.fsr_sharpening_slider.UsingGlobal());
+
+        return;
+    }
+
+    connect(ui->bg_combobox, qOverload<int>(&QComboBox::activated), this, [this](int index) {
+        ui->bg_button->setEnabled(index == 1);
+        ConfigurationShared::SetHighlight(ui->bg_layout, index == 1);
+    });
+
+    connect(ui->fsr_sharpening_combobox, qOverload<int>(&QComboBox::activated), this,
+            [this](int index) {
+                ui->fsr_sharpening_slider->setEnabled(index == 1);
+                ui->fsr_sharpening_value->setEnabled(index == 1);
+                ConfigurationShared::SetHighlight(ui->fsr_sharpening_layout, index == 1);
+            });
+
+    ConfigurationShared::SetColoredTristate(
+        ui->use_disk_shader_cache, Settings::values.use_disk_shader_cache, use_disk_shader_cache);
+    ConfigurationShared::SetColoredTristate(ui->accelerate_astc, Settings::values.accelerate_astc,
+                                            accelerate_astc);
+    ConfigurationShared::SetColoredTristate(ui->use_asynchronous_gpu_emulation,
+                                            Settings::values.use_asynchronous_gpu_emulation,
+                                            use_asynchronous_gpu_emulation);
+
+    ConfigurationShared::SetColoredComboBox(ui->aspect_ratio_combobox, ui->ar_label,
+                                            Settings::values.aspect_ratio.GetValue(true));
+    ConfigurationShared::SetColoredComboBox(
+        ui->fullscreen_mode_combobox, ui->fullscreen_mode_label,
+        static_cast<int>(Settings::values.fullscreen_mode.GetValue(true)));
+    ConfigurationShared::SetColoredComboBox(
+        ui->resolution_combobox, ui->resolution_label,
+        static_cast<int>(Settings::values.resolution_setup.GetValue(true)));
+    ConfigurationShared::SetColoredComboBox(
+        ui->scaling_filter_combobox, ui->scaling_filter_label,
+        static_cast<int>(Settings::values.scaling_filter.GetValue(true)));
+    ConfigurationShared::SetColoredComboBox(
+        ui->anti_aliasing_combobox, ui->anti_aliasing_label,
+        static_cast<int>(Settings::values.anti_aliasing.GetValue(true)));
+    ConfigurationShared::InsertGlobalItem(
+        ui->api, static_cast<int>(Settings::values.renderer_backend.GetValue(true)));
+    ConfigurationShared::InsertGlobalItem(
+        ui->nvdec_emulation, static_cast<int>(Settings::values.nvdec_emulation.GetValue(true)));
+
+    ui->vsync_mode_layout->setVisible(false);
 }

src/yuzu/configuration/configure_graphics.h

@@ -5,8 +5,6 @@
 
 #include <functional>
 #include <memory>
-#include <type_traits>
-#include <typeindex>
 #include <vector>
 #include <QColor>
 #include <QString>
@@ -14,14 +12,10 @@
 #include <qobjectdefs.h>
 #include <vulkan/vulkan_core.h>
 #include "common/common_types.h"
-#include "configuration/shared_translation.h"
 #include "vk_device_info.h"
-#include "yuzu/configuration/configuration_shared.h"
 
-class QPushButton;
 class QEvent;
 class QObject;
-class QComboBox;
 
 namespace Settings {
 enum class NvdecEmulation : u32;
@@ -33,33 +27,31 @@ namespace Core {
 class System;
 }
 
+namespace ConfigurationShared {
+enum class CheckState;
+}
+
 namespace Ui {
 class ConfigureGraphics;
 }
 
-namespace ConfigurationShared {
-class Builder;
-}
+class ConfigureGraphics : public QWidget {
+    Q_OBJECT
 
-class ConfigureGraphics : public ConfigurationShared::Tab {
 public:
     explicit ConfigureGraphics(const Core::System& system_,
                                std::vector<VkDeviceInfo::Record>& records,
                                const std::function<void()>& expose_compute_option_,
-                               std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group,
-                               const ConfigurationShared::Builder& builder,
                                QWidget* parent = nullptr);
     ~ConfigureGraphics() override;
 
-    void ApplyConfiguration() override;
-    void SetConfiguration() override;
+    void ApplyConfiguration();
+    void SetConfiguration();
 
 private:
     void changeEvent(QEvent* event) override;
     void RetranslateUI();
 
-    void Setup(const ConfigurationShared::Builder& builder);
-
     void PopulateVSyncModeSelection();
     void UpdateBackgroundColorButton(QColor color);
     void UpdateAPILayout();
@@ -68,40 +60,34 @@ private:
 
     void RetrieveVulkanDevices();
 
+    void SetFSRIndicatorText(int percentage);
     /* Turns a Vulkan present mode into a textual string for a UI
      * (and eventually for a human to read) */
     const QString TranslateVSyncMode(VkPresentModeKHR mode,
                                      Settings::RendererBackend backend) const;
 
-    Settings::RendererBackend GetCurrentGraphicsBackend() const;
+    void SetupPerGameUI();
 
-    int FindIndex(u32 enumeration, int value) const;
+    Settings::RendererBackend GetCurrentGraphicsBackend() const;
+    Settings::NvdecEmulation GetCurrentNvdecEmulation() const;
 
     std::unique_ptr<Ui::ConfigureGraphics> ui;
     QColor bg_color;
 
-    std::vector<std::function<void(bool)>> apply_funcs{};
+    ConfigurationShared::CheckState use_nvdec_emulation;
+    ConfigurationShared::CheckState accelerate_astc;
+    ConfigurationShared::CheckState use_disk_shader_cache;
+    ConfigurationShared::CheckState use_asynchronous_gpu_emulation;
 
     std::vector<VkDeviceInfo::Record>& records;
     std::vector<QString> vulkan_devices;
     std::vector<std::vector<VkPresentModeKHR>> device_present_modes;
     std::vector<VkPresentModeKHR>
-        vsync_mode_combobox_enum_map{}; //< Keeps track of which present mode corresponds to which
+        vsync_mode_combobox_enum_map; //< Keeps track of which present mode corresponds to which
                                       // selection in the combobox
     u32 vulkan_device{};
     Settings::ShaderBackend shader_backend{};
     const std::function<void()>& expose_compute_option;
 
     const Core::System& system;
-    const ConfigurationShared::ComboboxTranslationMap& combobox_translations;
-    const std::vector<std::pair<u32, QString>>& shader_mapping;
-
-    QPushButton* api_restore_global_button;
-    QComboBox* vulkan_device_combobox;
-    QComboBox* api_combobox;
-    QComboBox* shader_backend_combobox;
-    QComboBox* vsync_mode_combobox;
-    QWidget* vulkan_device_widget;
-    QWidget* api_widget;
-    QWidget* shader_backend_widget;
 };

src/yuzu/configuration/configure_graphics.ui

@@ -27,7 +27,7 @@
        <layout class="QVBoxLayout" name="verticalLayout_3">
         <item>
          <widget class="QWidget" name="api_widget" native="true">
-          <layout class="QHBoxLayout" name="horizontalLayout">
+          <layout class="QGridLayout" name="gridLayout">
            <property name="leftMargin">
             <number>0</number>
            </property>
@@ -40,6 +40,115 @@
            <property name="bottomMargin">
             <number>0</number>
            </property>
+           <property name="horizontalSpacing">
+            <number>6</number>
+           </property>
+           <item row="4" column="0">
+            <widget class="QWidget" name="backend_widget" native="true">
+             <layout class="QHBoxLayout" name="backend_layout">
+              <property name="leftMargin">
+               <number>0</number>
+              </property>
+              <property name="topMargin">
+               <number>0</number>
+              </property>
+              <property name="rightMargin">
+               <number>0</number>
+              </property>
+              <property name="bottomMargin">
+               <number>0</number>
+              </property>
+              <item>
+               <widget class="QLabel" name="backend_label">
+                <property name="text">
+                 <string>Shader Backend:</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <widget class="QComboBox" name="backend"/>
+              </item>
+             </layout>
+            </widget>
+           </item>
+           <item row="2" column="0">
+            <widget class="QWidget" name="device_widget" native="true">
+             <layout class="QHBoxLayout" name="device_layout">
+              <property name="leftMargin">
+               <number>0</number>
+              </property>
+              <property name="topMargin">
+               <number>0</number>
+              </property>
+              <property name="rightMargin">
+               <number>0</number>
+              </property>
+              <property name="bottomMargin">
+               <number>0</number>
+              </property>
+              <item>
+               <widget class="QLabel" name="device_label">
+                <property name="text">
+                 <string>Device:</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <widget class="QComboBox" name="device"/>
+              </item>
+             </layout>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QWidget" name="api_layout_2" native="true">
+             <layout class="QHBoxLayout" name="api_layout">
+              <property name="leftMargin">
+               <number>0</number>
+              </property>
+              <property name="topMargin">
+               <number>0</number>
+              </property>
+              <property name="rightMargin">
+               <number>0</number>
+              </property>
+              <property name="bottomMargin">
+               <number>0</number>
+              </property>
+              <item>
+               <widget class="QLabel" name="api_label">
+                <property name="text">
+                 <string>API:</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <widget class="QComboBox" name="api">
+                <property name="sizePolicy">
+                 <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                  <horstretch>0</horstretch>
+                  <verstretch>0</verstretch>
+                 </sizepolicy>
+                </property>
+                <item>
+                 <property name="text">
+                  <string notr="true">OpenGL</string>
+                 </property>
+                </item>
+                <item>
+                 <property name="text">
+                  <string notr="true">Vulkan</string>
+                 </property>
+                </item>
+                <item>
+                 <property name="text">
+                  <string>None</string>
+                 </property>
+                </item>
+               </widget>
+              </item>
+             </layout>
+            </widget>
+           </item>
           </layout>
          </widget>
         </item>
@@ -59,8 +168,29 @@
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_4">
         <item>
-         <widget class="QWidget" name="graphics_widget" native="true">
-          <layout class="QVBoxLayout" name="verticalLayout">
+         <widget class="QCheckBox" name="use_disk_shader_cache">
+          <property name="text">
+           <string>Use disk pipeline cache</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="use_asynchronous_gpu_emulation">
+          <property name="text">
+           <string>Use asynchronous GPU emulation</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="accelerate_astc">
+          <property name="text">
+           <string>Accelerate ASTC texture decoding</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="vsync_mode_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_4">
            <property name="leftMargin">
             <number>0</number>
            </property>
@@ -73,12 +203,32 @@
            <property name="bottomMargin">
             <number>0</number>
            </property>
+           <item>
+            <widget class="QLabel" name="vsync_mode_label">
+             <property name="text">
+              <string>VSync Mode:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="vsync_mode_combobox">
+             <property name="toolTip">
+              <string>FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen refresh rate.
+FIFO Relaxed is similar to FIFO but allows tearing as it recovers from a slow down.
+Mailbox can have lower latency than FIFO and does not tear but may drop frames.
+Immediate (no synchronization) just presents whatever is available and can exhibit tearing.</string>
+             </property>
+             <property name="currentText">
+              <string/>
+             </property>
+            </widget>
+           </item>
           </layout>
          </widget>
         </item>
         <item>
-         <widget class="QWidget" name="bg_widget" native="true">
-          <layout class="QHBoxLayout" name="bg_layout">
+         <widget class="QWidget" name="nvdec_emulation_widget" native="true">
+          <layout class="QHBoxLayout" name="nvdec_emulation_layout">
            <property name="leftMargin">
             <number>0</number>
            </property>
@@ -92,35 +242,535 @@
             <number>0</number>
            </property>
            <item>
-            <widget class="QLabel" name="label">
-             <property name="sizePolicy">
-              <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
-               <horstretch>0</horstretch>
-               <verstretch>0</verstretch>
-              </sizepolicy>
-             </property>
+            <widget class="QLabel" name="nvdec_emulation_label">
              <property name="text">
-              <string>Background Color:</string>
+              <string>NVDEC emulation:</string>
              </property>
             </widget>
            </item>
            <item>
-            <widget class="QPushButton" name="bg_button">
+            <widget class="QComboBox" name="nvdec_emulation">
+             <item>
+              <property name="text">
+               <string>No Video Output</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>CPU Video Decoding</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>GPU Video Decoding (Default)</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="fullscreen_mode_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_1">
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="fullscreen_mode_label">
+             <property name="text">
+              <string>Fullscreen Mode:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="fullscreen_mode_combobox">
+             <item>
+              <property name="text">
+               <string>Borderless Windowed</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Exclusive Fullscreen</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="aspect_ratio_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="ar_label">
+             <property name="text">
+              <string>Aspect Ratio:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="aspect_ratio_combobox">
+             <item>
+              <property name="text">
+               <string>Default (16:9)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Force 4:3</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Force 21:9</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Force 16:10</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Stretch to Window</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="resolution_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_5">
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="resolution_label">
+             <property name="text">
+              <string>Resolution:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="resolution_combobox">
+             <item>
+              <property name="text">
+               <string>0.5X  (360p/540p) [EXPERIMENTAL]</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>0.75X (540p/810p) [EXPERIMENTAL]</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>1X (720p/1080p)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>1.5X (1080p/1620p) [EXPERIMENTAL]</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>2X (1440p/2160p)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>3X (2160p/3240p)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>4X (2880p/4320p)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>5X (3600p/5400p)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>6X (4320p/6480p)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>7X (5040p/7560p)</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>8X (5760p/8640p)</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="scaling_filter_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_6">
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="scaling_filter_label">
+             <property name="text">
+              <string>Window Adapting Filter:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="scaling_filter_combobox">
+             <item>
+              <property name="text">
+               <string>Nearest Neighbor</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Bilinear</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Bicubic</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Gaussian</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>ScaleForce</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>AMD FidelityFX™️ Super Resolution</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="anti_aliasing_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_7">
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="anti_aliasing_label">
+             <property name="text">
+              <string>Anti-Aliasing Method:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="anti_aliasing_combobox">
+             <item>
+              <property name="text">
+               <string>None</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>FXAA</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>SMAA</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="fsr_sharpening_layout" native="true">
+          <property name="enabled">
+           <bool>true</bool>
+          </property>
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
+          <layout class="QHBoxLayout" name="horizontalLayout">
+           <property name="spacing">
+            <number>6</number>
+           </property>
+           <property name="sizeConstraint">
+            <enum>QLayout::SetDefaultConstraint</enum>
+           </property>
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <layout class="QHBoxLayout" name="fsr_sharpening_label_group">
+             <property name="rightMargin">
+              <number>0</number>
+             </property>
+             <property name="bottomMargin">
+              <number>0</number>
+             </property>
+             <item>
+              <widget class="QComboBox" name="fsr_sharpening_combobox">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
+               <item>
+                <property name="text">
+                 <string>Use global FSR Sharpness</string>
+                </property>
+               </item>
+               <item>
+                <property name="text">
+                 <string>Set FSR Sharpness</string>
+                </property>
+               </item>
+              </widget>
+             </item>
+             <item>
+              <widget class="QLabel" name="fsr_sharpening_label">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
+               <property name="text">
+                <string>FSR Sharpness:</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <spacer name="horizontalSpacer_2">
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>40</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
+            </layout>
+           </item>
+           <item>
+            <layout class="QHBoxLayout" name="fsr_slider_layout">
+             <property name="spacing">
+              <number>6</number>
+             </property>
+             <item>
+              <widget class="QSlider" name="fsr_sharpening_slider">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
+               <property name="baseSize">
+                <size>
+                 <width>0</width>
+                 <height>0</height>
+                </size>
+               </property>
+               <property name="maximum">
+                <number>200</number>
+               </property>
+               <property name="sliderPosition">
+                <number>25</number>
+               </property>
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="invertedAppearance">
+                <bool>true</bool>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QLabel" name="fsr_sharpening_value">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
+               <property name="minimumSize">
+                <size>
+                 <width>32</width>
+                 <height>0</height>
+                </size>
+               </property>
+               <property name="text">
+                <string>100%</string>
+               </property>
+               <property name="alignment">
+                <set>Qt::AlignCenter</set>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="bg_layout" native="true">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <layout class="QHBoxLayout" name="horizontalLayout_3">
+           <property name="spacing">
+            <number>6</number>
+           </property>
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QComboBox" name="bg_combobox">
+             <property name="currentText">
+              <string>Use global background color</string>
+             </property>
+             <property name="currentIndex">
+              <number>0</number>
+             </property>
+             <property name="maxVisibleItems">
+              <number>10</number>
+             </property>
+             <item>
+              <property name="text">
+               <string>Use global background color</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Set background color:</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="bg_label">
+             <property name="text">
+              <string>Background Color:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <spacer name="horizontalSpacer">
+             <property name="orientation">
+              <enum>Qt::Horizontal</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>40</width>
+               <height>20</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item>
+            <widget class="QPushButton" name="bg_button">
              <property name="maximumSize">
               <size>
                <width>40</width>
                <height>16777215</height>
               </size>
              </property>
-             <property name="text">
-              <string/>
-             </property>
             </widget>
            </item>
           </layout>

src/yuzu/configuration/configure_graphics_advanced.cpp

@@ -1,68 +1,104 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <vector>
-#include <QLabel>
-#include <qnamespace.h>
 #include "common/settings.h"
 #include "core/core.h"
 #include "ui_configure_graphics_advanced.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_graphics_advanced.h"
-#include "yuzu/configuration/shared_translation.h"
-#include "yuzu/configuration/shared_widget.h"
 
-ConfigureGraphicsAdvanced::ConfigureGraphicsAdvanced(
-    const Core::System& system_, std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group_,
-    const ConfigurationShared::Builder& builder, QWidget* parent)
-    : Tab(group_, parent), ui{std::make_unique<Ui::ConfigureGraphicsAdvanced>()}, system{system_} {
+ConfigureGraphicsAdvanced::ConfigureGraphicsAdvanced(const Core::System& system_, QWidget* parent)
+    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGraphicsAdvanced>()}, system{system_} {
 
     ui->setupUi(this);
 
-    Setup(builder);
+    SetupPerGameUI();
 
     SetConfiguration();
 
-    checkbox_enable_compute_pipelines->setVisible(false);
+    ui->enable_compute_pipelines_checkbox->setVisible(false);
 }
 
 ConfigureGraphicsAdvanced::~ConfigureGraphicsAdvanced() = default;
 
-void ConfigureGraphicsAdvanced::SetConfiguration() {}
+void ConfigureGraphicsAdvanced::SetConfiguration() {
+    const bool runtime_lock = !system.IsPoweredOn();
+    ui->use_reactive_flushing->setEnabled(runtime_lock);
+    ui->async_present->setEnabled(runtime_lock);
+    ui->renderer_force_max_clock->setEnabled(runtime_lock);
+    ui->async_astc->setEnabled(runtime_lock);
+    ui->astc_recompression_combobox->setEnabled(runtime_lock);
+    ui->use_asynchronous_shaders->setEnabled(runtime_lock);
+    ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
+    ui->enable_compute_pipelines_checkbox->setEnabled(runtime_lock);
 
-void ConfigureGraphicsAdvanced::Setup(const ConfigurationShared::Builder& builder) {
-    auto& layout = *ui->populate_target->layout();
-    std::map<u32, QWidget*> hold{}; // A map will sort the data for us
+    ui->async_present->setChecked(Settings::values.async_presentation.GetValue());
+    ui->renderer_force_max_clock->setChecked(Settings::values.renderer_force_max_clock.GetValue());
+    ui->use_reactive_flushing->setChecked(Settings::values.use_reactive_flushing.GetValue());
+    ui->async_astc->setChecked(Settings::values.async_astc.GetValue());
+    ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
+    ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
+    ui->use_vulkan_driver_pipeline_cache->setChecked(
+        Settings::values.use_vulkan_driver_pipeline_cache.GetValue());
+    ui->enable_compute_pipelines_checkbox->setChecked(
+        Settings::values.enable_compute_pipelines.GetValue());
+    ui->use_video_framerate_checkbox->setChecked(Settings::values.use_video_framerate.GetValue());
+    ui->barrier_feedback_loops_checkbox->setChecked(
+        Settings::values.barrier_feedback_loops.GetValue());
 
-    for (auto setting :
-         Settings::values.linkage.by_category[Settings::Category::RendererAdvanced]) {
-        ConfigurationShared::Widget* widget = builder.BuildWidget(setting, apply_funcs);
-
-        if (widget == nullptr) {
-            continue;
-        }
-        if (!widget->Valid()) {
-            widget->deleteLater();
-            continue;
-        }
-
-        hold.emplace(setting->Id(), widget);
-
-        // Keep track of enable_compute_pipelines so we can display it when needed
-        if (setting->Id() == Settings::values.enable_compute_pipelines.Id()) {
-            checkbox_enable_compute_pipelines = widget;
-        }
-    }
-    for (const auto& [id, widget] : hold) {
-        layout.addWidget(widget);
+    if (Settings::IsConfiguringGlobal()) {
+        ui->gpu_accuracy->setCurrentIndex(
+            static_cast<int>(Settings::values.gpu_accuracy.GetValue()));
+        ui->anisotropic_filtering_combobox->setCurrentIndex(
+            Settings::values.max_anisotropy.GetValue());
+        ui->astc_recompression_combobox->setCurrentIndex(
+            static_cast<int>(Settings::values.astc_recompression.GetValue()));
+    } else {
+        ConfigurationShared::SetPerGameSetting(ui->gpu_accuracy, &Settings::values.gpu_accuracy);
+        ConfigurationShared::SetPerGameSetting(ui->anisotropic_filtering_combobox,
+                                               &Settings::values.max_anisotropy);
+        ConfigurationShared::SetPerGameSetting(ui->astc_recompression_combobox,
+                                               &Settings::values.astc_recompression);
+        ConfigurationShared::SetHighlight(ui->label_gpu_accuracy,
+                                          !Settings::values.gpu_accuracy.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->af_label,
+                                          !Settings::values.max_anisotropy.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->label_astc_recompression,
+                                          !Settings::values.astc_recompression.UsingGlobal());
     }
 }
 
 void ConfigureGraphicsAdvanced::ApplyConfiguration() {
-    const bool is_powered_on = system.IsPoweredOn();
-    for (const auto& func : apply_funcs) {
-        func(is_powered_on);
-    }
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.gpu_accuracy, ui->gpu_accuracy);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.async_presentation,
+                                             ui->async_present, async_present);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.renderer_force_max_clock,
+                                             ui->renderer_force_max_clock,
+                                             renderer_force_max_clock);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
+                                             ui->anisotropic_filtering_combobox);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_reactive_flushing,
+                                             ui->use_reactive_flushing, use_reactive_flushing);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.async_astc, ui->async_astc,
+                                             async_astc);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.astc_recompression,
+                                             ui->astc_recompression_combobox);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders,
+                                             ui->use_asynchronous_shaders,
+                                             use_asynchronous_shaders);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_fast_gpu_time,
+                                             ui->use_fast_gpu_time, use_fast_gpu_time);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vulkan_driver_pipeline_cache,
+                                             ui->use_vulkan_driver_pipeline_cache,
+                                             use_vulkan_driver_pipeline_cache);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.enable_compute_pipelines,
+                                             ui->enable_compute_pipelines_checkbox,
+                                             enable_compute_pipelines);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_video_framerate,
+                                             ui->use_video_framerate_checkbox, use_video_framerate);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.barrier_feedback_loops,
+                                             ui->barrier_feedback_loops_checkbox,
+                                             barrier_feedback_loops);
 }
 
 void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {
@@ -77,6 +113,71 @@ void ConfigureGraphicsAdvanced::RetranslateUI() {
     ui->retranslateUi(this);
 }
 
-void ConfigureGraphicsAdvanced::ExposeComputeOption() {
-    checkbox_enable_compute_pipelines->setVisible(true);
+void ConfigureGraphicsAdvanced::SetupPerGameUI() {
+    // Disable if not global (only happens during game)
+    if (Settings::IsConfiguringGlobal()) {
+        ui->gpu_accuracy->setEnabled(Settings::values.gpu_accuracy.UsingGlobal());
+        ui->async_present->setEnabled(Settings::values.async_presentation.UsingGlobal());
+        ui->renderer_force_max_clock->setEnabled(
+            Settings::values.renderer_force_max_clock.UsingGlobal());
+        ui->use_reactive_flushing->setEnabled(Settings::values.use_reactive_flushing.UsingGlobal());
+        ui->async_astc->setEnabled(Settings::values.async_astc.UsingGlobal());
+        ui->astc_recompression_combobox->setEnabled(
+            Settings::values.astc_recompression.UsingGlobal());
+        ui->use_asynchronous_shaders->setEnabled(
+            Settings::values.use_asynchronous_shaders.UsingGlobal());
+        ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal());
+        ui->use_vulkan_driver_pipeline_cache->setEnabled(
+            Settings::values.use_vulkan_driver_pipeline_cache.UsingGlobal());
+        ui->anisotropic_filtering_combobox->setEnabled(
+            Settings::values.max_anisotropy.UsingGlobal());
+        ui->enable_compute_pipelines_checkbox->setEnabled(
+            Settings::values.enable_compute_pipelines.UsingGlobal());
+        ui->use_video_framerate_checkbox->setEnabled(
+            Settings::values.use_video_framerate.UsingGlobal());
+        ui->barrier_feedback_loops_checkbox->setEnabled(
+            Settings::values.barrier_feedback_loops.UsingGlobal());
+
+        return;
+    }
+
+    ConfigurationShared::SetColoredTristate(ui->async_present, Settings::values.async_presentation,
+                                            async_present);
+    ConfigurationShared::SetColoredTristate(ui->renderer_force_max_clock,
+                                            Settings::values.renderer_force_max_clock,
+                                            renderer_force_max_clock);
+    ConfigurationShared::SetColoredTristate(
+        ui->use_reactive_flushing, Settings::values.use_reactive_flushing, use_reactive_flushing);
+    ConfigurationShared::SetColoredTristate(ui->async_astc, Settings::values.async_astc,
+                                            async_astc);
+    ConfigurationShared::SetColoredTristate(ui->use_asynchronous_shaders,
+                                            Settings::values.use_asynchronous_shaders,
+                                            use_asynchronous_shaders);
+    ConfigurationShared::SetColoredTristate(ui->use_fast_gpu_time,
+                                            Settings::values.use_fast_gpu_time, use_fast_gpu_time);
+    ConfigurationShared::SetColoredTristate(ui->use_vulkan_driver_pipeline_cache,
+                                            Settings::values.use_vulkan_driver_pipeline_cache,
+                                            use_vulkan_driver_pipeline_cache);
+    ConfigurationShared::SetColoredTristate(ui->enable_compute_pipelines_checkbox,
+                                            Settings::values.enable_compute_pipelines,
+                                            enable_compute_pipelines);
+    ConfigurationShared::SetColoredTristate(ui->use_video_framerate_checkbox,
+                                            Settings::values.use_video_framerate,
+                                            use_video_framerate);
+    ConfigurationShared::SetColoredTristate(ui->barrier_feedback_loops_checkbox,
+                                            Settings::values.barrier_feedback_loops,
+                                            barrier_feedback_loops);
+    ConfigurationShared::SetColoredComboBox(
+        ui->gpu_accuracy, ui->label_gpu_accuracy,
+        static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));
+    ConfigurationShared::SetColoredComboBox(
+        ui->anisotropic_filtering_combobox, ui->af_label,
+        static_cast<int>(Settings::values.max_anisotropy.GetValue(true)));
+    ConfigurationShared::SetColoredComboBox(
+        ui->astc_recompression_combobox, ui->label_astc_recompression,
+        static_cast<int>(Settings::values.astc_recompression.GetValue(true)));
+}
+
+void ConfigureGraphicsAdvanced::ExposeComputeOption() {
+    ui->enable_compute_pipelines_checkbox->setVisible(true);
 }

src/yuzu/configuration/configure_graphics_advanced.h

@@ -4,44 +4,51 @@
 #pragma once
 
 #include <memory>
-#include <vector>
 #include <QWidget>
-#include "yuzu/configuration/configuration_shared.h"
 
 namespace Core {
 class System;
 }
 
+namespace ConfigurationShared {
+enum class CheckState;
+}
+
 namespace Ui {
 class ConfigureGraphicsAdvanced;
 }
 
-namespace ConfigurationShared {
-class Builder;
-}
+class ConfigureGraphicsAdvanced : public QWidget {
+    Q_OBJECT
 
-class ConfigureGraphicsAdvanced : public ConfigurationShared::Tab {
 public:
-    explicit ConfigureGraphicsAdvanced(
-        const Core::System& system_, std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group,
-        const ConfigurationShared::Builder& builder, QWidget* parent = nullptr);
+    explicit ConfigureGraphicsAdvanced(const Core::System& system_, QWidget* parent = nullptr);
     ~ConfigureGraphicsAdvanced() override;
 
-    void ApplyConfiguration() override;
-    void SetConfiguration() override;
+    void ApplyConfiguration();
+    void SetConfiguration();
 
     void ExposeComputeOption();
 
 private:
-    void Setup(const ConfigurationShared::Builder& builder);
     void changeEvent(QEvent* event) override;
     void RetranslateUI();
 
+    void SetupPerGameUI();
+
     std::unique_ptr<Ui::ConfigureGraphicsAdvanced> ui;
 
+    ConfigurationShared::CheckState async_present;
+    ConfigurationShared::CheckState renderer_force_max_clock;
+    ConfigurationShared::CheckState use_vsync;
+    ConfigurationShared::CheckState async_astc;
+    ConfigurationShared::CheckState use_reactive_flushing;
+    ConfigurationShared::CheckState use_asynchronous_shaders;
+    ConfigurationShared::CheckState use_fast_gpu_time;
+    ConfigurationShared::CheckState use_vulkan_driver_pipeline_cache;
+    ConfigurationShared::CheckState enable_compute_pipelines;
+    ConfigurationShared::CheckState use_video_framerate;
+    ConfigurationShared::CheckState barrier_feedback_loops;
+
     const Core::System& system;
-
-    std::vector<std::function<void(bool)>> apply_funcs;
-
-    QWidget* checkbox_enable_compute_pipelines{};
 };

src/yuzu/configuration/configure_graphics_advanced.ui

@@ -26,8 +26,8 @@
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_3">
         <item>
-         <widget class="QWidget" name="populate_target" native="true">
-          <layout class="QVBoxLayout" name="verticalLayout">
+         <widget class="QWidget" name="gpu_accuracy_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
            <property name="leftMargin">
             <number>0</number>
            </property>
@@ -40,6 +40,233 @@
            <property name="bottomMargin">
             <number>0</number>
            </property>
+           <item>
+            <widget class="QLabel" name="label_gpu_accuracy">
+             <property name="text">
+              <string>Accuracy Level:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="gpu_accuracy">
+             <item>
+              <property name="text">
+               <string notr="true">Normal</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string notr="true">High</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string notr="true">Extreme(very slow)</string>
+              </property>
+             </item>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="astc_recompression_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_3">
+            <property name="leftMargin">
+              <number>0</number>
+            </property>
+            <property name="topMargin">
+              <number>0</number>
+            </property>
+            <property name="rightMargin">
+              <number>0</number>
+            </property>
+            <property name="bottomMargin">
+              <number>0</number>
+            </property>
+            <item>
+              <widget class="QLabel" name="label_astc_recompression">
+              <property name="text">
+                <string>ASTC recompression:</string>
+              </property>
+              </widget>
+            </item>
+            <item>
+              <widget class="QComboBox" name="astc_recompression_combobox">
+                <item>
+                <property name="text">
+                  <string>Uncompressed (Best quality)</string>
+                </property>
+                </item>
+                <item>
+                <property name="text">
+                  <string>BC1 (Low quality)</string>
+                </property>
+                </item>
+                <item>
+                <property name="text">
+                  <string>BC3 (Medium quality)</string>
+                </property>
+                </item>
+              </widget>
+            </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="async_present">
+          <property name="text">
+           <string>Enable asynchronous presentation (Vulkan only)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="renderer_force_max_clock">
+          <property name="toolTip">
+           <string>Runs work in the background while waiting for graphics commands to keep the GPU from lowering its clock speed.</string>
+          </property>
+          <property name="text">
+           <string>Force maximum clocks (Vulkan only)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="async_astc">
+          <property name="toolTip">
+           <string>Enables asynchronous ASTC texture decoding, which may reduce load time stutter. This feature is experimental.</string>
+          </property>
+          <property name="text">
+           <string>Decode ASTC textures asynchronously (Hack)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="use_reactive_flushing">
+          <property name="toolTip">
+           <string>Uses reactive flushing instead of predictive flushing. Allowing a more accurate syncing of memory.</string>
+          </property>
+          <property name="text">
+           <string>Enable Reactive Flushing</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="use_asynchronous_shaders">
+          <property name="toolTip">
+           <string>Enables asynchronous shader compilation, which may reduce shader stutter. This feature is experimental.</string>
+          </property>
+          <property name="text">
+           <string>Use asynchronous shader building (Hack)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="use_fast_gpu_time">
+          <property name="toolTip">
+           <string>Enables Fast GPU Time. This option will force most games to run at their highest native resolution.</string>
+          </property>
+          <property name="text">
+           <string>Use Fast GPU Time (Hack)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="use_vulkan_driver_pipeline_cache">
+          <property name="toolTip">
+           <string>Enables GPU vendor-specific pipeline cache. This option can improve shader loading time significantly in cases where the Vulkan driver does not store pipeline cache files internally.</string>
+          </property>
+          <property name="text">
+           <string>Use Vulkan pipeline cache</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="enable_compute_pipelines_checkbox">
+          <property name="toolTip">
+           <string>Enable compute pipelines, required by some games. This setting only exists for Intel proprietary drivers, and may crash if enabled.
+Compute pipelines are always enabled on all other drivers.</string>
+          </property>
+          <property name="text">
+           <string>Enable Compute Pipelines (Intel Vulkan only)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="use_video_framerate_checkbox">
+          <property name="toolTip">
+           <string>Run the game at normal speed during video playback, even when the framerate is unlocked.</string>
+          </property>
+          <property name="text">
+           <string>Sync to framerate of video playback</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="barrier_feedback_loops_checkbox">
+          <property name="toolTip">
+           <string>Improves rendering of transparency effects in specific games.</string>
+          </property>
+          <property name="text">
+           <string>Barrier feedback loops</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="af_layout" native="true">
+          <layout class="QHBoxLayout" name="horizontalLayout_1">
+           <property name="leftMargin">
+            <number>0</number>
+           </property>
+           <property name="topMargin">
+            <number>0</number>
+           </property>
+           <property name="rightMargin">
+            <number>0</number>
+           </property>
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="af_label">
+             <property name="text">
+              <string>Anisotropic Filtering:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QComboBox" name="anisotropic_filtering_combobox">
+             <item>
+              <property name="text">
+               <string>Automatic</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>Default</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>2x</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>4x</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>8x</string>
+              </property>
+             </item>
+             <item>
+              <property name="text">
+               <string>16x</string>
+              </property>
+             </item>
+            </widget>
+           </item>
           </layout>
          </widget>
         </item>

src/yuzu/configuration/configure_per_game.cpp

@@ -17,7 +17,6 @@
 #include <QTimer>
 
 #include "common/fs/fs_util.h"
-#include "configuration/shared_widget.h"
 #include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -25,9 +24,9 @@
 #include "core/loader/loader.h"
 #include "ui_configure_per_game.h"
 #include "yuzu/configuration/config.h"
-#include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_audio.h"
 #include "yuzu/configuration/configure_cpu.h"
+#include "yuzu/configuration/configure_general.h"
 #include "yuzu/configuration/configure_graphics.h"
 #include "yuzu/configuration/configure_graphics_advanced.h"
 #include "yuzu/configuration/configure_input_per_game.h"
@@ -42,28 +41,26 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
                                    std::vector<VkDeviceInfo::Record>& vk_device_records,
                                    Core::System& system_)
     : QDialog(parent),
-      ui(std::make_unique<Ui::ConfigurePerGame>()), title_id{title_id_}, system{system_},
-      builder{std::make_unique<ConfigurationShared::Builder>(this, !system_.IsPoweredOn())},
-      tab_group{std::make_shared<std::vector<ConfigurationShared::Tab*>>()} {
+      ui(std::make_unique<Ui::ConfigurePerGame>()), title_id{title_id_}, system{system_} {
     const auto file_path = std::filesystem::path(Common::FS::ToU8String(file_name));
     const auto config_file_name = title_id == 0 ? Common::FS::PathToUTF8String(file_path.filename())
                                                 : fmt::format("{:016X}", title_id);
     game_config = std::make_unique<Config>(config_file_name, Config::ConfigType::PerGameConfig);
 
     addons_tab = std::make_unique<ConfigurePerGameAddons>(system_, this);
-    audio_tab = std::make_unique<ConfigureAudio>(system_, tab_group, *builder, this);
-    cpu_tab = std::make_unique<ConfigureCpu>(system_, tab_group, *builder, this);
-    graphics_advanced_tab =
-        std::make_unique<ConfigureGraphicsAdvanced>(system_, tab_group, *builder, this);
+    audio_tab = std::make_unique<ConfigureAudio>(system_, this);
+    cpu_tab = std::make_unique<ConfigureCpu>(system_, this);
+    general_tab = std::make_unique<ConfigureGeneral>(system_, this);
+    graphics_advanced_tab = std::make_unique<ConfigureGraphicsAdvanced>(system_, this);
     graphics_tab = std::make_unique<ConfigureGraphics>(
-        system_, vk_device_records, [&]() { graphics_advanced_tab->ExposeComputeOption(); },
-        tab_group, *builder, this);
+        system_, vk_device_records, [&]() { graphics_advanced_tab->ExposeComputeOption(); }, this);
     input_tab = std::make_unique<ConfigureInputPerGame>(system_, game_config.get(), this);
-    system_tab = std::make_unique<ConfigureSystem>(system_, tab_group, *builder, this);
+    system_tab = std::make_unique<ConfigureSystem>(system_, this);
 
     ui->setupUi(this);
 
     ui->tabWidget->addTab(addons_tab.get(), tr("Add-Ons"));
+    ui->tabWidget->addTab(general_tab.get(), tr("General"));
     ui->tabWidget->addTab(system_tab.get(), tr("System"));
     ui->tabWidget->addTab(cpu_tab.get(), tr("CPU"));
     ui->tabWidget->addTab(graphics_tab.get(), tr("Graphics"));
@@ -91,10 +88,13 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
 ConfigurePerGame::~ConfigurePerGame() = default;
 
 void ConfigurePerGame::ApplyConfiguration() {
-    for (const auto tab : *tab_group) {
-        tab->ApplyConfiguration();
-    }
     addons_tab->ApplyConfiguration();
+    general_tab->ApplyConfiguration();
+    cpu_tab->ApplyConfiguration();
+    system_tab->ApplyConfiguration();
+    graphics_tab->ApplyConfiguration();
+    graphics_advanced_tab->ApplyConfiguration();
+    audio_tab->ApplyConfiguration();
     input_tab->ApplyConfiguration();
 
     system.ApplySettings();

src/yuzu/configuration/configure_per_game.h

@@ -10,12 +10,9 @@
 #include <QDialog>
 #include <QList>
 
-#include "configuration/shared_widget.h"
 #include "core/file_sys/vfs_types.h"
 #include "vk_device_info.h"
 #include "yuzu/configuration/config.h"
-#include "yuzu/configuration/configuration_shared.h"
-#include "yuzu/configuration/shared_translation.h"
 
 namespace Core {
 class System;
@@ -28,6 +25,7 @@ class InputSubsystem;
 class ConfigurePerGameAddons;
 class ConfigureAudio;
 class ConfigureCpu;
+class ConfigureGeneral;
 class ConfigureGraphics;
 class ConfigureGraphicsAdvanced;
 class ConfigureInputPerGame;
@@ -75,12 +73,11 @@ private:
     std::unique_ptr<Config> game_config;
 
     Core::System& system;
-    std::unique_ptr<ConfigurationShared::Builder> builder;
-    std::shared_ptr<std::vector<ConfigurationShared::Tab*>> tab_group;
 
     std::unique_ptr<ConfigurePerGameAddons> addons_tab;
     std::unique_ptr<ConfigureAudio> audio_tab;
     std::unique_ptr<ConfigureCpu> cpu_tab;
+    std::unique_ptr<ConfigureGeneral> general_tab;
     std::unique_ptr<ConfigureGraphicsAdvanced> graphics_advanced_tab;
     std::unique_ptr<ConfigureGraphics> graphics_tab;
     std::unique_ptr<ConfigureInputPerGame> input_tab;

src/yuzu/configuration/configure_per_game.ui

@@ -2,14 +2,6 @@
 <ui version="4.0">
  <class>ConfigurePerGame</class>
  <widget class="QDialog" name="ConfigurePerGame">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>900</width>
-    <height>607</height>
-   </rect>
-  </property>
   <property name="minimumSize">
    <size>
     <width>900</width>
@@ -232,15 +224,6 @@
      </item>
     </layout>
    </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout_2">
-     <item>
-      <widget class="QLabel" name="label_8">
-       <property name="text">
-        <string>Some settings are only available when a game is not running.</string>
-       </property>
-      </widget>
-     </item>
    <item>
     <widget class="QDialogButtonBox" name="buttonBox">
      <property name="sizePolicy">
@@ -258,8 +241,6 @@
     </widget>
    </item>
   </layout>
-   </item>
-  </layout>
  </widget>
  <resources/>
  <connections>

src/yuzu/configuration/configure_system.cpp

@@ -3,23 +3,16 @@
 
 #include <chrono>
 #include <optional>
-#include <vector>
 
-#include <QCheckBox>
-#include <QComboBox>
-#include <QDateTimeEdit>
 #include <QFileDialog>
 #include <QGraphicsItem>
-#include <QLineEdit>
 #include <QMessageBox>
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/hle/service/time/time_manager.h"
 #include "ui_configure_system.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_system.h"
-#include "yuzu/configuration/shared_widget.h"
 
 constexpr std::array<u32, 7> LOCALE_BLOCKLIST{
     // pzzefezrpnkzeidfej
@@ -44,32 +37,44 @@ static bool IsValidLocale(u32 region_index, u32 language_index) {
     return ((LOCALE_BLOCKLIST.at(region_index) >> language_index) & 1) == 0;
 }
 
-ConfigureSystem::ConfigureSystem(Core::System& system_,
-                                 std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group_,
-                                 const ConfigurationShared::Builder& builder, QWidget* parent)
-    : Tab(group_, parent), ui{std::make_unique<Ui::ConfigureSystem>()}, system{system_} {
+ConfigureSystem::ConfigureSystem(Core::System& system_, QWidget* parent)
+    : QWidget(parent), ui{std::make_unique<Ui::ConfigureSystem>()}, system{system_} {
     ui->setupUi(this);
 
-    Setup(builder);
+    connect(ui->rng_seed_checkbox, &QCheckBox::stateChanged, this, [this](int state) {
+        ui->rng_seed_edit->setEnabled(state == Qt::Checked);
+        if (state != Qt::Checked) {
+            ui->rng_seed_edit->setText(QStringLiteral("00000000"));
+        }
+    });
 
-    const auto locale_check = [this]() {
-        const auto region_index = combo_region->currentIndex();
-        const auto language_index = combo_language->currentIndex();
+    connect(ui->custom_rtc_checkbox, &QCheckBox::stateChanged, this, [this](int state) {
+        ui->custom_rtc_edit->setEnabled(state == Qt::Checked);
+        if (state != Qt::Checked) {
+            ui->custom_rtc_edit->setDateTime(QDateTime::currentDateTime());
+        }
+    });
+
+    const auto locale_check = [this](int index) {
+        const auto region_index = ConfigurationShared::GetComboboxIndex(
+            Settings::values.region_index.GetValue(true), ui->combo_region);
+        const auto language_index = ConfigurationShared::GetComboboxIndex(
+            Settings::values.language_index.GetValue(true), ui->combo_language);
         const bool valid_locale = IsValidLocale(region_index, language_index);
         ui->label_warn_invalid_locale->setVisible(!valid_locale);
         if (!valid_locale) {
             ui->label_warn_invalid_locale->setText(
                 tr("Warning: \"%1\" is not a valid language for region \"%2\"")
-                    .arg(combo_language->currentText())
-                    .arg(combo_region->currentText()));
+                    .arg(ui->combo_language->currentText())
+                    .arg(ui->combo_region->currentText()));
         }
     };
 
-    connect(combo_language, qOverload<int>(&QComboBox::currentIndexChanged), this, locale_check);
-    connect(combo_region, qOverload<int>(&QComboBox::currentIndexChanged), this, locale_check);
+    connect(ui->combo_language, qOverload<int>(&QComboBox::currentIndexChanged), this,
+            locale_check);
+    connect(ui->combo_region, qOverload<int>(&QComboBox::currentIndexChanged), this, locale_check);
 
-    ui->label_warn_invalid_locale->setVisible(false);
-    locale_check();
+    SetupPerGameUI();
 
     SetConfiguration();
 }
@@ -88,66 +93,137 @@ void ConfigureSystem::RetranslateUI() {
     ui->retranslateUi(this);
 }
 
-void ConfigureSystem::Setup(const ConfigurationShared::Builder& builder) {
-    auto& core_layout = *ui->core_widget->layout();
-    auto& system_layout = *ui->system_widget->layout();
+void ConfigureSystem::SetConfiguration() {
+    enabled = !system.IsPoweredOn();
+    const auto rng_seed =
+        QStringLiteral("%1")
+            .arg(Settings::values.rng_seed.GetValue().value_or(0), 8, 16, QLatin1Char{'0'})
+            .toUpper();
+    const auto rtc_time = Settings::values.custom_rtc.value_or(QDateTime::currentSecsSinceEpoch());
 
-    std::map<u32, QWidget*> core_hold{};
-    std::map<u32, QWidget*> system_hold{};
+    ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.GetValue().has_value());
+    ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.GetValue().has_value() &&
+                                  Settings::values.rng_seed.UsingGlobal());
+    ui->rng_seed_edit->setText(rng_seed);
 
-    std::vector<Settings::BasicSetting*> settings;
-    auto push = [&settings](auto& list) {
-        for (auto setting : list) {
-            settings.push_back(setting);
-        }
-    };
+    ui->custom_rtc_checkbox->setChecked(Settings::values.custom_rtc.has_value());
+    ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.has_value());
+    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time));
+    ui->device_name_edit->setText(
+        QString::fromUtf8(Settings::values.device_name.GetValue().c_str()));
+    ui->use_unsafe_extended_memory_layout->setEnabled(enabled);
+    ui->use_unsafe_extended_memory_layout->setChecked(
+        Settings::values.use_unsafe_extended_memory_layout.GetValue());
 
-    push(Settings::values.linkage.by_category[Settings::Category::Core]);
-    push(Settings::values.linkage.by_category[Settings::Category::System]);
+    if (Settings::IsConfiguringGlobal()) {
+        ui->combo_language->setCurrentIndex(Settings::values.language_index.GetValue());
+        ui->combo_region->setCurrentIndex(Settings::values.region_index.GetValue());
+        ui->combo_time_zone->setCurrentIndex(Settings::values.time_zone_index.GetValue());
+    } else {
+        ConfigurationShared::SetPerGameSetting(ui->combo_language,
+                                               &Settings::values.language_index);
+        ConfigurationShared::SetPerGameSetting(ui->combo_region, &Settings::values.region_index);
+        ConfigurationShared::SetPerGameSetting(ui->combo_time_zone,
+                                               &Settings::values.time_zone_index);
 
-    for (auto setting : settings) {
-        ConfigurationShared::Widget* widget = builder.BuildWidget(setting, apply_funcs);
-
-        if (widget == nullptr) {
-            continue;
-        }
-        if (!widget->Valid()) {
-            widget->deleteLater();
-            continue;
-        }
-
-        if (setting->Id() == Settings::values.region_index.Id()) {
-            // Keep track of the region_index (and langauge_index) combobox to validate the selected
-            // settings
-            combo_region = widget->combobox;
-        } else if (setting->Id() == Settings::values.language_index.Id()) {
-            combo_language = widget->combobox;
-        }
-
-        switch (setting->GetCategory()) {
-        case Settings::Category::Core:
-            core_hold.emplace(setting->Id(), widget);
-            break;
-        case Settings::Category::System:
-            system_hold.emplace(setting->Id(), widget);
-            break;
-        default:
-            widget->deleteLater();
-        }
-    }
-    for (const auto& [label, widget] : core_hold) {
-        core_layout.addWidget(widget);
-    }
-    for (const auto& [id, widget] : system_hold) {
-        system_layout.addWidget(widget);
+        ConfigurationShared::SetHighlight(ui->label_language,
+                                          !Settings::values.language_index.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->label_region,
+                                          !Settings::values.region_index.UsingGlobal());
+        ConfigurationShared::SetHighlight(ui->label_timezone,
+                                          !Settings::values.time_zone_index.UsingGlobal());
     }
 }
 
-void ConfigureSystem::SetConfiguration() {}
+void ConfigureSystem::ReadSystemSettings() {}
 
 void ConfigureSystem::ApplyConfiguration() {
-    const bool powered_on = system.IsPoweredOn();
-    for (const auto& func : apply_funcs) {
-        func(powered_on);
+    // Allow setting custom RTC even if system is powered on,
+    // to allow in-game time to be fast forwarded
+    if (Settings::IsConfiguringGlobal()) {
+        if (ui->custom_rtc_checkbox->isChecked()) {
+            Settings::values.custom_rtc = ui->custom_rtc_edit->dateTime().toSecsSinceEpoch();
+            if (system.IsPoweredOn()) {
+                const s64 posix_time{*Settings::values.custom_rtc};
+                system.GetTimeManager().UpdateLocalSystemClockTime(posix_time);
+            }
+        } else {
+            Settings::values.custom_rtc = std::nullopt;
+        }
+    }
+
+    Settings::values.device_name = ui->device_name_edit->text().toStdString();
+
+    if (!enabled) {
+        return;
+    }
+
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.language_index, ui->combo_language);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.region_index, ui->combo_region);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.time_zone_index,
+                                             ui->combo_time_zone);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_unsafe_extended_memory_layout,
+                                             ui->use_unsafe_extended_memory_layout,
+                                             use_unsafe_extended_memory_layout);
+
+    if (Settings::IsConfiguringGlobal()) {
+        // Guard if during game and set to game-specific value
+        if (Settings::values.rng_seed.UsingGlobal()) {
+            if (ui->rng_seed_checkbox->isChecked()) {
+                Settings::values.rng_seed.SetValue(ui->rng_seed_edit->text().toUInt(nullptr, 16));
+            } else {
+                Settings::values.rng_seed.SetValue(std::nullopt);
+            }
+        }
+    } else {
+        switch (use_rng_seed) {
+        case ConfigurationShared::CheckState::On:
+        case ConfigurationShared::CheckState::Off:
+            Settings::values.rng_seed.SetGlobal(false);
+            if (ui->rng_seed_checkbox->isChecked()) {
+                Settings::values.rng_seed.SetValue(ui->rng_seed_edit->text().toUInt(nullptr, 16));
+            } else {
+                Settings::values.rng_seed.SetValue(std::nullopt);
+            }
+            break;
+        case ConfigurationShared::CheckState::Global:
+            Settings::values.rng_seed.SetGlobal(false);
+            Settings::values.rng_seed.SetValue(std::nullopt);
+            Settings::values.rng_seed.SetGlobal(true);
+            break;
+        case ConfigurationShared::CheckState::Count:
+            break;
+        }
     }
 }
+
+void ConfigureSystem::SetupPerGameUI() {
+    if (Settings::IsConfiguringGlobal()) {
+        ui->combo_language->setEnabled(Settings::values.language_index.UsingGlobal());
+        ui->combo_region->setEnabled(Settings::values.region_index.UsingGlobal());
+        ui->combo_time_zone->setEnabled(Settings::values.time_zone_index.UsingGlobal());
+        ui->rng_seed_checkbox->setEnabled(Settings::values.rng_seed.UsingGlobal());
+        ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.UsingGlobal());
+
+        return;
+    }
+
+    ConfigurationShared::SetColoredComboBox(ui->combo_language, ui->label_language,
+                                            Settings::values.language_index.GetValue(true));
+    ConfigurationShared::SetColoredComboBox(ui->combo_region, ui->label_region,
+                                            Settings::values.region_index.GetValue(true));
+    ConfigurationShared::SetColoredComboBox(ui->combo_time_zone, ui->label_timezone,
+                                            Settings::values.time_zone_index.GetValue(true));
+
+    ConfigurationShared::SetColoredTristate(
+        ui->rng_seed_checkbox, Settings::values.rng_seed.UsingGlobal(),
+        Settings::values.rng_seed.GetValue().has_value(),
+        Settings::values.rng_seed.GetValue(true).has_value(), use_rng_seed);
+
+    ConfigurationShared::SetColoredTristate(ui->use_unsafe_extended_memory_layout,
+                                            Settings::values.use_unsafe_extended_memory_layout,
+                                            use_unsafe_extended_memory_layout);
+
+    ui->custom_rtc_checkbox->setVisible(false);
+    ui->custom_rtc_edit->setVisible(false);
+}

src/yuzu/configuration/configure_system.h

@@ -3,53 +3,45 @@
 
 #pragma once
 
-#include <functional>
 #include <memory>
-#include <vector>
 
 #include <QWidget>
-#include "yuzu/configuration/configuration_shared.h"
 
-class QCheckBox;
-class QLineEdit;
-class QComboBox;
-class QDateTimeEdit;
 namespace Core {
 class System;
 }
 
+namespace ConfigurationShared {
+enum class CheckState;
+}
+
 namespace Ui {
 class ConfigureSystem;
 }
 
-namespace ConfigurationShared {
-class Builder;
-}
+class ConfigureSystem : public QWidget {
+    Q_OBJECT
 
-class ConfigureSystem : public ConfigurationShared::Tab {
 public:
-    explicit ConfigureSystem(Core::System& system_,
-                             std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group,
-                             const ConfigurationShared::Builder& builder,
-                             QWidget* parent = nullptr);
+    explicit ConfigureSystem(Core::System& system_, QWidget* parent = nullptr);
     ~ConfigureSystem() override;
 
-    void ApplyConfiguration() override;
-    void SetConfiguration() override;
+    void ApplyConfiguration();
+    void SetConfiguration();
 
 private:
     void changeEvent(QEvent* event) override;
     void RetranslateUI();
 
-    void Setup(const ConfigurationShared::Builder& builder);
+    void ReadSystemSettings();
 
-    std::vector<std::function<void(bool)>> apply_funcs{};
+    void SetupPerGameUI();
 
     std::unique_ptr<Ui::ConfigureSystem> ui;
     bool enabled = false;
 
-    Core::System& system;
+    ConfigurationShared::CheckState use_rng_seed;
+    ConfigurationShared::CheckState use_unsafe_extended_memory_layout;
 
-    QComboBox* combo_region;
-    QComboBox* combo_language;
+    Core::System& system;
 };

src/yuzu/configuration/configure_system.ui

@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>605</width>
+    <width>366</width>
     <height>483</height>
    </rect>
   </property>
@@ -22,63 +22,470 @@
      <item>
       <widget class="QGroupBox" name="group_system_settings">
        <property name="title">
-        <string>System</string>
+        <string>System Settings</string>
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_2">
         <item>
-         <widget class="QWidget" name="system_widget" native="true">
-          <layout class="QVBoxLayout" name="verticalLayout_3">
-           <property name="leftMargin">
-            <number>0</number>
-           </property>
-           <property name="topMargin">
-            <number>0</number>
-           </property>
-           <property name="rightMargin">
-            <number>0</number>
-           </property>
-           <property name="bottomMargin">
-            <number>0</number>
-           </property>
-          </layout>
-         </widget>
-        </item>
-        <item>
-         <widget class="QLabel" name="label_warn_invalid_locale">
+         <layout class="QGridLayout" name="gridLayout_2">
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_region">
             <property name="text">
-           <string/>
+             <string>Region:</string>
             </property>
-          <property name="wordWrap">
-           <bool>true</bool>
+           </widget>
+          </item>
+          <item row="2" column="1">
+           <widget class="QComboBox" name="combo_time_zone">
+            <item>
+             <property name="text">
+              <string>Auto</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Default</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>CET</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>CST6CDT</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Cuba</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>EET</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Egypt</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Eire</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>EST</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>EST5EDT</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>GB</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>GB-Eire</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>GMT</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>GMT+0</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>GMT-0</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>GMT0</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Greenwich</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Hongkong</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>HST</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Iceland</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Iran</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Israel</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Jamaica</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Japan</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Kwajalein</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Libya</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>MET</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>MST</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>MST7MDT</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Navajo</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>NZ</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>NZ-CHAT</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Poland</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Portugal</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>PRC</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>PST8PDT</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>ROC</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>ROK</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Singapore</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Turkey</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>UCT</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Universal</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>UTC</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>W-SU</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>WET</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Zulu</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QComboBox" name="combo_region">
+            <item>
+             <property name="text">
+              <string>Japan</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>USA</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Europe</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Australia</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>China</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Korea</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Taiwan</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="label_timezone">
+            <property name="text">
+             <string>Time Zone:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1">
+           <widget class="QComboBox" name="combo_language">
+            <property name="toolTip">
+             <string>Note: this can be overridden when region setting is auto-select</string>
+            </property>
+            <item>
+             <property name="text">
+              <string>Japanese (日本語)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>American English</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>French (français)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>German (Deutsch)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Italian (italiano)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Spanish (español)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Chinese</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Korean (한국어)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Dutch (Nederlands)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Portuguese (português)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Russian (Русский)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Taiwanese</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>British English</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Canadian French</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Latin American Spanish</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Simplified Chinese</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Traditional Chinese (正體中文)</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Brazilian Portuguese (português do Brasil)</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="4" column="0">
+           <widget class="QCheckBox" name="custom_rtc_checkbox">
+            <property name="text">
+             <string>Custom RTC</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_language">
+            <property name="text">
+             <string>Language</string>
+            </property>
+           </widget>
+          </item>
+          <item row="5" column="0">
+           <widget class="QCheckBox" name="rng_seed_checkbox">
+            <property name="text">
+             <string>RNG Seed</string>
+            </property>
+           </widget>
+          </item>
+          <item row="6" column="0">
+           <widget class="QLabel" name="device_name_label">
+            <property name="text">
+             <string>Device Name</string>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="1">
+           <widget class="QDateTimeEdit" name="custom_rtc_edit">
+            <property name="minimumDate">
+             <date>
+              <year>1970</year>
+              <month>1</month>
+              <day>1</day>
+             </date>
+            </property>
+           </widget>
+          </item>
+          <item row="6" column="1">
+           <widget class="QLineEdit" name="device_name_edit">
+            <property name="maxLength">
+             <number>128</number>
+            </property>
+           </widget>
+          </item>
+          <item row="5" column="1">
+           <widget class="QLineEdit" name="rng_seed_edit">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="font">
+             <font>
+              <family>Lucida Console</family>
+             </font>
+            </property>
+            <property name="inputMask">
+             <string notr="true">HHHHHHHH</string>
+            </property>
+            <property name="maxLength">
+             <number>8</number>
+            </property>
+           </widget>
+          </item>
+          <item row="7" column="0">
+           <widget class="QCheckBox" name="use_unsafe_extended_memory_layout">
+            <property name="text">
+             <string>Unsafe extended memory layout (8GB DRAM)</string>
             </property>
            </widget>
           </item>
          </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox">
-       <property name="title">
-        <string>Core</string>
-       </property>
-       <layout class="QVBoxLayout" name="verticalLayout_6">
-        <item>
-         <widget class="QWidget" name="core_widget" native="true">
-          <layout class="QVBoxLayout" name="verticalLayout_5">
-           <property name="leftMargin">
-            <number>0</number>
-           </property>
-           <property name="topMargin">
-            <number>0</number>
-           </property>
-           <property name="rightMargin">
-            <number>0</number>
-           </property>
-           <property name="bottomMargin">
-            <number>0</number>
-           </property>
-          </layout>
-         </widget>
         </item>
        </layout>
       </widget>
@@ -96,6 +503,26 @@
        </property>
       </spacer>
      </item>
+     <item>
+      <widget class="QLabel" name="label_warn_invalid_locale">
+       <property name="text">
+        <string></string>
+       </property>
+       <property name="wordWrap">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="label_disable_info">
+       <property name="text">
+        <string>System settings are available only when game is not running.</string>
+       </property>
+       <property name="wordWrap">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
     </layout>
    </item>
   </layout>

src/yuzu/configuration/shared_translation.cpp

@@ -1,388 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/time_zone.h"
-#include "yuzu/configuration/shared_translation.h"
-
-#include <map>
-#include <memory>
-#include <tuple>
-#include <utility>
-#include <QWidget>
-#include "common/settings.h"
-#include "common/settings_enums.h"
-#include "common/settings_setting.h"
-#include "yuzu/uisettings.h"
-
-namespace ConfigurationShared {
-
-std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
-    std::unique_ptr<TranslationMap> translations = std::make_unique<TranslationMap>();
-    const auto& tr = [parent](const char* text) -> QString { return parent->tr(text); };
-
-#define INSERT(SETTINGS, ID, NAME, TOOLTIP)                                                        \
-    translations->insert(std::pair{SETTINGS::values.ID.Id(), std::pair{tr((NAME)), tr((TOOLTIP))}})
-
-    // A setting can be ignored by giving it a blank name
-
-    // Audio
-    INSERT(Settings, sink_id, "Output Engine:", "");
-    INSERT(Settings, audio_output_device_id, "Output Device:", "");
-    INSERT(Settings, audio_input_device_id, "Input Device:", "");
-    INSERT(Settings, audio_muted, "Mute audio when in background", "");
-    INSERT(Settings, volume, "Volume:", "");
-    INSERT(Settings, dump_audio_commands, "", "");
-
-    // Core
-    INSERT(Settings, use_multi_core, "Multicore CPU Emulation", "");
-    INSERT(Settings, memory_layout_mode, "Memory Layout", "");
-    INSERT(Settings, use_speed_limit, "", "");
-    INSERT(Settings, speed_limit, "Limit Speed Percent", "");
-
-    // Cpu
-    INSERT(Settings, cpu_accuracy, "Accuracy:", "");
-
-    // Cpu Debug
-
-    // Cpu Unsafe
-    INSERT(Settings, cpuopt_unsafe_unfuse_fma,
-           "Unfuse FMA (improve performance on CPUs without FMA)",
-           "This option improves speed by reducing accuracy of fused-multiply-add instructions on "
-           "CPUs without native FMA support.");
-    INSERT(Settings, cpuopt_unsafe_reduce_fp_error, "Faster FRSQRTE and FRECPE",
-           "This option improves the speed of some approximate floating-point functions by using "
-           "less accurate native approximations.");
-    INSERT(Settings, cpuopt_unsafe_ignore_standard_fpcr, "Faster ASIMD instructions (32 bits only)",
-           "This option improves the speed of 32 bits ASIMD floating-point functions by running "
-           "with incorrect rounding modes.");
-    INSERT(Settings, cpuopt_unsafe_inaccurate_nan, "Inaccurate NaN handling",
-           "This option improves speed by removing NaN checking. Please note this also reduces "
-           "accuracy of certain floating-point instructions.");
-    INSERT(
-        Settings, cpuopt_unsafe_fastmem_check, "Disable address space checks",
-        "This option improves speed by eliminating a safety check before every memory read/write "
-        "in guest. Disabling it may allow a game to read/write the emulator's memory.");
-    INSERT(Settings, cpuopt_unsafe_ignore_global_monitor, "Ignore global monitor",
-           "This option improves speed by relying only on the semantics of cmpxchg to ensure "
-           "safety of exclusive access instructions. Please note this may result in deadlocks and "
-           "other race conditions.");
-
-    // Renderer
-    INSERT(Settings, renderer_backend, "API:", "");
-    INSERT(Settings, vulkan_device, "Device:", "");
-    INSERT(Settings, shader_backend, "Shader Backend:", "");
-    INSERT(Settings, resolution_setup, "Resolution:", "");
-    INSERT(Settings, scaling_filter, "Window Adapting Filter:", "");
-    INSERT(Settings, fsr_sharpening_slider, "FSR Sharpness:", "");
-    INSERT(Settings, anti_aliasing, "Anti-Aliasing Method:", "");
-    INSERT(Settings, fullscreen_mode, "Fullscreen Mode:", "");
-    INSERT(Settings, aspect_ratio, "Aspect Ratio:", "");
-    INSERT(Settings, use_disk_shader_cache, "Use disk pipeline cache", "");
-    INSERT(Settings, use_asynchronous_gpu_emulation, "Use asynchronous GPU emulation", "");
-    INSERT(Settings, nvdec_emulation, "NVDEC emulation:", "");
-    INSERT(Settings, accelerate_astc, "ASTC Decoding Method:", "");
-    INSERT(Settings, astc_recompression, "ASTC Recompression Method:", "");
-    INSERT(Settings, vsync_mode, "VSync Mode:",
-           "FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen "
-           "refresh rate.\nFIFO Relaxed is similar to FIFO but allows tearing as it recovers from "
-           "a slow down.\nMailbox can have lower latency than FIFO and does not tear but may drop "
-           "frames.\nImmediate (no synchronization) just presents whatever is available and can "
-           "exhibit tearing.");
-    INSERT(Settings, bg_red, "", "");
-    INSERT(Settings, bg_green, "", "");
-    INSERT(Settings, bg_blue, "", "");
-
-    // Renderer (Advanced Graphics)
-    INSERT(Settings, async_presentation, "Enable asynchronous presentation (Vulkan only)", "");
-    INSERT(Settings, renderer_force_max_clock, "Force maximum clocks (Vulkan only)",
-           "Runs work in the background while waiting for graphics commands to keep the GPU from "
-           "lowering its clock speed.");
-    INSERT(Settings, max_anisotropy, "Anisotropic Filtering:", "");
-    INSERT(Settings, gpu_accuracy, "Accuracy Level:", "");
-    INSERT(Settings, use_asynchronous_shaders, "Use asynchronous shader building (Hack)",
-           "Enables asynchronous shader compilation, which may reduce shader stutter. This feature "
-           "is experimental.");
-    INSERT(Settings, use_fast_gpu_time, "Use Fast GPU Time (Hack)",
-           "Enables Fast GPU Time. This option will force most games to run at their highest "
-           "native resolution.");
-    INSERT(Settings, use_vulkan_driver_pipeline_cache, "Use Vulkan pipeline cache",
-           "Enables GPU vendor-specific pipeline cache. This option can improve shader loading "
-           "time significantly in cases where the Vulkan driver does not store pipeline cache "
-           "files internally.");
-    INSERT(Settings, enable_compute_pipelines, "Enable Compute Pipelines (Intel Vulkan Only)",
-           "Enable compute pipelines, required by some games.\nThis setting only exists for Intel "
-           "proprietary drivers, and may crash if enabled.\nCompute pipelines are always enabled "
-           "on all other drivers.");
-    INSERT(Settings, use_reactive_flushing, "Enable Reactive Flushing",
-           "Uses reactive flushing instead of predictive flushing, allowing more accurate memory "
-           "syncing.");
-    INSERT(Settings, use_video_framerate, "Sync to framerate of video playback",
-           "Run the game at normal speed during video playback, even when the framerate is "
-           "unlocked.");
-    INSERT(Settings, barrier_feedback_loops, "Barrier feedback loops",
-           "Improves rendering of transparency effects in specific games.");
-
-    // Renderer (Debug)
-
-    // System
-    INSERT(Settings, rng_seed, "RNG Seed", "");
-    INSERT(Settings, rng_seed_enabled, "", "");
-    INSERT(Settings, device_name, "Device Name", "");
-    INSERT(Settings, custom_rtc, "Custom RTC", "");
-    INSERT(Settings, custom_rtc_enabled, "", "");
-    INSERT(Settings, language_index,
-           "Language:", "Note: this can be overridden when region setting is auto-select");
-    INSERT(Settings, region_index, "Region:", "");
-    INSERT(Settings, time_zone_index, "Time Zone:", "");
-    INSERT(Settings, sound_index, "Sound Output Mode:", "");
-    INSERT(Settings, use_docked_mode, "", "");
-    INSERT(Settings, current_user, "", "");
-
-    // Controls
-
-    // Data Storage
-
-    // Debugging
-
-    // Debugging Graphics
-
-    // Network
-
-    // Web Service
-
-    // Ui
-
-    // Ui General
-    INSERT(UISettings, select_user_on_boot, "Prompt for user on game boot", "");
-    INSERT(UISettings, pause_when_in_background, "Pause emulation when in background", "");
-    INSERT(UISettings, confirm_before_closing, "Confirm exit while emulation is running", "");
-    INSERT(UISettings, hide_mouse, "Hide mouse on inactivity", "");
-    INSERT(UISettings, controller_applet_disabled, "Disable controller applet", "");
-
-    // Ui Debugging
-
-    // Ui Multiplayer
-
-    // Ui Games list
-
-#undef INSERT
-
-    return translations;
-}
-
-std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
-    std::unique_ptr<ComboboxTranslationMap> translations =
-        std::make_unique<ComboboxTranslationMap>();
-    const auto& tr = [&](const char* text, const char* context = "") {
-        return parent->tr(text, context);
-    };
-
-#define PAIR(ENUM, VALUE, TRANSLATION)                                                             \
-    { static_cast<u32>(Settings::ENUM::VALUE), tr(TRANSLATION) }
-#define CTX_PAIR(ENUM, VALUE, TRANSLATION, CONTEXT)                                                \
-    { static_cast<u32>(Settings::ENUM::VALUE), tr(TRANSLATION, CONTEXT) }
-
-    // Intentionally skipping VSyncMode to let the UI fill that one out
-
-    translations->insert({Settings::EnumMetadata<Settings::AstcDecodeMode>::Index(),
-                          {
-                              PAIR(AstcDecodeMode, Cpu, "CPU"),
-                              PAIR(AstcDecodeMode, Gpu, "GPU"),
-                              PAIR(AstcDecodeMode, CpuAsynchronous, "CPU Asynchronous"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::AstcRecompression>::Index(),
-                          {
-                              PAIR(AstcRecompression, Uncompressed, "Uncompressed (Best quality)"),
-                              PAIR(AstcRecompression, Bc1, "BC1 (Low quality)"),
-                              PAIR(AstcRecompression, Bc3, "BC3 (Medium quality)"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::RendererBackend>::Index(),
-                          {
-#ifdef HAS_OPENGL
-                              PAIR(RendererBackend, OpenGL, "OpenGL"),
-#endif
-                              PAIR(RendererBackend, Vulkan, "Vulkan"),
-                              PAIR(RendererBackend, Null, "Null"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::ShaderBackend>::Index(),
-                          {
-                              PAIR(ShaderBackend, Glsl, "GLSL"),
-                              PAIR(ShaderBackend, Glasm, "GLASM (Assembly Shaders, NVIDIA Only)"),
-                              PAIR(ShaderBackend, SpirV, "SPIR-V (Experimental, Mesa Only)"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::GpuAccuracy>::Index(),
-                          {
-                              PAIR(GpuAccuracy, Normal, "Normal"),
-                              PAIR(GpuAccuracy, High, "High"),
-                              PAIR(GpuAccuracy, Extreme, "Extreme"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::CpuAccuracy>::Index(),
-                          {
-                              PAIR(CpuAccuracy, Auto, "Auto"),
-                              PAIR(CpuAccuracy, Accurate, "Accurate"),
-                              PAIR(CpuAccuracy, Unsafe, "Unsafe"),
-                              PAIR(CpuAccuracy, Paranoid, "Paranoid (disables most optimizations)"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::FullscreenMode>::Index(),
-                          {
-                              PAIR(FullscreenMode, Borderless, "Borderless Windowed"),
-                              PAIR(FullscreenMode, Exclusive, "Exclusive Fullscreen"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::NvdecEmulation>::Index(),
-                          {
-                              PAIR(NvdecEmulation, Off, "No Video Output"),
-                              PAIR(NvdecEmulation, Cpu, "CPU Video Decoding"),
-                              PAIR(NvdecEmulation, Gpu, "GPU Video Decoding (Default)"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::ResolutionSetup>::Index(),
-                          {
-                              PAIR(ResolutionSetup, Res1_2X, "0.5X (360p/540p) [EXPERIMENTAL]"),
-                              PAIR(ResolutionSetup, Res3_4X, "0.75X (540p/810p) [EXPERIMENTAL]"),
-                              PAIR(ResolutionSetup, Res1X, "1X (720p/1080p)"),
-                              PAIR(ResolutionSetup, Res3_2X, "1.5X (1080p/1620p) [EXPERIMENTAL]"),
-                              PAIR(ResolutionSetup, Res2X, "2X (1440p/2160p)"),
-                              PAIR(ResolutionSetup, Res3X, "3X (2160p/3240p)"),
-                              PAIR(ResolutionSetup, Res4X, "4X (2880p/4320p)"),
-                              PAIR(ResolutionSetup, Res5X, "5X (3600p/5400p)"),
-                              PAIR(ResolutionSetup, Res6X, "6X (4320p/6480p)"),
-                              PAIR(ResolutionSetup, Res7X, "7X (5040p/7560p)"),
-                              PAIR(ResolutionSetup, Res8X, "8X (5760p/8640p)"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::ScalingFilter>::Index(),
-                          {
-                              PAIR(ScalingFilter, NearestNeighbor, "Nearest Neighbor"),
-                              PAIR(ScalingFilter, Bilinear, "Bilinear"),
-                              PAIR(ScalingFilter, Bicubic, "Bicubic"),
-                              PAIR(ScalingFilter, Gaussian, "Gaussian"),
-                              PAIR(ScalingFilter, ScaleForce, "ScaleForce"),
-                              PAIR(ScalingFilter, Fsr, "AMD FidelityFX™️ Super Resolution"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::AntiAliasing>::Index(),
-                          {
-                              PAIR(AntiAliasing, None, "None"),
-                              PAIR(AntiAliasing, Fxaa, "FXAA"),
-                              PAIR(AntiAliasing, Smaa, "SMAA"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::AspectRatio>::Index(),
-                          {
-                              PAIR(AspectRatio, R16_9, "Default (16:9)"),
-                              PAIR(AspectRatio, R4_3, "Force 4:3"),
-                              PAIR(AspectRatio, R21_9, "Force 21:9"),
-                              PAIR(AspectRatio, R16_10, "Force 16:10"),
-                              PAIR(AspectRatio, Stretch, "Stretch to Window"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::AnisotropyMode>::Index(),
-                          {
-                              PAIR(AnisotropyMode, Automatic, "Automatic"),
-                              PAIR(AnisotropyMode, Default, "Default"),
-                              PAIR(AnisotropyMode, X2, "2x"),
-                              PAIR(AnisotropyMode, X4, "4x"),
-                              PAIR(AnisotropyMode, X8, "8x"),
-                              PAIR(AnisotropyMode, X16, "16x"),
-                          }});
-    translations->insert(
-        {Settings::EnumMetadata<Settings::Language>::Index(),
-         {
-             PAIR(Language, Japanese, "Japanese (日本語)"),
-             PAIR(Language, EnglishAmerican, "American English"),
-             PAIR(Language, French, "French (français)"),
-             PAIR(Language, German, "German (Deutsch)"),
-             PAIR(Language, Italian, "Italian (italiano)"),
-             PAIR(Language, Spanish, "Spanish (español)"),
-             PAIR(Language, Chinese, "Chinese"),
-             PAIR(Language, Korean, "Korean (한국어)"),
-             PAIR(Language, Dutch, "Dutch (Nederlands)"),
-             PAIR(Language, Portuguese, "Portuguese (português)"),
-             PAIR(Language, Russian, "Russian (Русский)"),
-             PAIR(Language, Taiwanese, "Taiwanese"),
-             PAIR(Language, EnglishBritish, "British English"),
-             PAIR(Language, FrenchCanadian, "Canadian French"),
-             PAIR(Language, SpanishLatin, "Latin American Spanish"),
-             PAIR(Language, ChineseSimplified, "Simplified Chinese"),
-             PAIR(Language, ChineseTraditional, "Traditional Chinese (正體中文)"),
-             PAIR(Language, PortugueseBrazilian, "Brazilian Portuguese (português do Brasil)"),
-         }});
-    translations->insert({Settings::EnumMetadata<Settings::Region>::Index(),
-                          {
-                              PAIR(Region, Japan, "Japan"),
-                              PAIR(Region, Usa, "USA"),
-                              PAIR(Region, Europe, "Europe"),
-                              PAIR(Region, Australia, "Australia"),
-                              PAIR(Region, China, "China"),
-                              PAIR(Region, Korea, "Korea"),
-                              PAIR(Region, Taiwan, "Taiwan"),
-                          }});
-    translations->insert(
-        {Settings::EnumMetadata<Settings::TimeZone>::Index(),
-         {
-             {static_cast<u32>(Settings::TimeZone::Auto),
-              tr("Auto (%1)", "Auto select time zone")
-                  .arg(QString::fromStdString(
-                      Settings::GetTimeZoneString(Settings::TimeZone::Auto)))},
-             {static_cast<u32>(Settings::TimeZone::Default),
-              tr("Default (%1)", "Default time zone")
-                  .arg(QString::fromStdString(Common::TimeZone::GetDefaultTimeZone()))},
-             PAIR(TimeZone, Cet, "CET"),
-             PAIR(TimeZone, Cst6Cdt, "CST6CDT"),
-             PAIR(TimeZone, Cuba, "Cuba"),
-             PAIR(TimeZone, Eet, "EET"),
-             PAIR(TimeZone, Egypt, "Egypt"),
-             PAIR(TimeZone, Eire, "Eire"),
-             PAIR(TimeZone, Est, "EST"),
-             PAIR(TimeZone, Est5Edt, "EST5EDT"),
-             PAIR(TimeZone, Gb, "GB"),
-             PAIR(TimeZone, GbEire, "GB-Eire"),
-             PAIR(TimeZone, Gmt, "GMT"),
-             PAIR(TimeZone, GmtPlusZero, "GMT+0"),
-             PAIR(TimeZone, GmtMinusZero, "GMT-0"),
-             PAIR(TimeZone, GmtZero, "GMT0"),
-             PAIR(TimeZone, Greenwich, "Greenwich"),
-             PAIR(TimeZone, Hongkong, "Hongkong"),
-             PAIR(TimeZone, Hst, "HST"),
-             PAIR(TimeZone, Iceland, "Iceland"),
-             PAIR(TimeZone, Iran, "Iran"),
-             PAIR(TimeZone, Israel, "Israel"),
-             PAIR(TimeZone, Jamaica, "Jamaica"),
-             PAIR(TimeZone, Japan, "Japan"),
-             PAIR(TimeZone, Kwajalein, "Kwajalein"),
-             PAIR(TimeZone, Libya, "Libya"),
-             PAIR(TimeZone, Met, "MET"),
-             PAIR(TimeZone, Mst, "MST"),
-             PAIR(TimeZone, Mst7Mdt, "MST7MDT"),
-             PAIR(TimeZone, Navajo, "Navajo"),
-             PAIR(TimeZone, Nz, "NZ"),
-             PAIR(TimeZone, NzChat, "NZ-CHAT"),
-             PAIR(TimeZone, Poland, "Poland"),
-             PAIR(TimeZone, Portugal, "Portugal"),
-             PAIR(TimeZone, Prc, "PRC"),
-             PAIR(TimeZone, Pst8Pdt, "PST8PDT"),
-             PAIR(TimeZone, Roc, "ROC"),
-             PAIR(TimeZone, Rok, "ROK"),
-             PAIR(TimeZone, Singapore, "Singapore"),
-             PAIR(TimeZone, Turkey, "Turkey"),
-             PAIR(TimeZone, Uct, "UCT"),
-             PAIR(TimeZone, Universal, "Universal"),
-             PAIR(TimeZone, Utc, "UTC"),
-             PAIR(TimeZone, WSu, "W-SU"),
-             PAIR(TimeZone, Wet, "WET"),
-             PAIR(TimeZone, Zulu, "Zulu"),
-         }});
-    translations->insert({Settings::EnumMetadata<Settings::AudioMode>::Index(),
-                          {
-                              PAIR(AudioMode, Mono, "Mono"),
-                              PAIR(AudioMode, Stereo, "Stereo"),
-                              PAIR(AudioMode, Surround, "Surround"),
-                          }});
-    translations->insert({Settings::EnumMetadata<Settings::MemoryLayout>::Index(),
-                          {
-                              PAIR(MemoryLayout, Memory_4Gb, "4GB DRAM (Default)"),
-                              PAIR(MemoryLayout, Memory_6Gb, "6GB DRAM (Unsafe)"),
-                              PAIR(MemoryLayout, Memory_8Gb, "8GB DRAM (Unsafe)"),
-                          }});
-
-#undef PAIR
-#undef CTX_PAIR
-
-    return translations;
-}
-} // namespace ConfigurationShared

src/yuzu/configuration/shared_translation.h

@@ -1,25 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <map>
-#include <memory>
-#include <typeindex>
-#include <utility>
-#include <vector>
-#include <QString>
-#include "common/common_types.h"
-
-class QWidget;
-
-namespace ConfigurationShared {
-using TranslationMap = std::map<u32, std::pair<QString, QString>>;
-using ComboboxTranslations = std::vector<std::pair<u32, QString>>;
-using ComboboxTranslationMap = std::map<u32, ComboboxTranslations>;
-
-std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent);
-
-std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent);
-
-} // namespace ConfigurationShared