no blur

2025-11-28 19:22:48 +03:00
31 changed files with 498 additions and 212 deletions
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -27,7 +27,7 @@ set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL ON)

 # Xbyak (also used by Dynarmic, so needs to be added first)
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    if (PLATFORM_SUN OR PLATFORM_OPENBSD OR PLATFORM_NETBSD OR PLATFORM_DRAGONFLY)
+    if (PLATFORM_SUN OR PLATFORM_OPENBSD)
        AddJsonPackage(xbyak_sun)
    else()
        AddJsonPackage(xbyak)
--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -22,21 +22,33 @@ void AssertFailSoftImpl();
 #define YUZU_NO_INLINE __attribute__((noinline))
 #endif

+#define ASSERT(_a_)                                                                                \
+    ([&]() YUZU_NO_INLINE {                                                                        \
+        if (!(_a_)) [[unlikely]] {                                                                 \
+            LOG_CRITICAL(Debug, "Assert");                                              \
+            AssertFailSoftImpl();                                                                    \
+        }                                                                                          \
+    }())
+
 #define ASSERT_MSG(_a_, ...)                                                                       \
    ([&]() YUZU_NO_INLINE {                                                                        \
        if (!(_a_)) [[unlikely]] {                                                                 \
-            LOG_CRITICAL(Debug, __FILE__ ": assert\n" __VA_ARGS__);                                \
-            AssertFailSoftImpl();                                                                  \
+            LOG_CRITICAL(Debug, "Assert\n" __VA_ARGS__);                                \
+            AssertFailSoftImpl();                                                                    \
        }                                                                                          \
    }())
-#define ASSERT(_a_) ASSERT_MSG(_a_, "{}", #_a_)
+
+#define UNREACHABLE()                                                                              \
+    do {                                                                                           \
+        LOG_CRITICAL(Debug, "Unreachable");                                                  \
+        AssertFatalImpl();                                                                        \
+    } while (0)

 #define UNREACHABLE_MSG(...)                                                                       \
    do {                                                                                           \
-        LOG_CRITICAL(Debug, __FILE__ ": unreachable\n" __VA_ARGS__);                               \
-        AssertFatalImpl();                                                                         \
+        LOG_CRITICAL(Debug, "Unreachable\n" __VA_ARGS__);                                    \
+        AssertFatalImpl();                                                                        \
    } while (0)
-#define UNREACHABLE() UNREACHABLE_MSG("")

 #ifdef _DEBUG
 #define DEBUG_ASSERT(_a_) ASSERT(_a_)
@@ -57,11 +69,19 @@ void AssertFailSoftImpl();
 #define UNIMPLEMENTED_IF_MSG(cond, ...) ASSERT_MSG(!(cond), __VA_ARGS__)

 // If the assert is ignored, execute _b_
-#define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
+#define ASSERT_OR_EXECUTE(_a_, _b_)                                                                \
    do {                                                                                           \
-        ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
-        if (!(_a_)) { _b_ }                                                                        \
+        ASSERT(_a_);                                                                               \
+        if (!(_a_)) [[unlikely]] {                                                                 \
+            _b_                                                                                    \
+        }                                                                                          \
    } while (0)

 // If the assert is ignored, execute _b_
-#define ASSERT_OR_EXECUTE(_a_, _b_) ASSERT_OR_EXECUTE_MSG(_a_, _b_, "{}", #_a_)
+#define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
+    do {                                                                                           \
+        ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
+            _b_                                                                                    \
+        }                                                                                          \
+    } while (0)
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -50,7 +50,8 @@ constexpr const char* TrimSourcePath(std::string_view source) {
 }

 /// @brief Interface for logging backends.
