6 files changed, 69 insertions, 112 deletions

diff --git a/src/yuzu/configuration/configuration_shared.cpp b/src/yuzu/configuration/configuration_shared.cpp
index 89be4a62d..be6e0b668 100644
--- a/src/yuzu/configuration/configuration_shared.cpp
+++ b/src/yuzu/configuration/configuration_shared.cpp
@@ -13,32 +13,44 @@
 void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<bool>* setting,
                                               const QCheckBox* checkbox,
                                               const CheckState& tracker) {
-    if (tracker == CheckState::Global) {
-        setting->SetGlobal(true);
-    } else {
-        setting->SetGlobal(false);
+    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());
+        }
     }
 }
 
 void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<int>* setting,
                                               const QComboBox* combobox) {
-    if (combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
-        setting->SetGlobal(true);
-    } else {
-        setting->SetGlobal(false);
-        setting->SetValue(combobox->currentIndex() - ConfigurationShared::USE_GLOBAL_OFFSET);
+    if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) {
+        setting->SetValue(combobox->currentIndex());
+    } else if (!Settings::IsConfiguringGlobal()) {
+        if (combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            setting->SetGlobal(true);
+        } else {
+            setting->SetGlobal(false);
+            setting->SetValue(combobox->currentIndex() - ConfigurationShared::USE_GLOBAL_OFFSET);
+        }
     }
 }
 
 void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<Settings::RendererBackend>* setting,
                                               const QComboBox* combobox) {
-    if (combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
-        setting->SetGlobal(true);
-    } else {
-        setting->SetGlobal(false);
-        setting->SetValue(static_cast<Settings::RendererBackend>(
-            combobox->currentIndex() - ConfigurationShared::USE_GLOBAL_OFFSET));
+    if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) {
+        setting->SetValue(static_cast<Settings::RendererBackend>(combobox->currentIndex()));
+    } else if (!Settings::IsConfiguringGlobal()) {
+        if (combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
+            setting->SetGlobal(true);
+        } else {
+            setting->SetGlobal(false);
+            setting->SetValue(static_cast<Settings::RendererBackend>(
+                combobox->currentIndex() - ConfigurationShared::USE_GLOBAL_OFFSET));
+        }
     }
 }
 
