common/setting: Make ranged a property of the type

- Avoids new GCC 12 warnings when Type is of form std::optional<T>
- Makes more sense this way, because ranged is not a property which would change over time

.ci/scripts/windows/docker.sh

@@ -65,7 +65,7 @@ python3 .ci/scripts/windows/scan_dll.py package/*.exe package/imageformats/*.dll
 # copy FFmpeg libraries
 EXTERNALS_PATH="$(pwd)/build/externals"
 FFMPEG_DLL_PATH="$(find "${EXTERNALS_PATH}" -maxdepth 1 -type d | grep 'ffmpeg-')/bin"
-find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -v {} package/ ';'
+find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -nv {} package/ ';'
 
 # copy libraries from yuzu.exe path
 find "$(pwd)/build/bin/" -type f -regex ".*\.dll" -exec cp -v {} package/ ';'

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
     container: yuzuemu/build-environments:linux-transifex
     if: ${{ github.repository == 'yuzu-emu/yuzu' && !github.head_ref }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
           fetch-depth: 0   

.github/workflows/verify.yml

@@ -12,7 +12,7 @@ jobs:
       image: yuzuemu/build-environments:linux-clang-format
       options: -u 1001
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           submodules: false
       - name: 'Verify Formatting'
@@ -35,12 +35,12 @@ jobs:
       image: yuzuemu/build-environments:${{ matrix.image }}
       options: -u 1001
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
           fetch-depth: 0
       - name: Set up cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         id: ccache-restore
         with:
           path: ~/.ccache
@@ -69,7 +69,7 @@ jobs:
     runs-on: windows-2019
     steps:
       - name: Set up cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ~/.buildcache
           key: ${{ runner.os }}-msvc-${{ github.sha }}
@@ -89,7 +89,7 @@ jobs:
           echo %PATH% >> %GITHUB_PATH%
       - name: Set up MSVC
         uses: ilammy/msvc-dev-cmd@v1
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
           fetch-depth: 0

src/common/common_funcs.h

@@ -18,14 +18,16 @@
 /// Helper macros to insert unused bytes or words to properly align structs. These values will be
 /// zero-initialized.
 #define INSERT_PADDING_BYTES(num_bytes)                                                            \
-    std::array<u8, num_bytes> CONCAT2(pad, __LINE__) {}
+    [[maybe_unused]] std::array<u8, num_bytes> CONCAT2(pad, __LINE__) {}
 #define INSERT_PADDING_WORDS(num_words)                                                            \
-    std::array<u32, num_words> CONCAT2(pad, __LINE__) {}
+    [[maybe_unused]] std::array<u32, num_words> CONCAT2(pad, __LINE__) {}
 
 /// These are similar to the INSERT_PADDING_* macros but do not zero-initialize the contents.
 /// This keeps the structure trivial to construct.
-#define INSERT_PADDING_BYTES_NOINIT(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
-#define INSERT_PADDING_WORDS_NOINIT(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__)
+#define INSERT_PADDING_BYTES_NOINIT(num_bytes)                                                     \
+    [[maybe_unused]] std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
+#define INSERT_PADDING_WORDS_NOINIT(num_words)                                                     \
+    [[maybe_unused]] std::array<u32, num_words> CONCAT2(pad, __LINE__)
 
 #ifndef _MSC_VER
 

src/common/settings.h

@@ -106,7 +106,7 @@ struct ResolutionScalingInfo {
  * configurations. Specifying a default value and label is required. A minimum and maximum range can
  * be specified for sanitization.
  */
-template <typename Type>
+template <typename Type, bool ranged = false>
 class Setting {
 protected:
     Setting() = default;
@@ -126,8 +126,8 @@ public:
      * @param default_val Intial 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)
-        : value{default_val}, default_value{default_val}, ranged{false}, label{name} {}
+    explicit Setting(const Type& default_val, const std::string& name) requires(!ranged)
+        : value{default_val}, default_value{default_val}, label{name} {}
     virtual ~Setting() = default;
 
     /**
@@ -139,9 +139,9 @@ public:
      * @param name Label for the setting
      */
     explicit Setting(const Type& default_val, const Type& min_val, const Type& max_val,
-                     const std::string& name)
-        : value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val},
-          ranged{true}, label{name} {}
+                     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.
@@ -158,7 +158,7 @@ public:
      * @param val The desired value
      */
     virtual void SetValue(const Type& val) {
-        Type temp{(ranged) ? std::clamp(val, minimum, maximum) : val};
+        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
         std::swap(value, temp);
     }
 