-struct Backend {
+class Backend {
+public:
    virtual ~Backend() = default;
    virtual void Write(const Entry& entry) = 0;
    virtual void EnableForStacktrace() = 0;
@@ -58,7 +59,8 @@ struct Backend {
 };

 /// @brief Backend that writes to stderr and with color
-struct ColorConsoleBackend final : public Backend {
+class ColorConsoleBackend final : public Backend {
+public:
    explicit ColorConsoleBackend() = default;
    ~ColorConsoleBackend() override = default;

@@ -84,15 +86,16 @@ private:
 };

 /// @brief Backend that writes to a file passed into the constructor
-struct FileBackend final : public Backend {
+class FileBackend final : public Backend {
+public:
    explicit FileBackend(const std::filesystem::path& filename) {
        auto old_filename = filename;
        old_filename += ".old.txt";

        // Existence checks are done within the functions themselves.
        // We don't particularly care if these succeed or not.
-        void(FS::RemoveFile(old_filename));
-        void(FS::RenameFile(filename, old_filename));
+        static_cast<void>(FS::RemoveFile(old_filename));
+        static_cast<void>(FS::RenameFile(filename, old_filename));

        file = std::make_unique<FS::IOFile>(filename, FS::FileAccessMode::Write, FS::FileType::TextFile);
    }
@@ -162,34 +165,51 @@ private:
    bool enabled = true;
 };

-#ifdef _WIN32
-/// @brief Backend that writes to Visual Studio's output window
-struct DebuggerBackend final : public Backend {
+/**
+ * Backend that writes to Visual Studio's output window
+ */
+class DebuggerBackend final : public Backend {
+public:
    explicit DebuggerBackend() = default;
+
    ~DebuggerBackend() override = default;
+
    void Write(const Entry& entry) override {
+#ifdef _WIN32
        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
+#endif
    }
+
    void Flush() override {}
+
    void EnableForStacktrace() override {}
 };
-#endif
+
 #ifdef ANDROID
-/// @brief Backend that writes to the Android logcat
-struct LogcatBackend : public Backend {
+/**
+ * Backend that writes to the Android logcat
+ */
+class LogcatBackend : public Backend {
+public:
    explicit LogcatBackend() = default;
+
    ~LogcatBackend() override = default;
+
    void Write(const Entry& entry) override {
        PrintMessageToLogcat(entry);
    }
+
    void Flush() override {}
+
    void EnableForStacktrace() override {}
 };
 #endif

 bool initialization_in_progress_suppress_logging = true;

-/// @brief Static state as a singleton.
+/**
+ * Static state as a singleton.
+ */
 class Impl {
 public:
    static Impl& Instance() {
@@ -208,7 +228,8 @@ public:
        void(CreateDir(log_dir));
        Filter filter;
        filter.ParseFilterString(Settings::values.log_filter.GetValue());
-        instance = std::unique_ptr<Impl, decltype(&Deleter)>(new Impl(log_dir / LOG_FILE, filter), Deleter);
+        instance = std::unique_ptr<Impl, decltype(&Deleter)>(new Impl(log_dir / LOG_FILE, filter),
+                                                             Deleter);
        initialization_in_progress_suppress_logging = false;
    }

@@ -255,14 +276,13 @@ private:
            Common::SetCurrentThreadName("Logger");
            Entry entry;
            const auto write_logs = [this, &entry]() {
-                ForEachBackend([&entry](Backend& backend) {
-                    backend.Write(entry);
-                });
+                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
            };
-            do {
+            while (!stop_token.stop_requested()) {
                message_queue.PopWait(entry, stop_token);
-                write_logs();
-            } while (!stop_token.stop_requested());
+                if (entry.filename != nullptr)
+                    write_logs();
+            }
            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
            // case where a system is repeatedly spamming logs even on close.
            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
@@ -295,11 +315,9 @@ private:
    }

    void ForEachBackend(auto lambda) {
+        lambda(static_cast<Backend&>(debugger_backend));
        lambda(static_cast<Backend&>(color_console_backend));
        lambda(static_cast<Backend&>(file_backend));
-#ifdef _WIN32
-        lambda(static_cast<Backend&>(debugger_backend));
-#endif
 #ifdef ANDROID
        lambda(static_cast<Backend&>(lc_backend));
 #endif
@@ -312,11 +330,9 @@ private:
    static inline std::unique_ptr<Impl, decltype(&Deleter)> instance{nullptr, Deleter};

    Filter filter;
+    DebuggerBackend debugger_backend{};
    ColorConsoleBackend color_console_backend{};
    FileBackend file_backend;
-#ifdef _WIN32
-    DebuggerBackend debugger_backend{};
-#endif
 #ifdef ANDROID
    LogcatBackend lc_backend{};
 #endif
--- a/src/common/steady_clock.cpp
+++ b/src/common/steady_clock.cpp
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -28,21 +25,15 @@ static s64 WindowsQueryPerformanceCounter() {
 }

 static s64 GetSystemTimeNS() {
-    static auto pf = (decltype(&GetSystemTimePreciseAsFileTime))(void*)GetProcAddress(GetModuleHandle(TEXT("Kernel32.dll")), "GetSystemTimePreciseAsFileTime"); // Windows 8+
-    if (pf) {
-        // GetSystemTimePreciseAsFileTime returns the file time in 100ns units.
-        constexpr s64 Multiplier = 100;
-        // Convert Windows epoch to Unix epoch.
-        constexpr s64 WindowsEpochToUnixEpoch = 0x19DB1DED53E8000LL;
-        FILETIME filetime;
-        pf(&filetime);
-        return Multiplier * ((s64(filetime.dwHighDateTime) << 32) + s64(filetime.dwLowDateTime) - WindowsEpochToUnixEpoch);
-    } else {
-        // Only Windows XP and below error out here
-        LARGE_INTEGER ticks;
-        QueryPerformanceCounter(&ticks);
-        return ticks.QuadPart;
-    }
+    // GetSystemTimePreciseAsFileTime returns the file time in 100ns units.
+    static constexpr s64 Multiplier = 100;
+    // Convert Windows epoch to Unix epoch.
+    static constexpr s64 WindowsEpochToUnixEpoch = 0x19DB1DED53E8000LL;
+
+    FILETIME filetime;
+    GetSystemTimePreciseAsFileTime(&filetime);
+    return Multiplier * ((static_cast<s64>(filetime.dwHighDateTime) << 32) +
+                         static_cast<s64>(filetime.dwLowDateTime) - WindowsEpochToUnixEpoch);
 }
 #endif

--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -81,9 +81,10 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {

 // Sets the debugger-visible name of the current thread.
 void SetCurrentThreadName(const char* name) {
-    static auto pf = (decltype(&SetThreadDescription))(void*)GetProcAddress(GetModuleHandle(TEXT("KernelBase.dll")), "SetThreadDescription");
-    if (pf)
+    if (auto pf = (decltype(&SetThreadDescription))(void*)GetProcAddress(GetModuleHandle(TEXT("KernelBase.dll")), "SetThreadDescription"); pf)
        pf(GetCurrentThread(), UTF8ToUTF16W(name).data()); // Windows 10+
+    else
+        ; // No-op
 }

 #else // !MSVC_VER, so must be POSIX threads
--- a/src/common/windows/timer_resolution.cpp
+++ b/src/common/windows/timer_resolution.cpp
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -65,15 +62,14 @@ TimerResolution GetTimerResolution() {

 void SetHighQoS() {
    // https://learn.microsoft.com/en-us/windows/win32/procthread/quality-of-service
-    static auto pf = (decltype(&SetProcessInformation))(void*)GetProcAddress(GetModuleHandle(TEXT("Kernel32.dll")), "SetProcessInformation");
-    if (pf) {
-        PROCESS_POWER_THROTTLING_STATE PowerThrottling{
-            .Version = PROCESS_POWER_THROTTLING_CURRENT_VERSION,
-            .ControlMask = PROCESS_POWER_THROTTLING_EXECUTION_SPEED | PROCESS_POWER_THROTTLING_IGNORE_TIMER_RESOLUTION,
-            .StateMask = 0,
-        };
-        pf(GetCurrentProcess(), ProcessPowerThrottling, &PowerThrottling, sizeof(PROCESS_POWER_THROTTLING_STATE)); // Windows 7+
-    }
+    PROCESS_POWER_THROTTLING_STATE PowerThrottling{
+        .Version{PROCESS_POWER_THROTTLING_CURRENT_VERSION},
+        .ControlMask{PROCESS_POWER_THROTTLING_EXECUTION_SPEED |
+                     PROCESS_POWER_THROTTLING_IGNORE_TIMER_RESOLUTION},
+        .StateMask{},
+    };
+    SetProcessInformation(GetCurrentProcess(), ProcessPowerThrottling, &PowerThrottling,
+                          sizeof(PROCESS_POWER_THROTTLING_STATE));
 }

 } // Anonymous namespace
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -211,7 +211,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
    config.enable_cycle_counting = !m_uses_wall_clock;

    // Code cache size
-#if defined(ARCHITECTURE_arm64) || defined(__sun__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
+#if defined(ARCHITECTURE_arm64) || defined(__sun__)
    config.code_cache_size = std::uint32_t(128_MiB);
 #else
    config.code_cache_size = std::uint32_t(512_MiB);
@@ -295,7 +295,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
    // Curated optimizations
    case Settings::CpuAccuracy::Auto:
        config.unsafe_optimizations = true;
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__DragonFly__) || defined(__NetBSD__)
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__DragonFly__)
        config.fastmem_pointer = std::nullopt;
        config.fastmem_exclusive_access = false;
 #endif
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -270,7 +270,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ArmDynarmic64::MakeJit(Common::PageTable* pa
    config.enable_cycle_counting = !m_uses_wall_clock;

    // Code cache size
-#if defined(ARCHITECTURE_arm64) || defined(__sun__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
+#if defined(ARCHITECTURE_arm64) || defined(__sun__)
    config.code_cache_size = std::uint32_t(128_MiB);
 #else
    config.code_cache_size = std::uint32_t(512_MiB);
--- a/src/core/hle/service/set/system_settings_server.cpp
+++ b/src/core/hle/service/set/system_settings_server.cpp
@@ -339,10 +339,14 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_)
    };
    m_system_settings.eula_versions[0] = eula_version;
    m_system_settings.eula_version_count = 1;
+
+    m_save_thread =
+        std::jthread([this](std::stop_token stop_token) { StoreSettingsThreadFunc(stop_token); });
 }

 ISystemSettingsServer::~ISystemSettingsServer() {
    SetSaveNeeded();
+    m_save_thread.request_stop();
 }

 bool ISystemSettingsServer::LoadSettingsFile(std::filesystem::path& path, auto&& default_func) {
@@ -1389,9 +1393,20 @@ void ISystemSettingsServer::StoreSettings() {
    }
 }

+void ISystemSettingsServer::StoreSettingsThreadFunc(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("SettingsStore");
+
+    while (Common::StoppableTimedWait(stop_token, std::chrono::minutes(1))) {
+        std::scoped_lock l{m_save_needed_mutex};
+        if (!std::exchange(m_save_needed, false))
+            continue;
+        StoreSettings();
+    }
+}
+
 void ISystemSettingsServer::SetSaveNeeded() {
    std::scoped_lock l{m_save_needed_mutex};
-    StoreSettings();
+    m_save_needed = true;
 }

 Result ISystemSettingsServer::GetSettingsItemValueImpl(std::span<u8> out_value, u64& out_size,
--- a/src/core/hle/service/set/system_settings_server.h
+++ b/src/core/hle/service/set/system_settings_server.h
@@ -167,6 +167,7 @@ private:
    bool StoreSettingsFile(std::filesystem::path& path, auto& settings);
    void SetupSettings();
    void StoreSettings();
+    void StoreSettingsThreadFunc(std::stop_token stop_token);
    void SetSaveNeeded();

    Core::System& m_system;
@@ -175,6 +176,7 @@ private:
    DeviceSettings m_device_settings{};
    ApplnSettings m_appln_settings{};
    std::mutex m_save_needed_mutex;
+    std::jthread m_save_thread;
    bool m_save_needed{false};
 };

--- a/src/dynarmic/CMakeLists.txt
+++ b/src/dynarmic/CMakeLists.txt
@@ -18,12 +18,7 @@ endif()
 # Dynarmic project options
 option(DYNARMIC_ENABLE_CPU_FEATURE_DETECTION "Turning this off causes dynarmic to assume the host CPU doesn't support anything later than SSE3" ON)

-if (PLATFORM_OPENBSD OR PLATFORM_DRAGONFLY OR PLATFORM_NETBSD)
-    set(REQUIRE_WX ON)
-else()
-    set(REQUIRE_WX OFF)
-endif()
-option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" ${REQUIRE_WX})
+option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" ${PLATFORM_OPENBSD})

 option(DYNARMIC_IGNORE_ASSERTS "Ignore asserts" OFF)
 option(DYNARMIC_TESTS_USE_UNICORN "Enable fuzzing tests against unicorn" OFF)
--- a/src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64.cpp
+++ b/src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64.cpp
@@ -87,11 +87,9 @@ A32EmitX64::A32EmitX64(BlockOfCode& code, A32::UserConfig conf, A32::Jit* jit_in
    code.PreludeComplete();
    ClearFastDispatchTable();

-    if (conf.fastmem_pointer.has_value()) {
-        exception_handler.SetFastmemCallback([this](u64 rip_) {
-            return FastmemCallback(rip_);
-        });
-    }
+    exception_handler.SetFastmemCallback([this](u64 rip_) {
+        return FastmemCallback(rip_);
+    });
 }

 A32EmitX64::~A32EmitX64() = default;
--- a/src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64.cpp
+++ b/src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64.cpp
@@ -61,11 +61,9 @@ A64EmitX64::A64EmitX64(BlockOfCode& code, A64::UserConfig conf, A64::Jit* jit_in
    code.PreludeComplete();
    ClearFastDispatchTable();

-    if (conf.fastmem_pointer.has_value()) {
-        exception_handler.SetFastmemCallback([this](u64 rip_) {
-            return FastmemCallback(rip_);
-        });
-    }
+    exception_handler.SetFastmemCallback([this](u64 rip_) {
+        return FastmemCallback(rip_);
+    });
 }

 A64EmitX64::~A64EmitX64() = default;
--- a/src/dynarmic/src/dynarmic/backend/x64/block_of_code.cpp
+++ b/src/dynarmic/src/dynarmic/backend/x64/block_of_code.cpp
@@ -87,24 +87,18 @@ public:
        // Waste a page to store the size
        size += DYNARMIC_PAGE_SIZE;

-        int mode = MAP_PRIVATE;
-#if defined(MAP_ANONYMOUS)
-        mode |= MAP_ANONYMOUS;
-#elif defined(MAP_ANON)
-        mode |= MAP_ANON;
-#else
-#   error "not supported"
-#endif
-#ifdef MAP_JIT
+#    if defined(MAP_ANONYMOUS)
+        int mode = MAP_PRIVATE | MAP_ANONYMOUS;
+#    elif defined(MAP_ANON)
+        int mode = MAP_PRIVATE | MAP_ANON;
+#    else
+#        error "not supported"
+#    endif
+#    ifdef MAP_JIT
        mode |= MAP_JIT;
-#endif
-        int prot = PROT_READ | PROT_WRITE;
-#ifdef PROT_MPROTECT
-        // https://man.netbsd.org/mprotect.2 specifies that an mprotect() that is LESS
-        // restrictive than the original mapping MUST fail
-        prot |= PROT_MPROTECT(PROT_READ) | PROT_MPROTECT(PROT_WRITE) | PROT_MPROTECT(PROT_EXEC);
-#endif
-        void* p = mmap(nullptr, size, prot, mode, -1, 0);
+#    endif
+
+        void* p = mmap(nullptr, size, PROT_READ | PROT_WRITE, mode, -1, 0);
        if (p == MAP_FAILED) {
            using Xbyak::Error;
            XBYAK_THROW(Xbyak::ERR_CANT_ALLOC);
--- a/src/dynarmic/src/dynarmic/common/spin_lock_x64.cpp
+++ b/src/dynarmic/src/dynarmic/common/spin_lock_x64.cpp
@@ -7,7 +7,7 @@
 */

 #include <mutex>
-#include <optional>
+
 #include <xbyak/xbyak.h>

 #include "dynarmic/backend/x64/abi.h"
@@ -42,46 +42,43 @@ void EmitSpinLockUnlock(Xbyak::CodeGenerator& code, Xbyak::Reg64 ptr, Xbyak::Reg
 }

 namespace {
+
 struct SpinLockImpl {
-    void Initialize() noexcept;
-    static void GlobalInitialize() noexcept;
+    void Initialize();
+
    Xbyak::CodeGenerator code = Xbyak::CodeGenerator(4096, default_cg_mode);
-    void (*lock)(volatile int*) = nullptr;
-    void (*unlock)(volatile int*) = nullptr;
+
+    void (*lock)(volatile int*);
+    void (*unlock)(volatile int*);
 };

 std::once_flag flag;
-/// @brief Bear in mind that initializing the variable as-is on ctor time will trigger bugs
-/// because some OSes do not prepare mprotect() properly at static ctor time
-/// We can't really do anything about it, so just live with this fact
-std::optional<SpinLockImpl> impl;
+SpinLockImpl impl;
+
+void SpinLockImpl::Initialize() {
+    const Xbyak::Reg64 ABI_PARAM1 = Backend::X64::HostLocToReg64(Backend::X64::ABI_PARAM1);

-void SpinLockImpl::Initialize() noexcept {
-    Xbyak::Reg64 const ABI_PARAM1 = Backend::X64::HostLocToReg64(Backend::X64::ABI_PARAM1);
    code.align();
    lock = code.getCurr<void (*)(volatile int*)>();
    EmitSpinLockLock(code, ABI_PARAM1, code.eax);
    code.ret();
+
    code.align();
    unlock = code.getCurr<void (*)(volatile int*)>();
    EmitSpinLockUnlock(code, ABI_PARAM1, code.eax);
    code.ret();
 }

-void SpinLockImpl::GlobalInitialize() noexcept {
-    impl.emplace();
-    impl->Initialize();
-}
 }  // namespace

 void SpinLock::Lock() noexcept {
-    std::call_once(flag, &SpinLockImpl::GlobalInitialize);
-    impl->lock(&storage);
+    std::call_once(flag, &SpinLockImpl::Initialize, impl);
+    impl.lock(&storage);
 }

 void SpinLock::Unlock() noexcept {
-    std::call_once(flag, &SpinLockImpl::GlobalInitialize);
-    impl->unlock(&storage);
+    std::call_once(flag, &SpinLockImpl::Initialize, impl);
+    impl.unlock(&storage);
 }

 }  // namespace Dynarmic
--- a/src/qt_common/config/uisettings.h
+++ b/src/qt_common/config/uisettings.h
@@ -170,10 +170,14 @@ struct Values {
    // multiplayer settings
    Setting<std::string> multiplayer_nickname{linkage, {}, "nickname", Category::Multiplayer};
    Setting<std::string> multiplayer_filter_text{linkage, {}, "filter_text", Category::Multiplayer};
-    Setting<bool> multiplayer_filter_games_owned{linkage, true, "filter_games_owned", Category::Multiplayer};
-    Setting<bool> multiplayer_filter_public_rooms{linkage, true, "filter_games_public_room", Category::Multiplayer};
+    Setting<bool> multiplayer_filter_games_owned{linkage, false, "filter_games_owned",
+                                                 Category::Multiplayer};
+    Setting<bool> multiplayer_filter_hide_empty{linkage, false, "filter_games_hide_empty",
+                                                Category::Multiplayer};
+    Setting<bool> multiplayer_filter_hide_full{linkage, false, "filter_games_hide_full",
+                                               Category::Multiplayer};
    Setting<std::string> multiplayer_ip{linkage, {}, "ip", Category::Multiplayer};
-    Setting<u16, true> multiplayer_port{linkage, 24872,  0,
+    Setting<u16, true> multiplayer_port{linkage,    24872,  0,
                                        UINT16_MAX, "port", Category::Multiplayer};
    Setting<std::string> multiplayer_room_nickname{
        linkage, {}, "room_nickname", Category::Multiplayer};
--- a/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -195,6 +198,34 @@ Id Texture(EmitContext& ctx, IR::TextureInstInfo info, [[maybe_unused]] const IR
    }
 }

+Id TextureColorResultType(EmitContext& ctx, const TextureDefinition& def) {
+    switch (def.component_type) {
+    case SamplerComponentType::Float:
+    case SamplerComponentType::Depth:
+        return ctx.F32[4];
+    case SamplerComponentType::Sint:
+    case SamplerComponentType::Stencil:
+        return ctx.S32[4];
+    case SamplerComponentType::Uint:
+        return ctx.U32[4];
+    }
+    throw InvalidArgument("Invalid sampler component type {}", def.component_type);
+}
+
+Id TextureSampleResultToFloat(EmitContext& ctx, const TextureDefinition& def, Id color) {
+    switch (def.component_type) {
+    case SamplerComponentType::Float:
+    case SamplerComponentType::Depth:
+        return color;
+    case SamplerComponentType::Sint:
+    case SamplerComponentType::Stencil:
+        return ctx.OpConvertSToF(ctx.F32[4], color);
+    case SamplerComponentType::Uint:
+        return ctx.OpConvertUToF(ctx.F32[4], color);
+    }
+    throw InvalidArgument("Invalid sampler component type {}", def.component_type);
+}
+
 Id TextureImage(EmitContext& ctx, IR::TextureInstInfo info, const IR::Value& index) {
    if (!index.IsImmediate() || index.U32() != 0) {
        throw NotImplementedException("Indirect image indexing");
@@ -449,31 +480,39 @@ Id EmitBoundImageWrite(EmitContext&) {
 Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id bias_lc, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
+    const Id color_type{TextureColorResultType(ctx, def)};
+    const Id texture{Texture(ctx, info, index)};
+    Id color{};
    if (ctx.stage == Stage::Fragment) {
        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                     bias_lc, offset);
-        return Emit(&EmitContext::OpImageSparseSampleImplicitLod,
-                    &EmitContext::OpImageSampleImplicitLod, ctx, inst, ctx.F32[4],
-                    Texture(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
+        color = Emit(&EmitContext::OpImageSparseSampleImplicitLod,
+                     &EmitContext::OpImageSampleImplicitLod, ctx, inst, color_type, texture,
+                     coords, operands.MaskOptional(), operands.Span());
    } else {
        // We can't use implicit lods on non-fragment stages on SPIR-V. Maxwell hardware behaves as
        // if the lod was explicitly zero.  This may change on Turing with implicit compute
        // derivatives
        const Id lod{ctx.Const(0.0f)};
        const ImageOperands operands(ctx, false, true, info.has_lod_clamp != 0, lod, offset);
-        return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                    &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
-                    Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
+        color = Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                     &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type, texture,
+                     coords, operands.Mask(), operands.Span());
    }
+    return TextureSampleResultToFloat(ctx, def, color);
 }

 Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id lod, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
+    const Id color_type{TextureColorResultType(ctx, def)};
    const ImageOperands operands(ctx, false, true, false, lod, offset);
-    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
-                Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
+    const Id color{Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                        &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type,
+                        Texture(ctx, info, index), coords, operands.Mask(), operands.Span())};
+    return TextureSampleResultToFloat(ctx, def, color);
 }

 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
@@ -509,13 +548,18 @@ Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Va
 Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                   const IR::Value& offset, const IR::Value& offset2) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
+    const Id color_type{TextureColorResultType(ctx, def)};
    const ImageOperands operands(ctx, offset, offset2);
+    const Id texture{Texture(ctx, info, index)};
    if (ctx.profile.need_gather_subpixel_offset) {
        coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
    }
-    return Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst,
-                ctx.F32[4], Texture(ctx, info, index), coords, ctx.Const(info.gather_component),
-                operands.MaskOptional(), operands.Span());
+    const Id color{
+        Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst, color_type,
+             texture, coords, ctx.Const(info.gather_component), operands.MaskOptional(),
+             operands.Span())};
+    return TextureSampleResultToFloat(ctx, def, color);
 }

 Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
@@ -533,6 +577,9 @@ Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
 Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id offset,
                  Id lod, Id ms) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const TextureDefinition* def =
+        info.type == TextureType::Buffer ? nullptr : &ctx.textures.at(info.descriptor_index);
+    const Id result_type{def ? TextureColorResultType(ctx, *def) : ctx.F32[4]};
    AddOffsetToCoordinates(ctx, info, coords, offset);
    if (info.type == TextureType::Buffer) {
        lod = Id{};
@@ -542,8 +589,13 @@ Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c
        lod = Id{};
    }
    const ImageOperands operands(lod, ms);
-    return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst, ctx.F32[4],
-                TextureImage(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
+    Id color{Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst,
+                  result_type, TextureImage(ctx, info, index), coords, operands.MaskOptional(),
+                  operands.Span())};
+    if (def) {
+        color = TextureSampleResultToFloat(ctx, *def, color);
+    }
+    return color;
 }

 Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id lod,