diff --git a/src/yuzu/configuration/configure_audio.cpp b/src/yuzu/configuration/configure_audio.cpp
index f9507e228..6c18e9131 100644
--- a/src/yuzu/configuration/configure_audio.cpp
+++ b/src/yuzu/configuration/configure_audio.cpp
@@ -99,6 +99,10 @@ void ConfigureAudio::SetVolumeIndicatorText(int percentage) {
 }
 
 void ConfigureAudio::ApplyConfiguration() {
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.enable_audio_stretching,
+                                             ui->toggle_audio_stretching,
+                                             enable_audio_stretching);
+
     if (Settings::IsConfiguringGlobal()) {
         Settings::values.sink_id =
             ui->output_sink_combo_box->itemText(ui->output_sink_combo_box->currentIndex())
@@ -108,19 +112,12 @@ void ConfigureAudio::ApplyConfiguration() {
                 .toStdString();
 
         // Guard if during game and set to game-specific value
-        if (Settings::values.enable_audio_stretching.UsingGlobal()) {
-            Settings::values.enable_audio_stretching.SetValue(
-                ui->toggle_audio_stretching->isChecked());
-        }
         if (Settings::values.volume.UsingGlobal()) {
             Settings::values.volume.SetValue(
                 static_cast<float>(ui->volume_slider->sliderPosition()) /
                 ui->volume_slider->maximum());
         }
     } else {
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.enable_audio_stretching,
-                                                 ui->toggle_audio_stretching,
-                                                 enable_audio_stretching);
         if (ui->volume_combo_box->currentIndex() == 0) {
             Settings::values.volume.SetGlobal(true);
         } else {
diff --git a/src/yuzu/configuration/configure_general.cpp b/src/yuzu/configuration/configure_general.cpp
index 2fa88dcec..68c8aeb19 100644
--- a/src/yuzu/configuration/configure_general.cpp
+++ b/src/yuzu/configuration/configure_general.cpp
@@ -50,6 +50,9 @@ void ConfigureGeneral::SetConfiguration() {
 }
 
 void ConfigureGeneral::ApplyConfiguration() {
+    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();
@@ -62,13 +65,7 @@ void ConfigureGeneral::ApplyConfiguration() {
                                                       Qt::Checked);
             Settings::values.frame_limit.SetValue(ui->frame_limit->value());
         }
-        if (Settings::values.use_multi_core.UsingGlobal()) {
-            Settings::values.use_multi_core.SetValue(ui->use_multi_core->isChecked());
-        }
     } else {
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_multi_core,
-                                                 ui->use_multi_core, use_multi_core);
-
         bool global_frame_limit = use_frame_limit == ConfigurationShared::CheckState::Global;
         Settings::values.use_frame_limit.SetGlobal(global_frame_limit);
         Settings::values.frame_limit.SetGlobal(global_frame_limit);
@@ -94,6 +91,9 @@ void ConfigureGeneral::RetranslateUI() {
 
 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_frame_limit->setEnabled(Settings::values.use_frame_limit.UsingGlobal());
         ui->frame_limit->setEnabled(Settings::values.frame_limit.UsingGlobal());
 
diff --git a/src/yuzu/configuration/configure_graphics.cpp b/src/yuzu/configuration/configure_graphics.cpp
index 0a7536617..fb9ec093c 100644
--- a/src/yuzu/configuration/configure_graphics.cpp
+++ b/src/yuzu/configuration/configure_graphics.cpp
@@ -106,6 +106,19 @@ void ConfigureGraphics::SetConfiguration() {
 }
 
 void ConfigureGraphics::ApplyConfiguration() {
+    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.use_nvdec_emulation,
+                                             ui->use_nvdec_emulation, use_nvdec_emulation);
+
     if (Settings::IsConfiguringGlobal()) {
         // Guard if during game and set to game-specific value
         if (Settings::values.renderer_backend.UsingGlobal()) {
@@ -114,22 +127,6 @@ void ConfigureGraphics::ApplyConfiguration() {
         if (Settings::values.vulkan_device.UsingGlobal()) {
             Settings::values.vulkan_device.SetValue(vulkan_device);
         }
-        if (Settings::values.fullscreen_mode.UsingGlobal()) {
-            Settings::values.fullscreen_mode.SetValue(ui->fullscreen_mode_combobox->currentIndex());
-        }
-        if (Settings::values.aspect_ratio.UsingGlobal()) {
-            Settings::values.aspect_ratio.SetValue(ui->aspect_ratio_combobox->currentIndex());
-        }
-        if (Settings::values.use_disk_shader_cache.UsingGlobal()) {
-            Settings::values.use_disk_shader_cache.SetValue(ui->use_disk_shader_cache->isChecked());
-        }
-        if (Settings::values.use_asynchronous_gpu_emulation.UsingGlobal()) {
-            Settings::values.use_asynchronous_gpu_emulation.SetValue(
-                ui->use_asynchronous_gpu_emulation->isChecked());
-        }
-        if (Settings::values.use_nvdec_emulation.UsingGlobal()) {
-            Settings::values.use_nvdec_emulation.SetValue(ui->use_nvdec_emulation->isChecked());
-        }
         if (Settings::values.bg_red.UsingGlobal()) {
             Settings::values.bg_red.SetValue(static_cast<float>(bg_color.redF()));
             Settings::values.bg_green.SetValue(static_cast<float>(bg_color.greenF()));
@@ -150,19 +147,6 @@ void ConfigureGraphics::ApplyConfiguration() {
             }
         }
 
-        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.use_nvdec_emulation,
-                                                 ui->use_nvdec_emulation, use_nvdec_emulation);
-
         if (ui->bg_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
             Settings::values.bg_red.SetGlobal(true);
             Settings::values.bg_green.SetGlobal(true);
diff --git a/src/yuzu/configuration/configure_graphics_advanced.cpp b/src/yuzu/configuration/configure_graphics_advanced.cpp
index c67609b0e..94e634986 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.cpp
+++ b/src/yuzu/configuration/configure_graphics_advanced.cpp
@@ -54,47 +54,24 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
         ui->gpu_accuracy->currentIndex() -
         ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
 
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
+                                             ui->anisotropic_filtering_combobox);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync,
+                                             use_vsync);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_assembly_shaders,
+                                             ui->use_assembly_shaders, use_assembly_shaders);
+    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);
+
     if (Settings::IsConfiguringGlobal()) {
         // Must guard in case of a during-game configuration when set to be game-specific.
         if (Settings::values.gpu_accuracy.UsingGlobal()) {
             Settings::values.gpu_accuracy.SetValue(gpu_accuracy);
         }
-        if (Settings::values.use_vsync.UsingGlobal()) {
-            Settings::values.use_vsync.SetValue(ui->use_vsync->isChecked());
-        }
-        if (Settings::values.use_assembly_shaders.UsingGlobal()) {
-            Settings::values.use_assembly_shaders.SetValue(ui->use_assembly_shaders->isChecked());
-        }
-        if (Settings::values.use_asynchronous_shaders.UsingGlobal()) {
-            Settings::values.use_asynchronous_shaders.SetValue(
-                ui->use_asynchronous_shaders->isChecked());
-        }
-        if (Settings::values.use_asynchronous_shaders.UsingGlobal()) {
-            Settings::values.use_asynchronous_shaders.SetValue(
-                ui->use_asynchronous_shaders->isChecked());
-        }
-        if (Settings::values.use_fast_gpu_time.UsingGlobal()) {
-            Settings::values.use_fast_gpu_time.SetValue(ui->use_fast_gpu_time->isChecked());
-        }
-        if (Settings::values.max_anisotropy.UsingGlobal()) {
-            Settings::values.max_anisotropy.SetValue(
-                ui->anisotropic_filtering_combobox->currentIndex());
-        }
     } else {
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
-                                                 ui->anisotropic_filtering_combobox);
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync,
-                                                 use_vsync);
-        ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_assembly_shaders,
-                                                 ui->use_assembly_shaders, use_assembly_shaders);
-        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.max_anisotropy,
-                                                 ui->anisotropic_filtering_combobox);
-
         if (ui->gpu_accuracy->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
             Settings::values.gpu_accuracy.SetGlobal(true);
         } else {
diff --git a/src/yuzu/configuration/configure_system.cpp b/src/yuzu/configuration/configure_system.cpp
index 268ed44c3..26505956a 100644
--- a/src/yuzu/configuration/configure_system.cpp
+++ b/src/yuzu/configuration/configure_system.cpp
@@ -127,21 +127,15 @@ void ConfigureSystem::ApplyConfiguration() {
         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.sound_index, ui->combo_sound);
+
     if (Settings::IsConfiguringGlobal()) {
         // Guard if during game and set to game-specific value
-        if (Settings::values.language_index.UsingGlobal()) {
-            Settings::values.language_index.SetValue(ui->combo_language->currentIndex());
-        }
-        if (Settings::values.region_index.UsingGlobal()) {
-            Settings::values.region_index.SetValue(ui->combo_region->currentIndex());
-        }
-        if (Settings::values.time_zone_index.UsingGlobal()) {
-            Settings::values.time_zone_index.SetValue(ui->combo_time_zone->currentIndex());
-        }
-        if (Settings::values.sound_index.UsingGlobal()) {
-            Settings::values.sound_index.SetValue(ui->combo_sound->currentIndex());
-        }
-
         if (Settings::values.rng_seed.UsingGlobal()) {
             if (ui->rng_seed_checkbox->isChecked()) {
                 Settings::values.rng_seed.SetValue(
@@ -151,13 +145,6 @@ void ConfigureSystem::ApplyConfiguration() {
             }
         }
     } else {
-        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.sound_index, ui->combo_sound);
-
         switch (use_rng_seed) {
         case ConfigurationShared::CheckState::On:
         case ConfigurationShared::CheckState::Off: