vk_rasterizer: Flip viewport on Y_NEGATE

Matches OpenGL's behavior. I don't believe this register flips geometry,
but we have to try to match behavior on both backends.

CMakeLists.txt

@@ -496,7 +496,7 @@ endif()
 # Ensure libusb is properly configured (based on dolphin libusb include)
 if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
     include(FindPkgConfig)
-    if (PKG_CONFIG_FOUND)
+    if (PKG_CONFIG_FOUND AND NOT CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
         pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
     else()
         find_package(LibUSB)

src/common/fs/fs_util.cpp

@@ -20,6 +20,10 @@ std::string ToUTF8String(std::u8string_view u8_string) {
     return std::string{u8_string.begin(), u8_string.end()};
 }
 
+std::string BufferToUTF8String(std::span<const u8> buffer) {
+    return std::string{buffer.begin(), std::ranges::find(buffer, u8{0})};
+}
+
 std::string PathToUTF8String(const std::filesystem::path& path) {
     return ToUTF8String(path.u8string());
 }

src/common/fs/fs_util.h

@@ -46,6 +46,17 @@ concept IsChar = std::same_as<T, char>;
  */
 [[nodiscard]] std::string ToUTF8String(std::u8string_view u8_string);
 
+/**
+ * Converts a buffer of bytes to a UTF8-encoded std::string.
+ * This converts from the start of the buffer until the first encountered null-terminator.
+ * If no null-terminator is found, this converts the entire buffer instead.
+ *
+ * @param buffer Buffer of bytes
+ *
+ * @returns UTF-8 encoded std::string.
+ */
+[[nodiscard]] std::string BufferToUTF8String(std::span<const u8> buffer);
+
 /**
  * Converts a filesystem path to a UTF-8 encoded std::string.
  *

src/common/host_memory.cpp

@@ -6,7 +6,7 @@
 #include <windows.h>
 #include "common/dynamic_library.h"
 
-#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
+#elif defined(__linux__) || defined(__FreeBSD__) // ^^^ Windows ^^^ vvv Linux vvv
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
@@ -343,7 +343,7 @@ private:
     std::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
 };
 
-#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
+#elif defined(__linux__) || defined(__FreeBSD__) // ^^^ Windows ^^^ vvv Linux vvv
 
 class HostMemory::Impl {
 public:
@@ -357,7 +357,12 @@ public:
         });
 
         // Backing memory initialization
+#if defined(__FreeBSD__) && __FreeBSD__ < 13
+        // XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30
+        fd = shm_open(SHM_ANON, O_RDWR, 0600);
+#else
         fd = memfd_create("HostMemory", 0);
+#endif
         if (fd == -1) {
             LOG_CRITICAL(HW_Memory, "memfd_create failed: {}", strerror(errno));
             throw std::bad_alloc{};

src/common/settings.h

@@ -42,6 +42,11 @@ enum class CPUAccuracy : u32 {
     Unsafe = 2,
 };
 
+enum class FullscreenMode : u32 {
+    Borderless = 0,
+    Exclusive = 1,
+};
+
 /** The BasicSetting 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. Setting a default value and label is required, though subclasses may deviate from
@@ -322,11 +327,11 @@ struct Values {
     Setting<u16> resolution_factor{1, "resolution_factor"};
     // *nix platforms may have issues with the borderless windowed fullscreen mode.
     // Default to exclusive fullscreen on these platforms for now.
-    Setting<int> fullscreen_mode{
+    Setting<FullscreenMode> fullscreen_mode{
 #ifdef _WIN32
-        0,
+        FullscreenMode::Borderless,
 #else
-        1,
+        FullscreenMode::Exclusive,
 #endif
         "fullscreen_mode"};
     Setting<int> aspect_ratio{0, "aspect_ratio"};

src/shader_recompiler/exception.h

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include <stdexcept>
+#include <exception>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -17,7 +17,7 @@ class Exception : public std::exception {
 public:
     explicit Exception(std::string message) noexcept : err_message{std::move(message)} {}
 
-    const char* what() const noexcept override {
+    [[nodiscard]] const char* what() const noexcept override {
         return err_message.c_str();
     }
 
@@ -36,21 +36,21 @@ private:
 class LogicError : public Exception {
 public:
     template <typename... Args>
-    LogicError(const char* message, Args&&... args)
+    explicit LogicError(const char* message, Args&&... args)
         : Exception{fmt::format(fmt::runtime(message), std::forward<Args>(args)...)} {}
 };
 
 class RuntimeError : public Exception {
 public:
     template <typename... Args>
-    RuntimeError(const char* message, Args&&... args)
+    explicit RuntimeError(const char* message, Args&&... args)
         : Exception{fmt::format(fmt::runtime(message), std::forward<Args>(args)...)} {}
 };
 
 class NotImplementedException : public Exception {
 public:
     template <typename... Args>
-    NotImplementedException(const char* message, Args&&... args)
+    explicit NotImplementedException(const char* message, Args&&... args)
         : Exception{fmt::format(fmt::runtime(message), std::forward<Args>(args)...)} {
         Append(" is not implemented");
     }
@@ -59,7 +59,7 @@ public:
 class InvalidArgument : public Exception {
 public:
     template <typename... Args>
-    InvalidArgument(const char* message, Args&&... args)
+    explicit InvalidArgument(const char* message, Args&&... args)
         : Exception{fmt::format(fmt::runtime(message), std::forward<Args>(args)...)} {}
 };
 

src/shader_recompiler/ir_opt/collect_shader_info_pass.cpp

@@ -111,6 +111,8 @@ void VisitUsages(Info& info, IR::Inst& inst) {
     case IR::Opcode::ConvertF16U16:
     case IR::Opcode::ConvertF16U32:
     case IR::Opcode::ConvertF16U64:
+    case IR::Opcode::ConvertF16F32:
+    case IR::Opcode::ConvertF32F16:
     case IR::Opcode::FPAbs16:
     case IR::Opcode::FPAdd16:
     case IR::Opcode::FPCeil16:

src/video_core/buffer_cache/buffer_cache.h

@@ -817,7 +817,6 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
             const std::size_t size = interval.upper() - interval.lower();
             const VAddr cpu_addr = interval.lower();
             ForEachBufferInRange(cpu_addr, size, [&](BufferId buffer_id, Buffer& buffer) {
-                boost::container::small_vector<BufferCopy, 1> copies;
                 buffer.ForEachDownloadRangeAndClear(
                     cpu_addr, size, [&](u64 range_offset, u64 range_size) {
                         const VAddr buffer_addr = buffer.CpuAddr();

src/video_core/engines/fermi_2d.h

@@ -299,7 +299,7 @@ public:
     };
 
 private:
-    VideoCore::RasterizerInterface* rasterizer;
+    VideoCore::RasterizerInterface* rasterizer = nullptr;
 
     /// Performs the copy from the source surface to the destination surface as configured in the
     /// registers.

src/video_core/engines/maxwell_dma.h

@@ -227,7 +227,7 @@ private:
     Core::System& system;
 
     MemoryManager& memory_manager;
-    VideoCore::RasterizerInterface* rasterizer;
+    VideoCore::RasterizerInterface* rasterizer = nullptr;
 
     std::vector<u8> read_buffer;
     std::vector<u8> write_buffer;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -441,7 +441,6 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
 
     std::array<const Shader::Info*, Maxwell::MaxShaderStage> infos{};
 
-    OGLProgram source_program;
     std::array<std::string, 5> sources;
     std::array<std::vector<u32>, 5> sources_spirv;
     Shader::Backend::Bindings binding;

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -258,10 +258,9 @@ std::pair<VkBuffer, VkDeviceSize> Uint8Pass::Assemble(u32 num_vertices, VkBuffer
     update_descriptor_queue.AddBuffer(src_buffer, src_offset, num_vertices);
     update_descriptor_queue.AddBuffer(staging.buffer, staging.offset, staging_size);
     const void* const descriptor_data{update_descriptor_queue.UpdateData()};
-    const VkBuffer buffer{staging.buffer};
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([this, buffer, descriptor_data, num_vertices](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([this, descriptor_data, num_vertices](vk::CommandBuffer cmdbuf) {
         static constexpr u32 DISPATCH_SIZE = 1024;
         static constexpr VkMemoryBarrier WRITE_BARRIER{
             .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
@@ -319,7 +318,7 @@ std::pair<VkBuffer, VkDeviceSize> QuadIndexedPass::Assemble(
     const void* const descriptor_data{update_descriptor_queue.UpdateData()};
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([this, buffer = staging.buffer, descriptor_data, num_tri_vertices, base_vertex,
+    scheduler.Record([this, descriptor_data, num_tri_vertices, base_vertex,
                       index_shift](vk::CommandBuffer cmdbuf) {
         static constexpr u32 DISPATCH_SIZE = 1024;
         static constexpr VkMemoryBarrier WRITE_BARRIER{

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -61,11 +61,16 @@ struct DrawParams {
 VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t index) {
     const auto& src = regs.viewport_transform[index];
     const float width = src.scale_x * 2.0f;
-    const float height = src.scale_y * 2.0f;
+    float y = src.translate_y - src.scale_y;
+    float height = src.scale_y * 2.0f;
+    if (regs.screen_y_control.y_negate) {
+        y += height;
+        height = -height;
+    }
     const float reduce_z = regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1.0f : 0.0f;
     VkViewport viewport{
         .x = src.translate_x - src.scale_x,
-        .y = src.translate_y - src.scale_y,
+        .y = y,
         .width = width != 0.0f ? width : 1.0f,
         .height = height != 0.0f ? height : 1.0f,
         .minDepth = src.translate_z - src.scale_z * reduce_z,

src/video_core/texture_cache/render_targets.h

@@ -24,10 +24,10 @@ struct RenderTargets {
         return std::ranges::any_of(color_buffer_ids, contains) || contains(depth_buffer_id);
     }
 
-    std::array<ImageViewId, NUM_RT> color_buffer_ids;
-    ImageViewId depth_buffer_id;
+    std::array<ImageViewId, NUM_RT> color_buffer_ids{};
+    ImageViewId depth_buffer_id{};
     std::array<u8, NUM_RT> draw_buffers{};
-    Extent2D size;
+    Extent2D size{};
 };
 
 } // namespace VideoCommon

src/yuzu/applets/qt_web_browser.cpp

@@ -107,6 +107,7 @@ void QtNXWebEngineView::LoadLocalWebPage(const std::string& main_url,
     is_local = true;
 
     LoadExtractedFonts();
+    FocusFirstLinkElement();
     SetUserAgent(UserAgent::WebApplet);
     SetFinished(false);
     SetExitReason(Service::AM::Applets::WebExitReason::EndButtonPressed);
@@ -121,6 +122,7 @@ void QtNXWebEngineView::LoadExternalWebPage(const std::string& main_url,
                                             const std::string& additional_args) {
     is_local = false;
 
+    FocusFirstLinkElement();
     SetUserAgent(UserAgent::WebApplet);
     SetFinished(false);
     SetExitReason(Service::AM::Applets::WebExitReason::EndButtonPressed);
@@ -208,7 +210,7 @@ void QtNXWebEngineView::HandleWindowFooterButtonPressedOnce() {
         if (input_interpreter->IsButtonPressedOnce(button)) {
             page()->runJavaScript(
                 QStringLiteral("yuzu_key_callbacks[%1] == null;").arg(static_cast<u8>(button)),
-                [&](const QVariant& variant) {
+                [this, button](const QVariant& variant) {
                     if (variant.toBool()) {
                         switch (button) {
                         case HIDButton::A:
@@ -364,6 +366,17 @@ void QtNXWebEngineView::LoadExtractedFonts() {
         Qt::QueuedConnection);
 }
 
+void QtNXWebEngineView::FocusFirstLinkElement() {
+    QWebEngineScript focus_link_element;
+
+    focus_link_element.setName(QStringLiteral("focus_link_element.js"));
+    focus_link_element.setSourceCode(QString::fromStdString(FOCUS_LINK_ELEMENT_SCRIPT));
+    focus_link_element.setWorldId(QWebEngineScript::MainWorld);
+    focus_link_element.setInjectionPoint(QWebEngineScript::Deferred);
+    focus_link_element.setRunsOnSubFrames(true);
+    default_profile->scripts()->insert(focus_link_element);
+}
+
 #endif
 
 QtWebBrowser::QtWebBrowser(GMainWindow& main_window) {

src/yuzu/applets/qt_web_browser.h

@@ -161,6 +161,9 @@ private:
     /// Loads the extracted fonts using JavaScript.
     void LoadExtractedFonts();
 
+    /// Brings focus to the first available link element.
+    void FocusFirstLinkElement();
+
     InputCommon::InputSubsystem* input_subsystem;
 
     std::unique_ptr<UrlRequestInterceptor> url_interceptor;

src/yuzu/applets/qt_web_browser_scripts.h

@@ -73,6 +73,12 @@ constexpr char LOAD_NX_FONT[] = R"(
 })();
 )";
 
+constexpr char FOCUS_LINK_ELEMENT_SCRIPT[] = R"(
+if (document.getElementsByTagName("a").length > 0) {
+    document.getElementsByTagName("a")[0].focus();
+}
+)";
+
 constexpr char GAMEPAD_SCRIPT[] = R"(
 window.addEventListener("gamepadconnected", function(e) {
     console.log("Gamepad connected at index %d: %s. %d buttons, %d axes.",

src/yuzu/configuration/config.cpp

@@ -1332,7 +1332,10 @@ void Config::SaveRendererValues() {
                  static_cast<u32>(Settings::values.renderer_backend.GetDefault()),
                  Settings::values.renderer_backend.UsingGlobal());
     WriteGlobalSetting(Settings::values.vulkan_device);
-    WriteGlobalSetting(Settings::values.fullscreen_mode);
+    WriteSetting(QString::fromStdString(Settings::values.fullscreen_mode.GetLabel()),
+                 static_cast<u32>(Settings::values.fullscreen_mode.GetValue(global)),
+                 static_cast<u32>(Settings::values.fullscreen_mode.GetDefault()),
+                 Settings::values.fullscreen_mode.UsingGlobal());
     WriteGlobalSetting(Settings::values.aspect_ratio);
     WriteGlobalSetting(Settings::values.max_anisotropy);
     WriteGlobalSetting(Settings::values.use_speed_limit);

src/yuzu/configuration/config.h

@@ -181,5 +181,6 @@ private:
 // 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::FullscreenMode);
 Q_DECLARE_METATYPE(Settings::RendererBackend);
 Q_DECLARE_METATYPE(Settings::ShaderBackend);

src/yuzu/configuration/configuration_shared.cpp

@@ -25,20 +25,6 @@ void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<bool>* setting,
     }
 }
 
-void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<int>* setting,
-                                              const QComboBox* combobox) {
-    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::SetPerGameSetting(QCheckBox* checkbox,
                                             const Settings::Setting<bool>* setting) {
     if (setting->UsingGlobal()) {

src/yuzu/configuration/configuration_shared.h

@@ -28,7 +28,20 @@ enum class CheckState {
 // ApplyPerGameSetting, given a Settings::Setting and a Qt UI element, properly applies a Setting
 void ApplyPerGameSetting(Settings::Setting<bool>* setting, const QCheckBox* checkbox,
                          const CheckState& tracker);
-void ApplyPerGameSetting(Settings::Setting<int>* setting, const QComboBox* combobox);
+template <typename Type>
+void ApplyPerGameSetting(Settings::Setting<Type>* 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::Setting<bool>* setting);

src/yuzu/configuration/configure_cpu.cpp

@@ -65,6 +65,7 @@ void ConfigureCpu::UpdateGroup(int index) {
 }
 
 void ConfigureCpu::ApplyConfiguration() {
+    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);
@@ -80,22 +81,6 @@ void ConfigureCpu::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_fastmem_check,
                                              ui->cpuopt_unsafe_fastmem_check,
                                              cpuopt_unsafe_fastmem_check);
-
-    if (Settings::IsConfiguringGlobal()) {
-        // Guard if during game and set to game-specific value
-        if (Settings::values.cpu_accuracy.UsingGlobal()) {
-            Settings::values.cpu_accuracy.SetValue(
-                static_cast<Settings::CPUAccuracy>(ui->accuracy->currentIndex()));
-        }
-    } else {
-        if (ui->accuracy->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
-            Settings::values.cpu_accuracy.SetGlobal(true);
-        } else {
-            Settings::values.cpu_accuracy.SetGlobal(false);
-            Settings::values.cpu_accuracy.SetValue(static_cast<Settings::CPUAccuracy>(
-                ui->accuracy->currentIndex() - ConfigurationShared::USE_GLOBAL_OFFSET));
-        }
-    }
 }
 
 void ConfigureCpu::changeEvent(QEvent* event) {

src/yuzu/configuration/configure_graphics.cpp

@@ -98,7 +98,8 @@ void ConfigureGraphics::SetConfiguration() {
 
     if (Settings::IsConfiguringGlobal()) {
         ui->api->setCurrentIndex(static_cast<int>(Settings::values.renderer_backend.GetValue()));
-        ui->fullscreen_mode_combobox->setCurrentIndex(Settings::values.fullscreen_mode.GetValue());
+        ui->fullscreen_mode_combobox->setCurrentIndex(
+            static_cast<int>(Settings::values.fullscreen_mode.GetValue()));
         ui->aspect_ratio_combobox->setCurrentIndex(Settings::values.aspect_ratio.GetValue());
     } else {
         ConfigurationShared::SetPerGameSetting(ui->api, &Settings::values.renderer_backend);
@@ -310,8 +311,9 @@ void ConfigureGraphics::SetupPerGameUI() {
 
     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,
-                                            Settings::values.fullscreen_mode.GetValue(true));
+    ConfigurationShared::SetColoredComboBox(
+        ui->fullscreen_mode_combobox, ui->fullscreen_mode_label,
+        static_cast<int>(Settings::values.fullscreen_mode.GetValue(true)));
     ConfigurationShared::InsertGlobalItem(
         ui->api, static_cast<int>(Settings::values.renderer_backend.GetValue(true)));
 }

src/yuzu/configuration/configure_graphics_advanced.cpp

@@ -48,11 +48,7 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
 }
 
 void ConfigureGraphicsAdvanced::ApplyConfiguration() {
-    // Subtract 2 if configuring per-game (separator and "use global configuration" take 2 slots)
-    const auto gpu_accuracy = static_cast<Settings::GPUAccuracy>(
-        ui->gpu_accuracy->currentIndex() -
-        ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
-
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.gpu_accuracy, ui->gpu_accuracy);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
                                              ui->anisotropic_filtering_combobox);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync, use_vsync);
@@ -63,20 +59,6 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
                                              use_caches_gc);
     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);
-        }
-    } else {
-        if (ui->gpu_accuracy->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
-            Settings::values.gpu_accuracy.SetGlobal(true);
-        } else {
-            Settings::values.gpu_accuracy.SetGlobal(false);
-            Settings::values.gpu_accuracy.SetValue(gpu_accuracy);
-        }
-    }
 }
 
 void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {

src/yuzu/main.cpp

@@ -2513,7 +2513,7 @@ void GMainWindow::ShowFullscreen() {
         ui.menubar->hide();
         statusBar()->hide();
 
-        if (Settings::values.fullscreen_mode.GetValue() == 1) {
+        if (Settings::values.fullscreen_mode.GetValue() == Settings::FullscreenMode::Exclusive) {
             showFullScreen();
             return;
         }
@@ -2528,7 +2528,7 @@ void GMainWindow::ShowFullscreen() {
     } else {
         UISettings::values.renderwindow_geometry = render_window->saveGeometry();
 
-        if (Settings::values.fullscreen_mode.GetValue() == 1) {
+        if (Settings::values.fullscreen_mode.GetValue() == Settings::FullscreenMode::Exclusive) {
             render_window->showFullScreen();
             return;
         }
@@ -2545,7 +2545,7 @@ void GMainWindow::ShowFullscreen() {
 
 void GMainWindow::HideFullscreen() {
     if (ui.action_Single_Window_Mode->isChecked()) {
-        if (Settings::values.fullscreen_mode.GetValue() == 1) {
+        if (Settings::values.fullscreen_mode.GetValue() == Settings::FullscreenMode::Exclusive) {
             showNormal();
             restoreGeometry(UISettings::values.geometry);
         } else {
@@ -2559,7 +2559,7 @@ void GMainWindow::HideFullscreen() {
         statusBar()->setVisible(ui.action_Show_Status_Bar->isChecked());
         ui.menubar->show();
     } else {
-        if (Settings::values.fullscreen_mode.GetValue() == 1) {
+        if (Settings::values.fullscreen_mode.GetValue() == Settings::FullscreenMode::Exclusive) {
             render_window->showNormal();
             render_window->restoreGeometry(UISettings::values.renderwindow_geometry);
         } else {

src/yuzu_cmd/emu_window/emu_window_sdl2.cpp

@@ -124,7 +124,7 @@ void EmuWindow_SDL2::OnResize() {
 
 void EmuWindow_SDL2::Fullscreen() {
     switch (Settings::values.fullscreen_mode.GetValue()) {
-    case 1: // Exclusive fullscreen
+    case Settings::FullscreenMode::Exclusive:
         // Set window size to render size before entering fullscreen -- SDL does not resize to
         // display dimensions in this mode.
         // TODO: Multiply the window size by resolution_factor (for both docked modes)
@@ -140,7 +140,7 @@ void EmuWindow_SDL2::Fullscreen() {
         LOG_ERROR(Frontend, "Fullscreening failed: {}", SDL_GetError());
         LOG_INFO(Frontend, "Attempting to use borderless fullscreen...");
         [[fallthrough]];
-    case 0: // Borderless window
+    case Settings::FullscreenMode::Borderless:
         if (SDL_SetWindowFullscreen(render_window, SDL_WINDOW_FULLSCREEN_DESKTOP) == 0) {
             return;
         }