@@ -588,14 +640,17 @@ Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, I
 Id EmitImageGradient(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                     Id derivatives, const IR::Value& offset, Id lod_clamp) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
+    const Id color_type{TextureColorResultType(ctx, def)};
    const auto operands = info.num_derivatives == 3
                              ? ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                              ctx.Def(offset), {}, lod_clamp)
                              : ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                              info.num_derivatives, offset, lod_clamp);
-    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
-                Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
+    const Id color{Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                        &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type,
+                        Texture(ctx, info, index), coords, operands.Mask(), operands.Span())};
+    return TextureSampleResultToFloat(ctx, def, color);
 }

 Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {
--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp
+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp
@@ -28,27 +28,40 @@ enum class Operation {
    FPMax,
 };

-Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
+Id ComponentScalarType(EmitContext& ctx, SamplerComponentType component_type) {
+    switch (component_type) {
+    case SamplerComponentType::Float:
+    case SamplerComponentType::Depth:
+        return ctx.F32[1];
+    case SamplerComponentType::Sint:
+    case SamplerComponentType::Stencil:
+        return ctx.S32[1];
+    case SamplerComponentType::Uint:
+        return ctx.U32[1];
+    }
+    throw InvalidArgument("Invalid sampler component type {}", component_type);
+}
+
+Id ImageType(EmitContext& ctx, const TextureDescriptor& desc, Id sampled_type) {
    const spv::ImageFormat format{spv::ImageFormat::Unknown};
-    const Id type{ctx.F32[1]};
    const bool depth{desc.is_depth};
    const bool ms{desc.is_multisample};
    switch (desc.type) {
    case TextureType::Color1D:
-        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, depth, false, false, 1, format);
    case TextureType::ColorArray1D:
-        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, depth, true, false, 1, format);
    case TextureType::Color2D:
    case TextureType::Color2DRect:
-        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, ms, 1, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, depth, false, ms, 1, format);
    case TextureType::ColorArray2D:
