settings: restore the recommended MKW settings prompt

Apply accepted settings visibly and save them, then reapply after per-game configuration. Include handheld mode.

Assisted by Codex.

5 files changed, 166 insertions, 0 deletions

diff --git a/src/common/game_presets.h b/src/common/game_presets.h
new file mode 100644
index 0000000000..f8299d948f
--- /dev/null
+++ b/src/common/game_presets.h
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/settings.h"
+
+namespace Settings {
+
+inline constexpr u64 MarioKartWorldProgramId = 0x0400C3F00006E000ULL;
+
+inline void SetMarioKartWorldRecommendedSettings(Values& settings, bool global) {
+    const auto session = [global](auto& setting, auto value) {
+        setting.SetGlobal(global);
+        setting.SetValue(value);
+    };
+    session(settings.renderer_backend, RendererBackend::Vulkan);
+    session(settings.resolution_setup, ResolutionSetup::Res1X);
+    session(settings.gpu_accuracy, GpuAccuracy::Low);
+    session(settings.use_asynchronous_shaders, true);
+    session(settings.astc_recompression, AstcRecompression::Bc3);
+    session(settings.vram_usage_mode, VramUsageMode::Conservative);
+    session(settings.use_reactive_flushing, false);
+    session(settings.vsync_mode, VSyncMode::FifoRelaxed);
+    session(settings.use_docked_mode, ConsoleMode::Handheld);
+}
+
+inline bool ApplyMarioKartWorldPreset(Values& settings, u64 program_id, bool accepted) {
+    if (!accepted || program_id != MarioKartWorldProgramId) {
+        return false;
+    }
+    SetMarioKartWorldRecommendedSettings(settings, false);
+    return true;
+}
+
+} // namespace Settings
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index 461098954c..1eb1040e34 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -9,6 +9,7 @@ add_executable(tests
     common/cityhash.cpp
     common/container_hash.cpp
     common/fibers.cpp
+    common/game_presets.cpp
     common/host_memory.cpp
     common/param_package.cpp
     common/range_map.cpp
diff --git a/src/tests/common/game_presets.cpp b/src/tests/common/game_presets.cpp
new file mode 100644
index 0000000000..c036895ab8
--- /dev/null
+++ b/src/tests/common/game_presets.cpp
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <memory>
+#include <catch2/catch_test_macros.hpp>
+#include "common/game_presets.h"
+
+namespace {
+void SetConflictingPreferences(Settings::Values& settings, bool per_game) {
+    const auto set = [per_game](auto& setting, auto value) {
+        setting.SetGlobal(!per_game);
+        setting.SetValue(value);
+    };
+    set(settings.renderer_backend, Settings::RendererBackend::Null);
+    set(settings.resolution_setup, Settings::ResolutionSetup::Res2X);
+    set(settings.gpu_accuracy, Settings::GpuAccuracy::High);
+    set(settings.use_asynchronous_shaders, false);
+    set(settings.astc_recompression, Settings::AstcRecompression::Uncompressed);
+    set(settings.vram_usage_mode, Settings::VramUsageMode::Aggressive);
+    set(settings.use_reactive_flushing, true);
+    set(settings.vsync_mode, Settings::VSyncMode::Immediate);
+}
+
+void CheckPreset(const Settings::Values& settings) {
+    CHECK(settings.renderer_backend.GetValue() == Settings::RendererBackend::Vulkan);
+    CHECK(settings.resolution_setup.GetValue() == Settings::ResolutionSetup::Res1X);
+    CHECK(settings.gpu_accuracy.GetValue() == Settings::GpuAccuracy::Low);
+    CHECK(settings.use_asynchronous_shaders.GetValue());
+    CHECK(settings.astc_recompression.GetValue() == Settings::AstcRecompression::Bc3);
+    CHECK(settings.vram_usage_mode.GetValue() == Settings::VramUsageMode::Conservative);
+    CHECK_FALSE(settings.use_reactive_flushing.GetValue());
+    CHECK(settings.vsync_mode.GetValue() == Settings::VSyncMode::FifoRelaxed);
+    CHECK(settings.use_docked_mode.GetValue() == Settings::ConsoleMode::Handheld);
+}
+
+void CheckPreferences(const Settings::Values& settings, bool global = false) {
+    CHECK(settings.renderer_backend.GetValue(global) == Settings::RendererBackend::Null);
+    CHECK(settings.resolution_setup.GetValue(global) == Settings::ResolutionSetup::Res2X);
+    CHECK(settings.gpu_accuracy.GetValue(global) == Settings::GpuAccuracy::High);
+    CHECK_FALSE(settings.use_asynchronous_shaders.GetValue(global));
+    CHECK(settings.astc_recompression.GetValue(global) ==
+          Settings::AstcRecompression::Uncompressed);
+    CHECK(settings.vram_usage_mode.GetValue(global) == Settings::VramUsageMode::Aggressive);
+    CHECK(settings.use_reactive_flushing.GetValue(global));
+    CHECK(settings.vsync_mode.GetValue(global) == Settings::VSyncMode::Immediate);
+}
+} // namespace
+
+TEST_CASE("Accepted MKW settings replace visible global preferences", "[game_presets]") {
+    auto settings = std::make_unique<Settings::Values>();
+    SetConflictingPreferences(*settings, false);
+    Settings::SetMarioKartWorldRecommendedSettings(*settings, true);
+    CheckPreset(*settings);
+    CHECK(settings->renderer_backend.UsingGlobal());
+    CHECK(settings->gpu_accuracy.UsingGlobal());
+    CHECK(settings->renderer_backend.GetValue(true) == Settings::RendererBackend::Vulkan);
+    CHECK(settings->gpu_accuracy.GetValue(true) == Settings::GpuAccuracy::Low);
+}
+
+TEST_CASE("MKW preset overrides saved settings for the session", "[game_presets]") {
+    auto settings = std::make_unique<Settings::Values>();
+    SetConflictingPreferences(*settings, false);
+    SetConflictingPreferences(*settings, true);
+    REQUIRE(
+        Settings::ApplyMarioKartWorldPreset(*settings, Settings::MarioKartWorldProgramId, true));
+    CheckPreset(*settings);
+    CheckPreferences(*settings, true);
+    for (const auto& restore : settings->linkage.restore_functions) {
+        restore();
+    }
+    CheckPreferences(*settings);
+    CHECK(settings->renderer_backend.UsingGlobal());
+    CHECK(settings->resolution_setup.UsingGlobal());
+    REQUIRE(
+        Settings::ApplyMarioKartWorldPreset(*settings, Settings::MarioKartWorldProgramId, true));
+    CheckPreset(*settings);
+}
+
+TEST_CASE("MKW preset does not change unrelated games", "[game_presets]") {
+    auto settings = std::make_unique<Settings::Values>();
+    SetConflictingPreferences(*settings, false);
+    CHECK_FALSE(Settings::ApplyMarioKartWorldPreset(*settings, 0, true));
+    CHECK_FALSE(Settings::ApplyMarioKartWorldPreset(*settings,
+                                                    Settings::MarioKartWorldProgramId + 1, true));
+    CheckPreferences(*settings);
+    CHECK(settings->renderer_backend.UsingGlobal());
+    CHECK(settings->resolution_setup.UsingGlobal());
+}
+
+TEST_CASE("Declining the MKW preset preserves global and per-game preferences", "[game_presets]") {
+    auto settings = std::make_unique<Settings::Values>();
+    for (bool per_game : {false, true}) {
+        SetConflictingPreferences(*settings, per_game);
+        CHECK_FALSE(Settings::ApplyMarioKartWorldPreset(*settings,
+                                                        Settings::MarioKartWorldProgramId, false));
+        CheckPreferences(*settings);
+        CHECK(settings->renderer_backend.UsingGlobal() == !per_game);
+        CHECK(settings->resolution_setup.UsingGlobal() == !per_game);
+    }
+}
diff --git a/src/yuzu/main_window.cpp b/src/yuzu/main_window.cpp
index e5a8f81424..d0cd130f6f 100644
--- a/src/yuzu/main_window.cpp
+++ b/src/yuzu/main_window.cpp
@@ -10,6 +10,7 @@
 
 #include <boost/algorithm/string/split.hpp>
 #include "common/fs/path_util.h"
+#include "common/game_presets.h"
 #include "common/settings.h"
 #include "common/settings_enums.h"
 #include "frontend_common/settings_generator.h"
@@ -457,6 +458,29 @@ MainWindow::MainWindow(bool has_broken_vulkan)
     // Gen keys if necessary
     OnCheckFirmwareDecryption(false);
 
+    auto* recommendations = new QMessageBox(
+        QMessageBox::Question, tr("Recommended Mario Kart World settings"),
+        tr("Use the recommended settings for Mario Kart World?\n\n"
+           "Vulkan, 1x resolution, GPU Fast, asynchronous shaders, BC3, conservative VRAM, "
+           "reactive flushing off, FIFO Relaxed VSync, and handheld mode.\n\n"
+           "Yes replaces your saved settings. No or closing this window keeps your settings."),
+        QMessageBox::Yes | QMessageBox::No, this);
+    recommendations->setAttribute(Qt::WA_DeleteOnClose);
+    recommendations->setDefaultButton(QMessageBox::No);
+    recommendations->setEscapeButton(QMessageBox::No);
+    recommendations->setWindowModality(Qt::NonModal);
+    connect(recommendations, &QMessageBox::finished, this, [this](int result) {
+        use_recommended_mkw_settings = result == QMessageBox::Yes;
+        if (use_recommended_mkw_settings && !emulation_running && !boot_in_progress) {
+            Settings::SetMarioKartWorldRecommendedSettings(Settings::values, true);
+            config->SaveAllValues();
+            QtCommon::system->ApplySettings();
+            UpdateStatusButtons();
+        }
+        LOG_INFO(Config, "MKW recommended settings accepted: {}", use_recommended_mkw_settings);
+    });
+    recommendations->show();
+
 #ifdef __unix__
     OnCheckGraphicsBackend();
 #endif
@@ -1964,6 +1988,12 @@ void MainWindow::BootGame(const QString& filename, Service::AM::FrontendAppletPa
         QtCommon::system->ApplySettings();
     }
 
+    if (Settings::ApplyMarioKartWorldPreset(Settings::values, title_id,
+                                          use_recommended_mkw_settings)) {
+        QtCommon::system->ApplySettings();
+        Settings::UpdateGPUAccuracy();
+        LOG_INFO(Config, "Applied recommended MKW settings after per-game configuration");
+    }
     Settings::LogSettings();
 
     if (UISettings::values.select_user_on_boot && !user_flag_cmd_line) {
diff --git a/src/yuzu/main_window.h b/src/yuzu/main_window.h
index e2c5a0f6db..6fe967267a 100644
--- a/src/yuzu/main_window.h
+++ b/src/yuzu/main_window.h
@@ -501,6 +501,7 @@ private:
 #endif
 
     MultiplayerState* multiplayer_state = nullptr;
+    bool use_recommended_mkw_settings = false;
 
     GRenderWindow* render_window = nullptr;
     GameList* game_list = nullptr;