@@ -188,7 +188,7 @@ public:
      * @returns A reference to the setting
      */
     virtual const Type& operator=(const Type& val) {
-        Type temp{(ranged) ? std::clamp(val, minimum, maximum) : val};
+        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
         std::swap(value, temp);
         return value;
     }
@@ -207,7 +207,6 @@ protected:
     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 bool ranged;          ///< The setting has sanitization ranges
     const std::string label{};  ///< The setting's label
 };
 
@@ -219,8 +218,8 @@ protected:
  *
  * By default, the global setting is used.
  */
-template <typename Type>
-class SwitchableSetting : virtual public Setting<Type> {
+template <typename Type, bool ranged = false>
+class SwitchableSetting : virtual public Setting<Type, ranged> {
 public:
     /**
      * Sets a default value, label, and setting value.
@@ -228,7 +227,7 @@ public:
      * @param default_val Intial 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)
+    explicit SwitchableSetting(const Type& default_val, const std::string& name) requires(!ranged)
         : Setting<Type>{default_val, name} {}
     virtual ~SwitchableSetting() = default;
 
@@ -241,8 +240,8 @@ public:
      * @param name Label for the setting
      */
     explicit SwitchableSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                               const std::string& name)
-        : Setting<Type>{default_val, min_val, max_val, name} {}
+                               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
@@ -290,7 +289,7 @@ public:
      * @param val The new value
      */
     void SetValue(const Type& val) override {
-        Type temp{(this->ranged) ? std::clamp(val, this->minimum, this->maximum) : val};
+        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
         if (use_global) {
             std::swap(this->value, temp);
         } else {
@@ -306,7 +305,7 @@ public:
      * @returns A reference to the current setting value
      */
     const Type& operator=(const Type& val) override {
-        Type temp{(this->ranged) ? std::clamp(val, this->minimum, this->maximum) : val};
+        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
         if (use_global) {
             std::swap(this->value, temp);
             return this->value;
@@ -374,15 +373,15 @@ struct Values {
     Setting<std::string> audio_device_id{"auto", "output_device"};
     Setting<std::string> sink_id{"auto", "output_engine"};
     Setting<bool> audio_muted{false, "audio_muted"};
-    SwitchableSetting<u8> volume{100, 0, 100, "volume"};
+    SwitchableSetting<u8, true> volume{100, 0, 100, "volume"};
 
     // Core
     SwitchableSetting<bool> use_multi_core{true, "use_multi_core"};
     SwitchableSetting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};
 
     // Cpu
-    SwitchableSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
-                                                CPUAccuracy::Paranoid, "cpu_accuracy"};
+    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"};
@@ -409,7 +408,7 @@ struct Values {
         true, "cpuopt_unsafe_ignore_global_monitor"};
 
     // Renderer
-    SwitchableSetting<RendererBackend> renderer_backend{
+    SwitchableSetting<RendererBackend, true> renderer_backend{
         RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
     Setting<bool> renderer_debug{false, "debug"};
     Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
@@ -423,28 +422,28 @@ struct Values {
     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> fullscreen_mode{
+    SwitchableSetting<FullscreenMode, true> fullscreen_mode{
 #ifdef _WIN32
         FullscreenMode::Borderless,
 #else
         FullscreenMode::Exclusive,
 #endif
         FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    SwitchableSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
-    SwitchableSetting<int> max_anisotropy{0, 0, 5, "max_anisotropy"};
+    SwitchableSetting<int, true> aspect_ratio{0, 0, 3, "aspect_ratio"};
+    SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"};
     SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
-    SwitchableSetting<u16> speed_limit{100, 0, 9999, "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> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
-                                                GPUAccuracy::Extreme, "gpu_accuracy"};
+    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> use_vsync{true, "use_vsync"};
-    SwitchableSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
+    SwitchableSetting<u16, true> fps_cap{1000, 1, 1000, "fps_cap"};
     Setting<bool> disable_fps_limit{false, "disable_fps_limit"};
-    SwitchableSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
-                                                    ShaderBackend::SPIRV, "shader_backend"};
+    SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLASM, 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"};
 
@@ -460,10 +459,10 @@ struct Values {
     s64 custom_rtc_differential;
 
     Setting<s32> current_user{0, "current_user"};
-    SwitchableSetting<s32> language_index{1, 0, 17, "language_index"};
-    SwitchableSetting<s32> region_index{1, 0, 6, "region_index"};
-    SwitchableSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"};
-    SwitchableSetting<s32> sound_index{1, 0, 2, "sound_index"};
+    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;
@@ -485,7 +484,7 @@ struct Values {
     Setting<bool> tas_loop{false, "tas_loop"};
 
     Setting<bool> mouse_panning{false, "mouse_panning"};
-    Setting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
+    Setting<u8, true> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
     Setting<bool> mouse_enabled{false, "mouse_enabled"};
 
     Setting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};

src/core/hle/kernel/k_code_memory.h

@@ -30,19 +30,19 @@ public:
     explicit KCodeMemory(KernelCore& kernel_);
 
     Result Initialize(Core::DeviceMemory& device_memory, VAddr address, size_t size);
-    void Finalize();
+    void Finalize() override;
 
     Result Map(VAddr address, size_t size);
     Result Unmap(VAddr address, size_t size);
     Result MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm);
     Result UnmapFromOwner(VAddr address, size_t size);
 
-    bool IsInitialized() const {
+    bool IsInitialized() const override {
         return m_is_initialized;
     }
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
-    KProcess* GetOwner() const {
+    KProcess* GetOwner() const override {
         return m_owner;
     }
     VAddr GetSourceAddress() const {

src/core/hle/kernel/k_thread.cpp

@@ -308,14 +308,20 @@ void KThread::Finalize() {
 
         auto it = waiter_list.begin();
         while (it != waiter_list.end()) {
-            // Clear the lock owner
-            it->SetLockOwner(nullptr);
+            // Get the thread.
+            KThread* const waiter = std::addressof(*it);
+
+            // The thread shouldn't be a kernel waiter.
+            ASSERT(!IsKernelAddressKey(waiter->GetAddressKey()));
+
+            // Clear the lock owner.
+            waiter->SetLockOwner(nullptr);
 
             // Erase the waiter from our list.
             it = waiter_list.erase(it);
 
             // Cancel the thread's wait.
-            it->CancelWait(ResultInvalidState, true);
+            waiter->CancelWait(ResultInvalidState, true);
         }
     }
 

src/core/hle/service/hid/controllers/npad.cpp

@@ -838,11 +838,11 @@ bool Controller_NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id,
 
         const auto now = steady_clock::now();
 
-        // Filter out non-zero vibrations that are within 10ms of each other.
+        // Filter out non-zero vibrations that are within 15ms of each other.
         if ((vibration_value.low_amplitude != 0.0f || vibration_value.high_amplitude != 0.0f) &&
             duration_cast<milliseconds>(
                 now - controller.vibration[device_index].last_vibration_timepoint) <
-                milliseconds(10)) {
+                milliseconds(15)) {
             return false;
         }
 

src/core/hle/service/nvflinger/binder.h

@@ -34,6 +34,7 @@ enum class TransactionId {
 
 class IBinder {
 public:
+    virtual ~IBinder() = default;
     virtual void Transact(Kernel::HLERequestContext& ctx, android::TransactionId code,
                           u32 flags) = 0;
     virtual Kernel::KReadableEvent& GetNativeHandle() = 0;

src/input_common/drivers/sdl_driver.cpp

@@ -438,10 +438,17 @@ SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_en
             using namespace std::chrono_literals;
             while (initialized) {
                 SDL_PumpEvents();
-                SendVibrations();
                 std::this_thread::sleep_for(1ms);
             }
         });
+        vibration_thread = std::thread([this] {
+            Common::SetCurrentThreadName("yuzu:input:SDL_Vibration");
+            using namespace std::chrono_literals;
+            while (initialized) {
+                SendVibrations();
+                std::this_thread::sleep_for(10ms);
+            }
+        });
     }
     // Because the events for joystick connection happens before we have our event watcher added, we
     // can just open all the joysticks right here
@@ -457,6 +464,7 @@ SDLDriver::~SDLDriver() {
     initialized = false;
     if (start_thread) {
         poll_thread.join();
+        vibration_thread.join();
         SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
     }
 }

src/input_common/drivers/sdl_driver.h

@@ -128,5 +128,6 @@ private:
     std::atomic<bool> initialized = false;
 
     std::thread poll_thread;
+    std::thread vibration_thread;
 };
 } // namespace InputCommon

src/yuzu/CMakeLists.txt

@@ -30,6 +30,8 @@ add_executable(yuzu
     applets/qt_web_browser_scripts.h
     bootmanager.cpp
     bootmanager.h
+    check_vulkan.cpp
+    check_vulkan.h
     compatdb.ui
     compatibility_list.cpp
     compatibility_list.h
@@ -153,8 +155,6 @@ add_executable(yuzu
     main.cpp
     main.h
     main.ui
-    startup_checks.cpp
-    startup_checks.h
     uisettings.cpp
     uisettings.h
     util/controller_navigation.cpp

src/yuzu/applets/qt_web_browser.cpp

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #ifdef YUZU_USE_QT_WEB_ENGINE
+#include <bit>
+
 #include <QApplication>
 #include <QKeyEvent>
 
@@ -211,8 +213,10 @@ template <Core::HID::NpadButton... T>
 void QtNXWebEngineView::HandleWindowFooterButtonPressedOnce() {
     const auto f = [this](Core::HID::NpadButton button) {
         if (input_interpreter->IsButtonPressedOnce(button)) {
+            const auto button_index = std::countr_zero(static_cast<u64>(button));
+
             page()->runJavaScript(
-                QStringLiteral("yuzu_key_callbacks[%1] == null;").arg(static_cast<u8>(button)),
+                QStringLiteral("yuzu_key_callbacks[%1] == null;").arg(button_index),
                 [this, button](const QVariant& variant) {
                     if (variant.toBool()) {
                         switch (button) {
@@ -236,7 +240,7 @@ void QtNXWebEngineView::HandleWindowFooterButtonPressedOnce() {
 
             page()->runJavaScript(
                 QStringLiteral("if (yuzu_key_callbacks[%1] != null) { yuzu_key_callbacks[%1](); }")
-                    .arg(static_cast<u8>(button)));
+                    .arg(button_index));
         }
     };
 

src/yuzu/check_vulkan.cpp

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "video_core/vulkan_common/vulkan_wrapper.h"
+
+#include <filesystem>
+#include <fstream>
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+#include "video_core/vulkan_common/vulkan_instance.h"
+#include "video_core/vulkan_common/vulkan_library.h"
+#include "yuzu/check_vulkan.h"
+#include "yuzu/uisettings.h"
+
+constexpr char TEMP_FILE_NAME[] = "vulkan_check";
+
+bool CheckVulkan() {
+    if (UISettings::values.has_broken_vulkan) {
+        return true;
+    }
+
+    LOG_DEBUG(Frontend, "Checking presence of Vulkan");
+
+    const auto fs_config_loc = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir);
+    const auto temp_file_loc = fs_config_loc / TEMP_FILE_NAME;
+
+    if (std::filesystem::exists(temp_file_loc)) {
+        LOG_WARNING(Frontend, "Detected recovery from previous failed Vulkan initialization");
+
+        UISettings::values.has_broken_vulkan = true;
+        std::filesystem::remove(temp_file_loc);
+        return false;
+    }
+
+    std::ofstream temp_file_handle(temp_file_loc);
+    temp_file_handle.close();
+
+    try {
+        Vulkan::vk::InstanceDispatch dld;
+        const Common::DynamicLibrary library = Vulkan::OpenLibrary();
+        const Vulkan::vk::Instance instance =
+            Vulkan::CreateInstance(library, dld, VK_API_VERSION_1_0);
+
+    } catch (const Vulkan::vk::Exception& exception) {
+        LOG_ERROR(Frontend, "Failed to initialize Vulkan: {}", exception.what());
+        // Don't set has_broken_vulkan to true here: we care when loading Vulkan crashes the
+        // application, not when we can handle it.
+    }
+
+    std::filesystem::remove(temp_file_loc);
+    return true;
+}

src/yuzu/check_vulkan.h

@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+bool CheckVulkan();

src/yuzu/configuration/config.cpp

@@ -143,8 +143,8 @@ void Config::ReadBasicSetting(Settings::Setting<std::string>& setting) {
     }
 }
 
-template <typename Type>
-void Config::ReadBasicSetting(Settings::Setting<Type>& setting) {
+template <typename Type, bool ranged>
+void Config::ReadBasicSetting(Settings::Setting<Type, ranged>& setting) {
     const QString name = QString::fromStdString(setting.GetLabel());
     const Type default_value = setting.GetDefault();
     if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
@@ -164,16 +164,16 @@ void Config::WriteBasicSetting(const Settings::Setting<std::string>& setting) {
     qt_config->setValue(name, QString::fromStdString(value));
 }
 
-template <typename Type>
-void Config::WriteBasicSetting(const Settings::Setting<Type>& setting) {
+template <typename Type, bool ranged>
+void Config::WriteBasicSetting(const Settings::Setting<Type, ranged>& setting) {
     const QString name = QString::fromStdString(setting.GetLabel());
     const Type value = setting.GetValue();
     qt_config->setValue(name + QStringLiteral("/default"), value == setting.GetDefault());
     qt_config->setValue(name, value);
 }
 
-template <typename Type>
-void Config::WriteGlobalSetting(const Settings::SwitchableSetting<Type>& setting) {
+template <typename Type, bool ranged>
+void Config::WriteGlobalSetting(const Settings::SwitchableSetting<Type, ranged>& setting) {
     const QString name = QString::fromStdString(setting.GetLabel());
     const Type& value = setting.GetValue(global);
     if (!global) {
@@ -682,6 +682,12 @@ void Config::ReadRendererValues() {
     ReadGlobalSetting(Settings::values.bg_green);
     ReadGlobalSetting(Settings::values.bg_blue);
 
+    if (!global && UISettings::values.has_broken_vulkan &&
+        Settings::values.renderer_backend.GetValue() == Settings::RendererBackend::Vulkan &&
+        !Settings::values.renderer_backend.UsingGlobal()) {
+        Settings::values.renderer_backend.SetGlobal(true);
+    }
+
     if (global) {
         ReadBasicSetting(Settings::values.renderer_debug);
         ReadBasicSetting(Settings::values.renderer_shader_feedback);
@@ -801,6 +807,7 @@ void Config::ReadUIValues() {
     ReadBasicSetting(UISettings::values.pause_when_in_background);
     ReadBasicSetting(UISettings::values.mute_when_in_background);
     ReadBasicSetting(UISettings::values.hide_mouse);
+    ReadBasicSetting(UISettings::values.has_broken_vulkan);
     ReadBasicSetting(UISettings::values.disable_web_applet);
 
     qt_config->endGroup();
@@ -1348,6 +1355,7 @@ void Config::SaveUIValues() {
     WriteBasicSetting(UISettings::values.pause_when_in_background);
     WriteBasicSetting(UISettings::values.mute_when_in_background);
     WriteBasicSetting(UISettings::values.hide_mouse);
+    WriteBasicSetting(UISettings::values.has_broken_vulkan);
     WriteBasicSetting(UISettings::values.disable_web_applet);
 
     qt_config->endGroup();
@@ -1413,8 +1421,8 @@ QVariant Config::ReadSetting(const QString& name, const QVariant& default_value)
     return result;
 }
 
-template <typename Type>
-void Config::ReadGlobalSetting(Settings::SwitchableSetting<Type>& setting) {
+template <typename Type, bool ranged>
+void Config::ReadGlobalSetting(Settings::SwitchableSetting<Type, ranged>& setting) {
     QString name = QString::fromStdString(setting.GetLabel());
     const bool use_global = qt_config->value(name + QStringLiteral("/use_global"), true).toBool();
     setting.SetGlobal(use_global);

src/yuzu/configuration/config.h

@@ -159,8 +159,8 @@ private:
      *
      * @param The setting
      */
-    template <typename Type>
-    void ReadGlobalSetting(Settings::SwitchableSetting<Type>& setting);
+    template <typename Type, bool ranged>
+    void ReadGlobalSetting(Settings::SwitchableSetting<Type, ranged>& setting);
 
     /**
      * Sets a value to the qt_config using the setting's label and default value. If the config is a
@@ -168,8 +168,8 @@ private:
      *
      * @param The setting
      */
-    template <typename Type>
-    void WriteGlobalSetting(const Settings::SwitchableSetting<Type>& 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
@@ -177,15 +177,15 @@ private:
      *
      * @param The setting
      */
-    template <typename Type>
-    void ReadBasicSetting(Settings::Setting<Type>& 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>
-    void WriteBasicSetting(const Settings::Setting<Type>& setting);
+    template <typename Type, bool ranged>
+    void WriteBasicSetting(const Settings::Setting<Type, ranged>& setting);
 
     ConfigType type;
     std::unique_ptr<QSettings> qt_config;

src/yuzu/configuration/configuration_shared.h

@@ -27,8 +27,9 @@ enum class CheckState {
 // 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>
-void ApplyPerGameSetting(Settings::SwitchableSetting<Type>* setting, const QComboBox* combobox) {
+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()) {
@@ -45,8 +46,9 @@ void ApplyPerGameSetting(Settings::SwitchableSetting<Type>* setting, const QComb
 // Sets a Qt UI element given a Settings::Setting
 void SetPerGameSetting(QCheckBox* checkbox, const Settings::SwitchableSetting<bool>* setting);
 
-template <typename Type>
-void SetPerGameSetting(QComboBox* combobox, const Settings::SwitchableSetting<Type>* 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);

src/yuzu/configuration/configure_graphics.cpp

@@ -58,9 +58,24 @@ ConfigureGraphics::ConfigureGraphics(const Core::System& system_, QWidget* paren
         UpdateBackgroundColorButton(new_bg_color);
     });
 
-    ui->api->setEnabled(!UISettings::values.has_broken_vulkan);
-    ui->api_widget->setEnabled(!UISettings::values.has_broken_vulkan ||
-                               Settings::IsConfiguringGlobal());
+    connect(ui->button_check_vulkan, &QAbstractButton::clicked, this, [this] {
+        UISettings::values.has_broken_vulkan = false;
+
+        if (RetrieveVulkanDevices()) {
+            ui->api->setEnabled(true);
+            ui->button_check_vulkan->hide();
+
+            for (const auto& device : vulkan_devices) {
+                ui->device->addItem(device);
+            }
+        } else {
+            UISettings::values.has_broken_vulkan = true;
+        }
+    });
+
+    ui->api->setEnabled(!UISettings::values.has_broken_vulkan.GetValue());
+    ui->button_check_vulkan->setVisible(UISettings::values.has_broken_vulkan.GetValue());
+
     ui->bg_label->setVisible(Settings::IsConfiguringGlobal());
     ui->bg_combobox->setVisible(!Settings::IsConfiguringGlobal());
 }
@@ -300,7 +315,7 @@ void ConfigureGraphics::UpdateAPILayout() {
         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);
+        ui->backend_widget->setEnabled(UISettings::values.has_broken_vulkan.GetValue());
     } else {
         vulkan_device = Settings::values.vulkan_device.GetValue();
         shader_backend = Settings::values.shader_backend.GetValue();
@@ -322,9 +337,9 @@ void ConfigureGraphics::UpdateAPILayout() {
     }
 }
 
-void ConfigureGraphics::RetrieveVulkanDevices() try {
+bool ConfigureGraphics::RetrieveVulkanDevices() try {
     if (UISettings::values.has_broken_vulkan) {
-        return;
+        return false;
     }
 
     using namespace Vulkan;
@@ -340,8 +355,11 @@ void ConfigureGraphics::RetrieveVulkanDevices() try {
         const std::string name = vk::PhysicalDevice(device, dld).GetProperties().deviceName;
         vulkan_devices.push_back(QString::fromStdString(name));
     }
+
+    return true;
 } catch (const Vulkan::vk::Exception& exception) {
     LOG_ERROR(Frontend, "Failed to enumerate devices with error: {}", exception.what());
+    return false;
 }
 
 Settings::RendererBackend ConfigureGraphics::GetCurrentGraphicsBackend() const {
@@ -422,4 +440,11 @@ void ConfigureGraphics::SetupPerGameUI() {
         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)));
+
+    if (UISettings::values.has_broken_vulkan) {
+        ui->backend_widget->setEnabled(true);
+        ConfigurationShared::SetColoredComboBox(
+            ui->backend, ui->backend_widget,
+            static_cast<int>(Settings::values.shader_backend.GetValue(true)));
+    }
 }

src/yuzu/configuration/configure_graphics.h

@@ -41,7 +41,7 @@ private:
     void UpdateDeviceSelection(int device);
     void UpdateShaderBackendSelection(int backend);
 
-    void RetrieveVulkanDevices();
+    bool RetrieveVulkanDevices();
 
     void SetupPerGameUI();
 

src/yuzu/configuration/configure_graphics.ui

@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>541</width>
+    <width>471</width>
     <height>759</height>
    </rect>
   </property>
@@ -574,6 +574,13 @@
      </property>
     </spacer>
    </item>
+   <item>
+    <widget class="QPushButton" name="button_check_vulkan">
+     <property name="text">
+      <string>Check for Working Vulkan</string>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <resources/>

src/yuzu/main.cpp

@@ -115,6 +115,7 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "video_core/shader_notify.h"
 #include "yuzu/about_dialog.h"
 #include "yuzu/bootmanager.h"
+#include "yuzu/check_vulkan.h"
 #include "yuzu/compatdb.h"
 #include "yuzu/compatibility_list.h"
 #include "yuzu/configuration/config.h"
@@ -130,7 +131,6 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "yuzu/install_dialog.h"
 #include "yuzu/loading_screen.h"
 #include "yuzu/main.h"
-#include "yuzu/startup_checks.h"
 #include "yuzu/uisettings.h"
 
 using namespace Common::Literals;
@@ -252,7 +252,7 @@ static QString PrettyProductName() {
     return QSysInfo::prettyProductName();
 }
 
-GMainWindow::GMainWindow(bool has_broken_vulkan)
+GMainWindow::GMainWindow()
     : ui{std::make_unique<Ui::MainWindow>()}, system{std::make_unique<Core::System>()},
       input_subsystem{std::make_shared<InputCommon::InputSubsystem>()},
       config{std::make_unique<Config>(*system)},
@@ -352,15 +352,17 @@ GMainWindow::GMainWindow(bool has_broken_vulkan)
 
     MigrateConfigFiles();
 
-    if (has_broken_vulkan) {
-        UISettings::values.has_broken_vulkan = true;
-
-        QMessageBox::warning(this, tr("Broken Vulkan Installation Detected"),
-                             tr("Vulkan initialization failed during boot.<br><br>Click <a "
-                                "href='https://yuzu-emu.org/wiki/faq/"
-                                "#yuzu-starts-with-the-error-broken-vulkan-installation-detected'>"
-                                "here for instructions to fix the issue</a>."));
+    if (!CheckVulkan()) {
+        config->Save();
 
+        QMessageBox::warning(
+            this, tr("Broken Vulkan Installation Detected"),
+            tr("Vulkan initialization failed on the previous boot.<br><br>Click <a "
+               "href='https://yuzu-emu.org/wiki/faq/"
+               "#yuzu-starts-with-the-error-broken-vulkan-installation-detected'>here for "
+               "instructions to fix the issue</a>."));
+    }
+    if (UISettings::values.has_broken_vulkan) {
         Settings::values.renderer_backend = Settings::RendererBackend::OpenGL;
 
         renderer_status_button->setDisabled(true);
@@ -3851,11 +3853,6 @@ void GMainWindow::SetDiscordEnabled([[maybe_unused]] bool state) {
 #endif
 
 int main(int argc, char* argv[]) {
-    bool has_broken_vulkan = false;
-    if (StartupChecks(argv[0], &has_broken_vulkan)) {
-        return 0;
-    }
-
     Common::DetachedTasks detached_tasks;
     MicroProfileOnThreadCreate("Frontend");
     SCOPE_EXIT({ MicroProfileShutdown(); });
@@ -3895,7 +3892,7 @@ int main(int argc, char* argv[]) {
     // generating shaders
     setlocale(LC_ALL, "C");
 
-    GMainWindow main_window{has_broken_vulkan};
+    GMainWindow main_window{};
     // After settings have been loaded by GMainWindow, apply the filter
     main_window.show();
 

src/yuzu/main.h

@@ -118,7 +118,7 @@ class GMainWindow : public QMainWindow {
 public:
     void filterBarSetChecked(bool state);
     void UpdateUITheme();
-    explicit GMainWindow(bool has_broken_vulkan);
+    explicit GMainWindow();
     ~GMainWindow() override;
 
     bool DropAction(QDropEvent* event);

src/yuzu/startup_checks.cpp

@@ -1,136 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-#ifdef _WIN32
-#include <cstring> // for memset, strncpy
-#include <processthreadsapi.h>
-#include <windows.h>
-#elif defined(YUZU_UNIX)
-#include <errno.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#endif
-
-#include <cstdio>
-#include "video_core/vulkan_common/vulkan_instance.h"
-#include "video_core/vulkan_common/vulkan_library.h"
-#include "yuzu/startup_checks.h"
-
-void CheckVulkan() {
-    // Just start the Vulkan loader, this will crash if something is wrong
-    try {
-        Vulkan::vk::InstanceDispatch dld;
-        const Common::DynamicLibrary library = Vulkan::OpenLibrary();
-        const Vulkan::vk::Instance instance =
-            Vulkan::CreateInstance(library, dld, VK_API_VERSION_1_0);
-
-    } catch (const Vulkan::vk::Exception& exception) {
-        std::fprintf(stderr, "Failed to initialize Vulkan: %s\n", exception.what());
-    }
-}
-
-bool StartupChecks(const char* arg0, bool* has_broken_vulkan) {
-#ifdef _WIN32
-    // Check environment variable to see if we are the child
-    char variable_contents[8];
-    const DWORD startup_check_var =
-        GetEnvironmentVariableA(STARTUP_CHECK_ENV_VAR, variable_contents, 8);
-    if (startup_check_var > 0 && std::strncmp(variable_contents, "ON", 8) == 0) {
-        CheckVulkan();
-        return true;
-    }
-
-    // Set the startup variable for child processes
-    const bool env_var_set = SetEnvironmentVariableA(STARTUP_CHECK_ENV_VAR, "ON");
-    if (!env_var_set) {
-        std::fprintf(stderr, "SetEnvironmentVariableA failed to set %s with error %d\n",
-                     STARTUP_CHECK_ENV_VAR, GetLastError());
-        return false;
-    }
-
-    PROCESS_INFORMATION process_info;
-    std::memset(&process_info, '\0', sizeof(process_info));
-
-    if (!SpawnChild(arg0, &process_info)) {
-        return false;
-    }
-
-    // Wait until the processs exits and get exit code from it
-    WaitForSingleObject(process_info.hProcess, INFINITE);
-    DWORD exit_code = STILL_ACTIVE;
-    const int err = GetExitCodeProcess(process_info.hProcess, &exit_code);
-    if (err == 0) {
-        std::fprintf(stderr, "GetExitCodeProcess failed with error %d\n", GetLastError());
-    }
-
-    // Vulkan is broken if the child crashed (return value is not zero)
-    *has_broken_vulkan = (exit_code != 0);
-
-    if (CloseHandle(process_info.hProcess) == 0) {
-        std::fprintf(stderr, "CloseHandle failed with error %d\n", GetLastError());
-    }
-    if (CloseHandle(process_info.hThread) == 0) {
-        std::fprintf(stderr, "CloseHandle failed with error %d\n", GetLastError());
-    }
-
-    if (!SetEnvironmentVariableA(STARTUP_CHECK_ENV_VAR, nullptr)) {
-        std::fprintf(stderr, "SetEnvironmentVariableA failed to clear %s with error %d\n",
-                     STARTUP_CHECK_ENV_VAR, GetLastError());
-    }
-
-#elif defined(YUZU_UNIX)
-    const pid_t pid = fork();
-    if (pid == 0) {
-        CheckVulkan();
-        return true;
-    } else if (pid == -1) {
-        const int err = errno;
-        std::fprintf(stderr, "fork failed with error %d\n", err);
-        return false;
-    }
-
-    // Get exit code from child process
-    int status;
-    const int r_val = wait(&status);
-    if (r_val == -1) {
-        const int err = errno;
-        std::fprintf(stderr, "wait failed with error %d\n", err);
-        return false;
-    }
-    // Vulkan is broken if the child crashed (return value is not zero)
-    *has_broken_vulkan = (status != 0);
-#endif
-    return false;
-}
-
-#ifdef _WIN32
-bool SpawnChild(const char* arg0, PROCESS_INFORMATION* pi) {
-    STARTUPINFOA startup_info;
-
-    std::memset(&startup_info, '\0', sizeof(startup_info));
-    startup_info.cb = sizeof(startup_info);
-
-    char p_name[255];
-    std::strncpy(p_name, arg0, 255);
-
-    const bool process_created = CreateProcessA(nullptr,       // lpApplicationName
-                                                p_name,        // lpCommandLine
-                                                nullptr,       // lpProcessAttributes
-                                                nullptr,       // lpThreadAttributes
-                                                false,         // bInheritHandles
-                                                0,             // dwCreationFlags
-                                                nullptr,       // lpEnvironment
-                                                nullptr,       // lpCurrentDirectory
-                                                &startup_info, // lpStartupInfo
-                                                pi             // lpProcessInformation
-    );
-    if (!process_created) {
-        std::fprintf(stderr, "CreateProcessA failed with error %d\n", GetLastError());
-        return false;
-    }
-
-    return true;
-}
-#endif

src/yuzu/startup_checks.h

@@ -1,17 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-constexpr char STARTUP_CHECK_ENV_VAR[] = "YUZU_DO_STARTUP_CHECKS";
-
-void CheckVulkan();
-bool StartupChecks(const char* arg0, bool* has_broken_vulkan);
-
-#ifdef _WIN32
-bool SpawnChild(const char* arg0, PROCESS_INFORMATION* pi);
-#endif

src/yuzu/uisettings.h

@@ -78,7 +78,7 @@ struct Values {
     Settings::Setting<bool> mute_when_in_background{false, "muteWhenInBackground"};
     Settings::Setting<bool> hide_mouse{true, "hideInactiveMouse"};
     // Set when Vulkan is known to crash the application
-    bool has_broken_vulkan = false;
+    Settings::Setting<bool> has_broken_vulkan{false, "has_broken_vulkan"};
 
     Settings::Setting<bool> select_user_on_boot{false, "select_user_on_boot"};
 

src/yuzu_cmd/config.cpp

@@ -99,8 +99,8 @@ void Config::ReadSetting(const std::string& group, Settings::Setting<bool>& sett
     setting = sdl2_config->GetBoolean(group, setting.GetLabel(), setting.GetDefault());
 }
 
-template <typename Type>
-void Config::ReadSetting(const std::string& group, Settings::Setting<Type>& setting) {
+template <typename Type, bool ranged>
+void Config::ReadSetting(const std::string& group, Settings::Setting<Type, ranged>& setting) {
     setting = static_cast<Type>(sdl2_config->GetInteger(group, setting.GetLabel(),
                                                         static_cast<long>(setting.GetDefault())));
 }

src/yuzu_cmd/config.h

@@ -33,6 +33,6 @@ private:
      * @param group The name of the INI group
      * @param setting The yuzu setting to modify
      */
-    template <typename Type>
-    void ReadSetting(const std::string& group, Settings::Setting<Type>& setting);
+    template <typename Type, bool ranged>
+    void ReadSetting(const std::string& group, Settings::Setting<Type, ranged>& setting);
 };