-        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, true, ms, 1, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, depth, true, ms, 1, format);
    case TextureType::Color3D:
-        return ctx.TypeImage(type, spv::Dim::Dim3D, depth, false, false, 1, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Dim3D, depth, false, false, 1, format);
    case TextureType::ColorCube:
-        return ctx.TypeImage(type, spv::Dim::Cube, depth, false, false, 1, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Cube, depth, false, false, 1, format);
    case TextureType::ColorArrayCube:
-        return ctx.TypeImage(type, spv::Dim::Cube, depth, true, false, 1, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Cube, depth, true, false, 1, format);
    case TextureType::Buffer:
        break;
    }
@@ -315,6 +328,9 @@ void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
        ctx.Decorate(id, spv::Decoration::Binding, binding);
        ctx.Decorate(id, spv::Decoration::DescriptorSet, 0U);
        ctx.Name(id, fmt::format("ssbo{}", index));
+        if (!desc.is_written) {
+            ctx.Decorate(id, spv::Decoration::NonWritable);
+        }
        if (ctx.profile.supported_spirv >= 0x00010400) {
            ctx.interfaces.push_back(id);
        }
@@ -1359,7 +1375,8 @@ void EmitContext::DefineImageBuffers(const Info& info, u32& binding) {
 void EmitContext::DefineTextures(const Info& info, u32& binding, u32& scaling_index) {
    textures.reserve(info.texture_descriptors.size());
    for (const TextureDescriptor& desc : info.texture_descriptors) {
-        const Id image_type{ImageType(*this, desc)};
+        const Id result_type{ComponentScalarType(*this, desc.component_type)};
+        const Id image_type{ImageType(*this, desc, result_type)};
        const Id sampled_type{TypeSampledImage(image_type)};
        const Id pointer_type{TypePointer(spv::StorageClass::UniformConstant, sampled_type)};
        const Id desc_type{DescType(*this, sampled_type, pointer_type, desc.count)};
@@ -1372,8 +1389,10 @@ void EmitContext::DefineTextures(const Info& info, u32& binding, u32& scaling_in
            .sampled_type = sampled_type,
            .pointer_type = pointer_type,
            .image_type = image_type,
+            .result_type = result_type,
            .count = desc.count,
            .is_multisample = desc.is_multisample,
+            .component_type = desc.component_type,
        });
        if (profile.supported_spirv >= 0x00010400) {
            interfaces.push_back(id);
@@ -1432,6 +1451,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
    }
    if (info.uses_sample_id) {
        sample_id = DefineInput(*this, U32[1], false, spv::BuiltIn::SampleId);
+        if (stage == Stage::Fragment) {
+            Decorate(sample_id, spv::Decoration::Flat);
+        }
    }
    if (info.uses_is_helper_invocation) {
        is_helper_invocation = DefineInput(*this, U1, false, spv::BuiltIn::HelperInvocation);
@@ -1442,14 +1464,21 @@ void EmitContext::DefineInputs(const IR::Program& program) {
        subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
        subgroup_mask_gt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGtMaskKHR);
        subgroup_mask_ge = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGeMaskKHR);
+        if (stage == Stage::Fragment) {
+            Decorate(subgroup_mask_eq, spv::Decoration::Flat);
+            Decorate(subgroup_mask_lt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_le, spv::Decoration::Flat);
+            Decorate(subgroup_mask_gt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_ge, spv::Decoration::Flat);
+        }
    }
    if (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
-        (profile.warp_size_potentially_larger_than_guest &&
+         (profile.warp_size_potentially_larger_than_guest &&
         (info.uses_subgroup_vote || info.uses_subgroup_mask))) {
        AddCapability(spv::Capability::GroupNonUniform);
        subgroup_local_invocation_id =
            DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
-        Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
+            Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
    }
    if (info.uses_fswzadd) {
        const Id f32_one{Const(1.0f)};
@@ -1461,6 +1490,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
    }
    if (loads[IR::Attribute::PrimitiveId]) {
        primitive_id = DefineInput(*this, U32[1], false, spv::BuiltIn::PrimitiveId);
+        if (stage == Stage::Fragment) {
+            Decorate(primitive_id, spv::Decoration::Flat);
+        }
    }
    if (loads[IR::Attribute::Layer]) {
        AddCapability(spv::Capability::Geometry);
@@ -1552,17 +1584,21 @@ void EmitContext::DefineInputs(const IR::Program& program) {
        if (stage != Stage::Fragment) {
            continue;
        }
-        switch (info.interpolation[index]) {
-        case Interpolation::Smooth:
-            // Default
-            // Decorate(id, spv::Decoration::Smooth);
-            break;
-        case Interpolation::NoPerspective:
-            Decorate(id, spv::Decoration::NoPerspective);
-            break;
-        case Interpolation::Flat:
+        const bool is_integer = input_type == AttributeType::SignedInt ||
+                                input_type == AttributeType::UnsignedInt;
+        if (is_integer) {
            Decorate(id, spv::Decoration::Flat);
-            break;
+        } else {
+            switch (info.interpolation[index]) {
+            case Interpolation::Smooth:
+                break;
+            case Interpolation::NoPerspective:
+                Decorate(id, spv::Decoration::NoPerspective);
+                break;
+            case Interpolation::Flat:
+                Decorate(id, spv::Decoration::Flat);
+                break;
+            }
        }
    }
    if (stage == Stage::TessellationEval) {
--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.h
+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.h
@@ -36,8 +36,10 @@ struct TextureDefinition {
    Id sampled_type;
    Id pointer_type;
    Id image_type;
+    Id result_type;
    u32 count;
    bool is_multisample;
+    SamplerComponentType component_type;
 };

 struct TextureBufferDefinition {
--- a/src/shader_recompiler/environment.h
+++ b/src/shader_recompiler/environment.h
@@ -22,6 +22,8 @@ public:

    [[nodiscard]] virtual TextureType ReadTextureType(u32 raw_handle) = 0;

+    [[nodiscard]] virtual SamplerComponentType ReadTextureComponentType(u32 raw_handle) = 0;
+
    [[nodiscard]] virtual TexturePixelFormat ReadTexturePixelFormat(u32 raw_handle) = 0;

    [[nodiscard]] virtual bool IsTexturePixelFormatInteger(u32 raw_handle) = 0;
--- a/src/shader_recompiler/ir_opt/texture_pass.cpp
+++ b/src/shader_recompiler/ir_opt/texture_pass.cpp
@@ -396,6 +396,10 @@ bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf)
    return env.IsTexturePixelFormatInteger(GetTextureHandle(env, cbuf));
 }

+SamplerComponentType ReadTextureComponentType(Environment& env, const ConstBufferAddr& cbuf) {
+    return env.ReadTextureComponentType(GetTextureHandle(env, cbuf));
+}
+
 class Descriptors {
 public:
    explicit Descriptors(TextureBufferDescriptors& texture_buffer_descriptors_,
@@ -433,7 +437,9 @@ public:

    u32 Add(const TextureDescriptor& desc) {
        const u32 index{Add(texture_descriptors, desc, [&desc](const auto& existing) {
-            return desc.type == existing.type && desc.is_depth == existing.is_depth &&
+            return desc.type == existing.type &&
+                   desc.component_type == existing.component_type &&
+                   desc.is_depth == existing.is_depth &&
                   desc.has_secondary == existing.has_secondary &&
                   desc.cbuf_index == existing.cbuf_index &&
                   desc.cbuf_offset == existing.cbuf_offset &&
@@ -670,6 +676,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
            } else {
                index = descriptors.Add(TextureDescriptor{
                    .type = flags.type,
+                    .component_type = ReadTextureComponentType(env, cbuf),
                    .is_depth = flags.is_depth != 0,
                    .is_multisample = is_multisample,
                    .has_secondary = cbuf.has_secondary,
--- a/src/shader_recompiler/shader_info.h
+++ b/src/shader_recompiler/shader_info.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -151,6 +154,14 @@ enum class ImageFormat : u32 {
    R32G32B32A32_UINT,
 };

+enum class SamplerComponentType : u8 {
+    Float,
+    Sint,
+    Uint,
+    Depth,
+    Stencil,
+};
+
 enum class Interpolation {
    Smooth,
    Flat,
@@ -204,6 +215,7 @@ using ImageBufferDescriptors = boost::container::small_vector<ImageBufferDescrip

 struct TextureDescriptor {
    TextureType type;
+    SamplerComponentType component_type;
    bool is_depth;
    bool is_multisample;
    bool has_secondary;
--- a/src/video_core/macro/macro_jit_x64.cpp
+++ b/src/video_core/macro/macro_jit_x64.cpp
@@ -44,20 +44,10 @@ std::bitset<32> PersistentCallerSavedRegs() {
    return PERSISTENT_REGISTERS & Common::X64::ABI_ALL_CALLER_SAVED;
 }

-/// @brief Must enforce W^X constraints, as we yet don't havea  global "NO_EXECUTE" support flag
-/// the speed loss is minimal, and in fact may be negligible, however for your peace of mind
-/// I simply included known OSes whom had W^X issues
-#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
-static const auto default_cg_mode = Xbyak::DontSetProtectRWE;
-#else
-static const auto default_cg_mode = nullptr; //Allow RWE
-#endif
-
 class MacroJITx64Impl final : public Xbyak::CodeGenerator, public CachedMacro {
 public:
    explicit MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_)
-        : Xbyak::CodeGenerator(MAX_CODE_SIZE, default_cg_mode)
-        , code{code_}, maxwell3d{maxwell3d_} {
+        : CodeGenerator{MAX_CODE_SIZE}, code{code_}, maxwell3d{maxwell3d_} {
        Compile();
    }

--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -55,7 +55,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;

-constexpr u32 CACHE_VERSION = 14;
+constexpr u32 CACHE_VERSION = 13;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};

 template <typename Container>
--- a/src/video_core/shader_environment.cpp
+++ b/src/video_core/shader_environment.cpp
@@ -70,6 +70,59 @@ static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture
                                   entry.a_type, entry.srgb_conversion));
 }

+static Shader::SamplerComponentType ConvertSamplerComponentType(
+    const Tegra::Texture::TICEntry& entry) {
+    const auto pixel_format = PixelFormatFromTextureInfo(entry.format, entry.r_type, entry.g_type,
+                                                        entry.b_type, entry.a_type,
+                                                        entry.srgb_conversion);
+    const auto surface_type = VideoCore::Surface::GetFormatType(pixel_format);
+    if (entry.depth_texture != 0 || surface_type == VideoCore::Surface::SurfaceType::Depth) {
+        return Shader::SamplerComponentType::Depth;
+    }
+    if (surface_type == VideoCore::Surface::SurfaceType::Stencil) {
+        return Shader::SamplerComponentType::Stencil;
+    }
+    if (surface_type == VideoCore::Surface::SurfaceType::DepthStencil) {
+        return entry.depth_texture != 0 ? Shader::SamplerComponentType::Depth
+                                        : Shader::SamplerComponentType::Stencil;
+    }
+
+    const auto accumulate = [](const Tegra::Texture::ComponentType component,
+                               bool& has_signed, bool& has_unsigned) {
+        switch (component) {
+        case Tegra::Texture::ComponentType::SINT:
+            has_signed = true;
+            break;
+        case Tegra::Texture::ComponentType::UINT:
+            has_unsigned = true;
+            break;
+        default:
+            break;
+        }
+    };
+
+    bool has_signed{};
+    bool has_unsigned{};
+    accumulate(entry.r_type, has_signed, has_unsigned);
+    accumulate(entry.g_type, has_signed, has_unsigned);
+    accumulate(entry.b_type, has_signed, has_unsigned);
+    accumulate(entry.a_type, has_signed, has_unsigned);
+
+    if (has_signed && !has_unsigned) {
+        return Shader::SamplerComponentType::Sint;
+    }
+    if (has_unsigned && !has_signed) {
+        return Shader::SamplerComponentType::Uint;
+    }
+    if (has_signed) {
+        return Shader::SamplerComponentType::Sint;
+    }
+    if (has_unsigned) {
+        return Shader::SamplerComponentType::Uint;
+    }
+    return Shader::SamplerComponentType::Float;
+}
+
 static std::string_view StageToPrefix(Shader::Stage stage) {
    switch (stage) {
    case Shader::Stage::VertexB:
@@ -200,6 +253,7 @@ void GenericEnvironment::Serialize(std::ofstream& file) const {
    const u64 code_size{static_cast<u64>(CachedSizeBytes())};
    const u64 num_texture_types{static_cast<u64>(texture_types.size())};
    const u64 num_texture_pixel_formats{static_cast<u64>(texture_pixel_formats.size())};
+    const u64 num_texture_component_types{static_cast<u64>(texture_component_types.size())};
    const u64 num_cbuf_values{static_cast<u64>(cbuf_values.size())};
    const u64 num_cbuf_replacement_values{static_cast<u64>(cbuf_replacements.size())};

@@ -207,6 +261,8 @@ void GenericEnvironment::Serialize(std::ofstream& file) const {
        .write(reinterpret_cast<const char*>(&num_texture_types), sizeof(num_texture_types))
        .write(reinterpret_cast<const char*>(&num_texture_pixel_formats),
               sizeof(num_texture_pixel_formats))
+        .write(reinterpret_cast<const char*>(&num_texture_component_types),
+               sizeof(num_texture_component_types))
        .write(reinterpret_cast<const char*>(&num_cbuf_values), sizeof(num_cbuf_values))
        .write(reinterpret_cast<const char*>(&num_cbuf_replacement_values),
               sizeof(num_cbuf_replacement_values))
@@ -223,6 +279,10 @@ void GenericEnvironment::Serialize(std::ofstream& file) const {
        file.write(reinterpret_cast<const char*>(&key), sizeof(key))
            .write(reinterpret_cast<const char*>(&type), sizeof(type));
    }
+    for (const auto& [key, component] : texture_component_types) {
+        file.write(reinterpret_cast<const char*>(&key), sizeof(key))
+            .write(reinterpret_cast<const char*>(&component), sizeof(component));
+    }
    for (const auto& [key, format] : texture_pixel_formats) {
        file.write(reinterpret_cast<const char*>(&key), sizeof(key))
            .write(reinterpret_cast<const char*>(&format), sizeof(format));
@@ -374,6 +434,21 @@ Shader::TextureType GraphicsEnvironment::ReadTextureType(u32 handle) {
        ReadTextureInfo(regs.tex_header.Address(), regs.tex_header.limit, via_header_index, handle);
    const Shader::TextureType result{ConvertTextureType(entry)};
    texture_types.emplace(handle, result);
+    texture_component_types.emplace(handle, ConvertSamplerComponentType(entry));
+    return result;
+}
+
+Shader::SamplerComponentType GraphicsEnvironment::ReadTextureComponentType(u32 handle) {
+    const auto it{texture_component_types.find(handle)};
+    if (it != texture_component_types.end()) {
+        return it->second;
+    }
+    const auto& regs{maxwell3d->regs};
+    const bool via_header_index{regs.sampler_binding == Maxwell::SamplerBinding::ViaHeaderBinding};
+    auto entry =
+        ReadTextureInfo(regs.tex_header.Address(), regs.tex_header.limit, via_header_index, handle);
+    const Shader::SamplerComponentType result{ConvertSamplerComponentType(entry)};
+    texture_component_types.emplace(handle, result);
    return result;
 }

@@ -430,6 +505,20 @@ Shader::TextureType ComputeEnvironment::ReadTextureType(u32 handle) {
    auto entry = ReadTextureInfo(regs.tic.Address(), regs.tic.limit, qmd.linked_tsc != 0, handle);
    const Shader::TextureType result{ConvertTextureType(entry)};
    texture_types.emplace(handle, result);
+    texture_component_types.emplace(handle, ConvertSamplerComponentType(entry));
+    return result;
+}
+
+Shader::SamplerComponentType ComputeEnvironment::ReadTextureComponentType(u32 handle) {
+    const auto it{texture_component_types.find(handle)};
+    if (it != texture_component_types.end()) {
+        return it->second;
+    }
+    const auto& regs{kepler_compute->regs};
+    const auto& qmd{kepler_compute->launch_description};
+    auto entry = ReadTextureInfo(regs.tic.Address(), regs.tic.limit, qmd.linked_tsc != 0, handle);
+    const Shader::SamplerComponentType result{ConvertSamplerComponentType(entry)};
+    texture_component_types.emplace(handle, result);
    return result;
 }

@@ -455,12 +544,15 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
    u64 code_size{};
    u64 num_texture_types{};
    u64 num_texture_pixel_formats{};
+    u64 num_texture_component_types{};
    u64 num_cbuf_values{};
    u64 num_cbuf_replacement_values{};
    file.read(reinterpret_cast<char*>(&code_size), sizeof(code_size))
        .read(reinterpret_cast<char*>(&num_texture_types), sizeof(num_texture_types))
-        .read(reinterpret_cast<char*>(&num_texture_pixel_formats),
+          .read(reinterpret_cast<char*>(&num_texture_pixel_formats),
              sizeof(num_texture_pixel_formats))
+          .read(reinterpret_cast<char*>(&num_texture_component_types),
+              sizeof(num_texture_component_types))
        .read(reinterpret_cast<char*>(&num_cbuf_values), sizeof(num_cbuf_values))
        .read(reinterpret_cast<char*>(&num_cbuf_replacement_values),
              sizeof(num_cbuf_replacement_values))
@@ -480,6 +572,13 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
            .read(reinterpret_cast<char*>(&type), sizeof(type));
        texture_types.emplace(key, type);
    }
+    for (size_t i = 0; i < num_texture_component_types; ++i) {
+        u32 key;
+        Shader::SamplerComponentType component;
+        file.read(reinterpret_cast<char*>(&key), sizeof(key))
+            .read(reinterpret_cast<char*>(&component), sizeof(component));
+        texture_component_types.emplace(key, component);
+    }
    for (size_t i = 0; i < num_texture_pixel_formats; ++i) {
        u32 key;
        Shader::TexturePixelFormat format;
@@ -534,6 +633,15 @@ u32 FileEnvironment::ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) {
    return it->second;
 }

+Shader::SamplerComponentType FileEnvironment::ReadTextureComponentType(u32 handle) {
+    const auto it{texture_component_types.find(handle)};
+    if (it == texture_component_types.end()) {
+        LOG_WARNING(Render_Vulkan, "Texture component descriptor {:08x} not found", handle);
+        return Shader::SamplerComponentType::Float;
+    }
+    return it->second;
+}
+
 Shader::TextureType FileEnvironment::ReadTextureType(u32 handle) {
    const auto it{texture_types.find(handle)};
    if (it == texture_types.end()) {
--- a/src/video_core/shader_environment.h
+++ b/src/video_core/shader_environment.h
@@ -80,6 +80,7 @@ protected:

    std::vector<u64> code;
    std::unordered_map<u32, Shader::TextureType> texture_types;
+    std::unordered_map<u32, Shader::SamplerComponentType> texture_component_types;
    std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
    std::unordered_map<u64, u32> cbuf_values;
    std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;
@@ -116,6 +117,8 @@ public:

    Shader::TextureType ReadTextureType(u32 handle) override;

+    Shader::SamplerComponentType ReadTextureComponentType(u32 handle) override;
+
    Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;

    bool IsTexturePixelFormatInteger(u32 handle) override;
@@ -142,6 +145,8 @@ public:

    Shader::TextureType ReadTextureType(u32 handle) override;

+    Shader::SamplerComponentType ReadTextureComponentType(u32 handle) override;
+
    Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;

    bool IsTexturePixelFormatInteger(u32 handle) override;
@@ -176,6 +181,8 @@ public:

    [[nodiscard]] Shader::TextureType ReadTextureType(u32 handle) override;

+    [[nodiscard]] Shader::SamplerComponentType ReadTextureComponentType(u32 handle) override;
+
    [[nodiscard]] Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;

    [[nodiscard]] bool IsTexturePixelFormatInteger(u32 handle) override;
@@ -202,6 +209,7 @@ public:
 private:
    std::vector<u64> code;
    std::unordered_map<u32, Shader::TextureType> texture_types;
+    std::unordered_map<u32, Shader::SamplerComponentType> texture_component_types;
    std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
    std::unordered_map<u64, u32> cbuf_values;
    std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;
--- a/src/yuzu/configuration/configure_per_game.cpp
+++ b/src/yuzu/configuration/configure_per_game.cpp
@@ -41,7 +41,6 @@
 #include "yuzu/configuration/configure_per_game.h"
 #include "yuzu/configuration/configure_per_game_addons.h"
 #include "yuzu/configuration/configure_system.h"
-#include "yuzu/configuration/configure_network.h"
 #include "qt_common/config/uisettings.h"
 #include "yuzu/util/util.h"
 #include "yuzu/vk_device_info.h"
@@ -70,7 +69,6 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
    input_tab = std::make_unique<ConfigureInputPerGame>(system_, game_config.get(), this);
    linux_tab = std::make_unique<ConfigureLinuxTab>(system_, tab_group, *builder, this);
    system_tab = std::make_unique<ConfigureSystem>(system_, tab_group, *builder, this);
-    network_tab = std::make_unique<ConfigureNetwork>(system_, this);

    ui->setupUi(this);

@@ -82,7 +80,6 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
    ui->tabWidget->addTab(graphics_extensions_tab.get(), tr("GPU Extensions"));
    ui->tabWidget->addTab(audio_tab.get(), tr("Audio"));
    ui->tabWidget->addTab(input_tab.get(), tr("Input Profiles"));
-    ui->tabWidget->addTab(network_tab.get(), tr("Network"));

    // Only show Linux tab on Unix
    linux_tab->setVisible(false);
@@ -116,7 +113,6 @@ void ConfigurePerGame::ApplyConfiguration() {
    }
    addons_tab->ApplyConfiguration();
    input_tab->ApplyConfiguration();
-    network_tab->ApplyConfiguration();

    if (Settings::IsDockedMode() && Settings::values.players.GetValue()[0].controller_type ==
                                        Settings::ControllerType::Handheld) {
--- a/src/yuzu/configuration/configure_per_game.h
+++ b/src/yuzu/configuration/configure_per_game.h
@@ -38,7 +38,6 @@ class ConfigureGraphicsExtensions;
 class ConfigureInputPerGame;
 class ConfigureLinuxTab;
 class ConfigureSystem;
-class ConfigureNetwork;

 class QGraphicsScene;
 class QStandardItem;
@@ -94,5 +93,4 @@ private:
    std::unique_ptr<ConfigureInputPerGame> input_tab;
    std::unique_ptr<ConfigureLinuxTab> linux_tab;
    std::unique_ptr<ConfigureSystem> system_tab;
-    std::unique_ptr<ConfigureNetwork> network_tab;
 };
--- a/src/yuzu/multiplayer/lobby.cpp
+++ b/src/yuzu/multiplayer/lobby.cpp
@@ -62,12 +62,14 @@ Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
    ui->room_list->setContextMenuPolicy(Qt::CustomContextMenu);

    ui->nickname->setValidator(validation.GetNickname());
-    ui->nickname->setText(QString::fromStdString(UISettings::values.multiplayer_nickname.GetValue()));
+    ui->nickname->setText(
+        QString::fromStdString(UISettings::values.multiplayer_nickname.GetValue()));

    // Try find the best nickname by default
    if (ui->nickname->text().isEmpty() || ui->nickname->text() == QStringLiteral("Eden")) {
-        if (auto const username = Settings::values.eden_username.GetValue(); !username.empty()) {
-            ui->nickname->setText(QString::fromStdString(username));
+        if (!Settings::values.eden_username.GetValue().empty()) {
+            ui->nickname->setText(
+                QString::fromStdString(Settings::values.eden_username.GetValue()));
        } else if (!GetProfileUsername().empty()) {
            ui->nickname->setText(QString::fromStdString(GetProfileUsername()));
        } else {
@@ -79,17 +81,21 @@ Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
    connect(ui->refresh_list, &QPushButton::clicked, this, &Lobby::RefreshLobby);
    connect(ui->search, &QLineEdit::textChanged, proxy, &LobbyFilterProxyModel::SetFilterSearch);
    connect(ui->games_owned, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterOwned);
-    connect(ui->public_rooms, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterPublic);
+    connect(ui->hide_empty, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterEmpty);
+    connect(ui->hide_full, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterFull);
    connect(ui->room_list, &QTreeView::doubleClicked, this, &Lobby::OnJoinRoom);
    connect(ui->room_list, &QTreeView::clicked, this, &Lobby::OnExpandRoom);

    // Actions
-    connect(&room_list_watcher, &QFutureWatcher<AnnounceMultiplayerRoom::RoomList>::finished, this, &Lobby::OnRefreshLobby);
+    connect(&room_list_watcher, &QFutureWatcher<AnnounceMultiplayerRoom::RoomList>::finished, this,
+            &Lobby::OnRefreshLobby);

    // Load persistent filters after events are connected to make sure they apply
-    ui->search->setText(QString::fromStdString(UISettings::values.multiplayer_filter_text.GetValue()));
+    ui->search->setText(
+        QString::fromStdString(UISettings::values.multiplayer_filter_text.GetValue()));
    ui->games_owned->setChecked(UISettings::values.multiplayer_filter_games_owned.GetValue());
-    ui->public_rooms->setChecked(UISettings::values.multiplayer_filter_public_rooms.GetValue());
+    ui->hide_empty->setChecked(UISettings::values.multiplayer_filter_hide_empty.GetValue());
+    ui->hide_full->setChecked(UISettings::values.multiplayer_filter_hide_full.GetValue());
 }

 Lobby::~Lobby() = default;
@@ -209,9 +215,12 @@ void Lobby::OnJoinRoom(const QModelIndex& source) {
    UISettings::values.multiplayer_nickname = ui->nickname->text().toStdString();
    UISettings::values.multiplayer_filter_text = ui->search->text().toStdString();
    UISettings::values.multiplayer_filter_games_owned = ui->games_owned->isChecked();
-    UISettings::values.multiplayer_filter_public_rooms = ui->public_rooms->isChecked();
-    UISettings::values.multiplayer_ip = proxy->data(connection_index, LobbyItemHost::HostIPRole).value<QString>().toStdString();
-    UISettings::values.multiplayer_port = proxy->data(connection_index, LobbyItemHost::HostPortRole).toInt();
+    UISettings::values.multiplayer_filter_hide_empty = ui->hide_empty->isChecked();
+    UISettings::values.multiplayer_filter_hide_full = ui->hide_full->isChecked();
+    UISettings::values.multiplayer_ip =
+        proxy->data(connection_index, LobbyItemHost::HostIPRole).value<QString>().toStdString();
+    UISettings::values.multiplayer_port =
+        proxy->data(connection_index, LobbyItemHost::HostPortRole).toInt();
    emit SaveConfig();
 }

@@ -219,8 +228,8 @@ void Lobby::ResetModel() {
    model->clear();
    model->insertColumns(0, Column::TOTAL);
    model->setHeaderData(Column::MEMBER, Qt::Horizontal, tr("Players"), Qt::DisplayRole);
-    model->setHeaderData(Column::ROOM_NAME, Qt::Horizontal, tr("Name"), Qt::DisplayRole);
-    model->setHeaderData(Column::GAME_NAME, Qt::Horizontal, tr("Game"), Qt::DisplayRole);
+    model->setHeaderData(Column::ROOM_NAME, Qt::Horizontal, tr("Room Name"), Qt::DisplayRole);
+    model->setHeaderData(Column::GAME_NAME, Qt::Horizontal, tr("Preferred Game"), Qt::DisplayRole);
    model->setHeaderData(Column::HOST, Qt::Horizontal, tr("Host"), Qt::DisplayRole);
 }

@@ -336,12 +345,26 @@ bool LobbyFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& s
        return true;
    }

-    // filter by non-password protected
-    if (filter_public) {
-        QModelIndex password_index = sourceModel()->index(sourceRow, Column::ROOM_NAME);
-        bool has_password = sourceModel()->data(password_index, LobbyItemName::PasswordRole).toBool();
-        if (has_password)
+    // filter by empty rooms
+    if (filter_empty) {
+        QModelIndex member_list = sourceModel()->index(sourceRow, Column::MEMBER, sourceParent);
+        int player_count =
+            sourceModel()->data(member_list, LobbyItemMemberList::MemberListRole).toList().size();
+        if (player_count == 0) {
            return false;
+        }
+    }
+
+    // filter by filled rooms
+    if (filter_full) {
+        QModelIndex member_list = sourceModel()->index(sourceRow, Column::MEMBER, sourceParent);
+        int player_count =
+            sourceModel()->data(member_list, LobbyItemMemberList::MemberListRole).toList().size();
+        int max_players =
+            sourceModel()->data(member_list, LobbyItemMemberList::MaxPlayerRole).toInt();
+        if (player_count >= max_players) {
+            return false;
+        }
    }

    // filter by search parameters
@@ -349,9 +372,18 @@ bool LobbyFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& s
        QModelIndex game_name = sourceModel()->index(sourceRow, Column::GAME_NAME, sourceParent);
        QModelIndex room_name = sourceModel()->index(sourceRow, Column::ROOM_NAME, sourceParent);
        QModelIndex host_name = sourceModel()->index(sourceRow, Column::HOST, sourceParent);
-        bool preferred_game_match = sourceModel()->data(game_name, LobbyItemGame::GameNameRole).toString().contains(filter_search, filterCaseSensitivity());
-        bool room_name_match = sourceModel()->data(room_name, LobbyItemName::NameRole).toString().contains(filter_search, filterCaseSensitivity());
-        bool username_match = sourceModel()->data(host_name, LobbyItemHost::HostUsernameRole).toString().contains(filter_search, filterCaseSensitivity());
+        bool preferred_game_match = sourceModel()
+                                        ->data(game_name, LobbyItemGame::GameNameRole)
+                                        .toString()
+                                        .contains(filter_search, filterCaseSensitivity());
+        bool room_name_match = sourceModel()
+                                   ->data(room_name, LobbyItemName::NameRole)
+                                   .toString()
+                                   .contains(filter_search, filterCaseSensitivity());
+        bool username_match = sourceModel()
+                                  ->data(host_name, LobbyItemHost::HostUsernameRole)
+                                  .toString()
+                                  .contains(filter_search, filterCaseSensitivity());
        if (!preferred_game_match && !room_name_match && !username_match) {
            return false;
        }
@@ -393,8 +425,13 @@ void LobbyFilterProxyModel::SetFilterOwned(bool filter) {
    invalidate();
 }

-void LobbyFilterProxyModel::SetFilterPublic(bool filter) {
-    filter_public = filter;
+void LobbyFilterProxyModel::SetFilterEmpty(bool filter) {
+    filter_empty = filter;
+    invalidate();
+}
+
+void LobbyFilterProxyModel::SetFilterFull(bool filter) {
+    filter_full = filter;
    invalidate();
 }

--- a/src/yuzu/multiplayer/lobby.h
+++ b/src/yuzu/multiplayer/lobby.h
@@ -126,13 +126,14 @@ public:

 public slots:
    void SetFilterOwned(bool);
-    void SetFilterPublic(bool);
+    void SetFilterEmpty(bool);
+    void SetFilterFull(bool);
    void SetFilterSearch(const QString&);

 private:
    QStandardItemModel* game_list;
    bool filter_owned = false;
    bool filter_empty = false;
-    bool filter_public = false;
+    bool filter_full = false;
    QString filter_search;
 };
--- a/src/yuzu/multiplayer/lobby.ui
+++ b/src/yuzu/multiplayer/lobby.ui
@@ -78,9 +78,16 @@
          </widget>
         </item>
         <item>
-          <widget class="QCheckBox" name="public_rooms">
+          <widget class="QCheckBox" name="hide_empty">
           <property name="text">
-            <string>Public Rooms</string>
+            <string>Hide Empty Rooms</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QCheckBox" name="hide_full">
+           <property name="text">
+            <string>Hide Full Rooms</string>
           </property>
          </widget>
         </item>