yuzu: main: Increase the open file limit on Windows to 8192

This is a temporary solution for now to accommodate for mods containing more than 4096 files.

CMakeLists.txt

@@ -35,8 +35,6 @@ option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
 option(YUZU_USE_BUNDLED_OPUS "Compile bundled opus" ON)
 
-option(YUZU_TESTS "Compile tests" ON)
-
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
@@ -170,6 +168,7 @@ macro(yuzu_find_packages)
     # Capitalization matters here. We need the naming to match the generated paths from Conan
     set(REQUIRED_LIBS
     #    Cmake Pkg Prefix  Version     Conan Pkg
+        "Catch2            2.13.7      catch2/2.13.7"
         "fmt               8.0.1       fmt/8.1.1"
         "lz4               1.8         lz4/1.9.2"
         "nlohmann_json     3.8         nlohmann_json/3.8.0"
@@ -178,11 +177,6 @@ macro(yuzu_find_packages)
     # can't use opus until AVX check is fixed: https://github.com/yuzu-emu/yuzu/pull/4068
         #"opus              1.3         opus/1.3.1"
     )
-    if (YUZU_TESTS)
-        list(APPEND REQUIRED_LIBS
-        "Catch2            2.13.7      catch2/2.13.7"
-        )
-    endif()
 
     foreach(PACKAGE ${REQUIRED_LIBS})
         string(REGEX REPLACE "[ \t\r\n]+" ";" PACKAGE_SPLIT ${PACKAGE})

externals/CMakeLists.txt

@@ -13,6 +13,10 @@ if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
     target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
 endif()
 
+# Catch
+add_library(catch-single-include INTERFACE)
+target_include_directories(catch-single-include INTERFACE catch/single_include)
+
 # Dynarmic
 if (ARCHITECTURE_x86_64)
     set(DYNARMIC_TESTS OFF)

src/CMakeLists.txt

@@ -151,10 +151,7 @@ add_subdirectory(audio_core)
 add_subdirectory(video_core)
 add_subdirectory(input_common)
 add_subdirectory(shader_recompiler)
-
-if (YUZU_TESTS)
-    add_subdirectory(tests)
-endif()
+add_subdirectory(tests)
 
 if (ENABLE_SDL2)
     add_subdirectory(yuzu_cmd)

src/core/hid/emulated_controller.cpp

@@ -351,19 +351,6 @@ void EmulatedController::DisableConfiguration() {
     }
 }
 
-void EmulatedController::EnableSystemButtons() {
-    system_buttons_enabled = true;
-}
-
-void EmulatedController::DisableSystemButtons() {
-    system_buttons_enabled = false;
-}
-
-void EmulatedController::ResetSystemButtons() {
-    controller.home_button_state.home.Assign(false);
-    controller.capture_button_state.capture.Assign(false);
-}
-
 bool EmulatedController::IsConfiguring() const {
     return is_configuring;
 }
@@ -613,16 +600,7 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback
             controller.npad_button_state.right_sr.Assign(current_status.value);
             break;
         case Settings::NativeButton::Home:
-            if (!system_buttons_enabled) {
-                break;
-            }
-            controller.home_button_state.home.Assign(current_status.value);
-            break;
         case Settings::NativeButton::Screenshot:
-            if (!system_buttons_enabled) {
-                break;
-            }
-            controller.capture_button_state.capture.Assign(current_status.value);
             break;
         }
     }
@@ -1103,20 +1081,6 @@ BatteryValues EmulatedController::GetBatteryValues() const {
     return controller.battery_values;
 }
 
-HomeButtonState EmulatedController::GetHomeButtons() const {
-    if (is_configuring) {
-        return {};
-    }
-    return controller.home_button_state;
-}
-
-CaptureButtonState EmulatedController::GetCaptureButtons() const {
-    if (is_configuring) {
-        return {};
-    }
-    return controller.capture_button_state;
-}
-
 NpadButtonState EmulatedController::GetNpadButtons() const {
     if (is_configuring) {
         return {};

src/core/hid/emulated_controller.h

@@ -101,8 +101,6 @@ struct ControllerStatus {
     VibrationValues vibration_values{};
 
     // Data for HID serices
-    HomeButtonState home_button_state{};
-    CaptureButtonState capture_button_state{};
     NpadButtonState npad_button_state{};
     DebugPadButton debug_pad_button_state{};
     AnalogSticks analog_stick_state{};
@@ -200,15 +198,6 @@ public:
     /// Returns the emulated controller into normal mode, allowing the modification of the HID state
     void DisableConfiguration();
 
-    /// Enables Home and Screenshot buttons
-    void EnableSystemButtons();
-
-    /// Disables Home and Screenshot buttons
-    void DisableSystemButtons();
-
-    /// Sets Home and Screenshot buttons to false
-    void ResetSystemButtons();
-
     /// Returns true if the emulated controller is in configuring mode
     bool IsConfiguring() const;
 
@@ -272,13 +261,7 @@ public:
     /// Returns the latest battery status from the controller with parameters
     BatteryValues GetBatteryValues() const;
 
-    /// Returns the latest status of button input for the hid::HomeButton service
-    HomeButtonState GetHomeButtons() const;
-
-    /// Returns the latest status of button input for the hid::CaptureButton service
-    CaptureButtonState GetCaptureButtons() const;
-
-    /// Returns the latest status of button input for the hid::Npad service
+    /// Returns the latest status of button input for the npad service
     NpadButtonState GetNpadButtons() const;
 
     /// Returns the latest status of button input for the debug pad service
@@ -400,7 +383,6 @@ private:
     NpadStyleTag supported_style_tag{NpadStyleSet::All};
     bool is_connected{false};
     bool is_configuring{false};
-    bool system_buttons_enabled{true};
     f32 motion_sensitivity{0.01f};
     bool force_update_motion{false};
 

src/core/hid/hid_types.h

@@ -378,26 +378,6 @@ struct LedPattern {
     };
 };
 
-struct HomeButtonState {
-    union {
-        u64 raw{};
-
-        // Buttons
-        BitField<0, 1, u64> home;
-    };
-};
-static_assert(sizeof(HomeButtonState) == 0x8, "HomeButtonState has incorrect size.");
-
-struct CaptureButtonState {
-    union {
-        u64 raw{};
-
-        // Buttons
-        BitField<0, 1, u64> capture;
-    };
-};
-static_assert(sizeof(CaptureButtonState) == 0x8, "CaptureButtonState has incorrect size.");
-
 struct NpadButtonState {
     union {
         NpadButton raw{};

src/core/hle/kernel/k_memory_block.h

@@ -70,12 +70,12 @@ enum class KMemoryState : u32 {
     ThreadLocal =
         static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagMapped | FlagReferenceCounted,
 
-    Transfered = static_cast<u32>(Svc::MemoryState::Transferred) | FlagsMisc |
-                 FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
-                 FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
+    Transferred = static_cast<u32>(Svc::MemoryState::Transferred) | FlagsMisc |
+                  FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
+                  FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
 
-    SharedTransfered = static_cast<u32>(Svc::MemoryState::SharedTransferred) | FlagsMisc |
-                       FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
+    SharedTransferred = static_cast<u32>(Svc::MemoryState::SharedTransferred) | FlagsMisc |
+                        FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
 
     SharedCode = static_cast<u32>(Svc::MemoryState::SharedCode) | FlagMapped |
                  FlagReferenceCounted | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
@@ -93,8 +93,6 @@ enum class KMemoryState : u32 {
     GeneratedCode = static_cast<u32>(Svc::MemoryState::GeneratedCode) | FlagMapped |
                     FlagReferenceCounted | FlagCanDebug,
     CodeOut = static_cast<u32>(Svc::MemoryState::CodeOut) | FlagMapped | FlagReferenceCounted,
-
-    Coverage = static_cast<u32>(Svc::MemoryState::Coverage) | FlagMapped,
 };
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryState);
 
@@ -110,8 +108,8 @@ static_assert(static_cast<u32>(KMemoryState::AliasCodeData) == 0x03FFBD09);
 static_assert(static_cast<u32>(KMemoryState::Ipc) == 0x005C3C0A);
 static_assert(static_cast<u32>(KMemoryState::Stack) == 0x005C3C0B);
 static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0040200C);
-static_assert(static_cast<u32>(KMemoryState::Transfered) == 0x015C3C0D);
-static_assert(static_cast<u32>(KMemoryState::SharedTransfered) == 0x005C380E);
+static_assert(static_cast<u32>(KMemoryState::Transferred) == 0x015C3C0D);
+static_assert(static_cast<u32>(KMemoryState::SharedTransferred) == 0x005C380E);
 static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0040380F);
 static_assert(static_cast<u32>(KMemoryState::Inaccessible) == 0x00000010);
 static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x005C3811);
@@ -119,7 +117,6 @@ static_assert(static_cast<u32>(KMemoryState::NonDeviceIpc) == 0x004C2812);
 static_assert(static_cast<u32>(KMemoryState::Kernel) == 0x00002013);
 static_assert(static_cast<u32>(KMemoryState::GeneratedCode) == 0x00402214);
 static_assert(static_cast<u32>(KMemoryState::CodeOut) == 0x00402015);
-static_assert(static_cast<u32>(KMemoryState::Coverage) == 0x00002016);
 
 enum class KMemoryPermission : u8 {
     None = 0,
@@ -158,13 +155,7 @@ enum class KMemoryPermission : u8 {
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryPermission);
 
 constexpr KMemoryPermission ConvertToKMemoryPermission(Svc::MemoryPermission perm) {
-    return static_cast<KMemoryPermission>(
-        (static_cast<KMemoryPermission>(perm) & KMemoryPermission::UserMask) |
-        KMemoryPermission::KernelRead |
-        ((static_cast<KMemoryPermission>(perm) & KMemoryPermission::UserWrite)
-         << KMemoryPermission::KernelShift) |
-        (perm == Svc::MemoryPermission::None ? KMemoryPermission::NotMapped
-                                             : KMemoryPermission::None));
+    return static_cast<KMemoryPermission>(perm);
 }
 
 enum class KMemoryAttribute : u8 {
@@ -178,8 +169,6 @@ enum class KMemoryAttribute : u8 {
     DeviceShared = static_cast<u8>(Svc::MemoryAttribute::DeviceShared),
     Uncached = static_cast<u8>(Svc::MemoryAttribute::Uncached),
 
-    SetMask = Uncached,
-
     IpcAndDeviceMapped = IpcLocked | DeviceShared,
     LockedAndIpcLocked = Locked | IpcLocked,
     DeviceSharedAndUncached = DeviceShared | Uncached
@@ -226,15 +215,6 @@ struct KMemoryInfo {
     constexpr VAddr GetLastAddress() const {
         return GetEndAddress() - 1;
     }
-    constexpr KMemoryState GetState() const {
-        return state;
-    }
-    constexpr KMemoryAttribute GetAttribute() const {
-        return attribute;
-    }
-    constexpr KMemoryPermission GetPermission() const {
-        return perm;
-    }
 };
 
 class KMemoryBlock final {

src/core/hle/kernel/k_page_table.cpp

@@ -305,8 +305,8 @@ ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std:
 
     KMemoryState state{};
     KMemoryPermission perm{};
-    CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, nullptr, src_addr, size,
-                                  KMemoryState::All, KMemoryState::Normal, KMemoryPermission::All,
+    CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, src_addr, size, KMemoryState::All,
+                                  KMemoryState::Normal, KMemoryPermission::All,
                                   KMemoryPermission::ReadAndWrite, KMemoryAttribute::Mask,
                                   KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
@@ -344,14 +344,14 @@ ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, st
 
     const std::size_t num_pages{size / PageSize};
 
-    CASCADE_CODE(CheckMemoryState(nullptr, nullptr, nullptr, nullptr, src_addr, size,
-                                  KMemoryState::All, KMemoryState::Normal, KMemoryPermission::None,
+    CASCADE_CODE(CheckMemoryState(nullptr, nullptr, nullptr, src_addr, size, KMemoryState::All,
+                                  KMemoryState::Normal, KMemoryPermission::None,
                                   KMemoryPermission::None, KMemoryAttribute::Mask,
                                   KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped));
 
     KMemoryState state{};
     CASCADE_CODE(CheckMemoryState(
-        &state, nullptr, nullptr, nullptr, dst_addr, PageSize, KMemoryState::FlagCanCodeAlias,
+        &state, nullptr, nullptr, dst_addr, PageSize, KMemoryState::FlagCanCodeAlias,
         KMemoryState::FlagCanCodeAlias, KMemoryPermission::None, KMemoryPermission::None,
         KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
     CASCADE_CODE(CheckMemoryState(dst_addr, size, KMemoryState::All, state, KMemoryPermission::None,
@@ -553,7 +553,7 @@ ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
 
     KMemoryState src_state{};
     CASCADE_CODE(CheckMemoryState(
-        &src_state, nullptr, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias,
+        &src_state, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias,
         KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::ReadAndWrite,
         KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
@@ -592,13 +592,13 @@ ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
 
     KMemoryState src_state{};
     CASCADE_CODE(CheckMemoryState(
-        &src_state, nullptr, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias,
+        &src_state, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias,
         KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::None,
         KMemoryAttribute::Mask, KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped));
 
     KMemoryPermission dst_perm{};
-    CASCADE_CODE(CheckMemoryState(nullptr, &dst_perm, nullptr, nullptr, dst_addr, size,
-                                  KMemoryState::All, KMemoryState::Stack, KMemoryPermission::None,
+    CASCADE_CODE(CheckMemoryState(nullptr, &dst_perm, nullptr, dst_addr, size, KMemoryState::All,
+                                  KMemoryState::Stack, KMemoryPermission::None,
                                   KMemoryPermission::None, KMemoryAttribute::Mask,
                                   KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
@@ -721,7 +721,7 @@ ResultCode KPageTable::SetProcessMemoryPermission(VAddr addr, std::size_t size,
     KMemoryPermission prev_perm{};
 
     CASCADE_CODE(CheckMemoryState(
-        &prev_state, &prev_perm, nullptr, nullptr, addr, size, KMemoryState::FlagCode,
+        &prev_state, &prev_perm, nullptr, addr, size, KMemoryState::FlagCode,
         KMemoryState::FlagCode, KMemoryPermission::None, KMemoryPermission::None,
         KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
@@ -782,7 +782,7 @@ ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemo
     KMemoryAttribute attribute{};
 
     CASCADE_CODE(CheckMemoryState(
-        &state, nullptr, &attribute, nullptr, addr, size,
+        &state, nullptr, &attribute, addr, size,
         KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
         KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, KMemoryPermission::All,
         KMemoryPermission::ReadAndWrite, KMemoryAttribute::Mask, KMemoryAttribute::None,
@@ -799,7 +799,7 @@ ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
     KMemoryState state{};
 
     CASCADE_CODE(
-        CheckMemoryState(&state, nullptr, nullptr, nullptr, addr, size,
+        CheckMemoryState(&state, nullptr, nullptr, addr, size,
                          KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
                          KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
                          KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::Mask,
@@ -820,7 +820,7 @@ ResultCode KPageTable::SetMemoryPermission(VAddr addr, std::size_t size,
     KMemoryState old_state;
     KMemoryPermission old_perm;
     R_TRY(this->CheckMemoryState(
-        std::addressof(old_state), std::addressof(old_perm), nullptr, nullptr, addr, size,
+        std::addressof(old_state), std::addressof(old_perm), nullptr, addr, size,
         KMemoryState::FlagCanReprotect, KMemoryState::FlagCanReprotect, KMemoryPermission::None,
         KMemoryPermission::None, KMemoryAttribute::All, KMemoryAttribute::None));
 
@@ -837,36 +837,24 @@ ResultCode KPageTable::SetMemoryPermission(VAddr addr, std::size_t size,
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr) {
-    const size_t num_pages = size / PageSize;
-    ASSERT((static_cast<KMemoryAttribute>(mask) | KMemoryAttribute::SetMask) ==
-           KMemoryAttribute::SetMask);
-
-    // Lock the table.
+ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask,
+                                          KMemoryAttribute value) {
     std::lock_guard lock{page_table_lock};
 
-    // Verify we can change the memory attribute.
-    KMemoryState old_state;
-    KMemoryPermission old_perm;
-    KMemoryAttribute old_attr;
-    size_t num_allocator_blocks;
-    constexpr auto AttributeTestMask =
-        ~(KMemoryAttribute::SetMask | KMemoryAttribute::DeviceShared);
-    R_TRY(this->CheckMemoryState(
-        std::addressof(old_state), std::addressof(old_perm), std::addressof(old_attr),
-        std::addressof(num_allocator_blocks), addr, size, KMemoryState::FlagCanChangeAttribute,
+    KMemoryState state{};
+    KMemoryPermission perm{};
+    KMemoryAttribute attribute{};
+
+    CASCADE_CODE(CheckMemoryState(
+        &state, &perm, &attribute, addr, size, KMemoryState::FlagCanChangeAttribute,
         KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None,
-        AttributeTestMask, KMemoryAttribute::None, ~AttributeTestMask));
+        KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None,
+        KMemoryAttribute::DeviceSharedAndUncached));
 
-    // Determine the new attribute.
-    const auto new_attr = ((old_attr & static_cast<KMemoryAttribute>(~mask)) |
-                           static_cast<KMemoryAttribute>(attr & mask));
+    attribute = attribute & ~mask;
+    attribute = attribute | (mask & value);
 
-    // Perform operation.
-    this->Operate(addr, num_pages, old_perm, OperationType::ChangePermissionsAndRefresh);
-
-    // Update the blocks.
-    block_manager->Update(addr, num_pages, old_state, old_perm, new_attr);
+    block_manager->Update(addr, size / PageSize, state, perm, attribute);
 
     return ResultSuccess;
 }
@@ -1031,7 +1019,7 @@ ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
 
     KMemoryPermission perm{};
     if (const ResultCode result{CheckMemoryState(
-            nullptr, &perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute,
+            nullptr, &perm, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute,
             KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None,
             KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None,
             KMemoryAttribute::DeviceSharedAndUncached)};
@@ -1054,7 +1042,7 @@ ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size)
 
     KMemoryPermission perm{};
     if (const ResultCode result{CheckMemoryState(
-            nullptr, &perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute,
+            nullptr, &perm, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute,
             KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None,
             KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None,
             KMemoryAttribute::DeviceSharedAndUncached)};
@@ -1080,7 +1068,7 @@ ResultCode KPageTable::LockForCodeMemory(VAddr addr, std::size_t size) {
     KMemoryPermission old_perm{};
 
     if (const ResultCode result{CheckMemoryState(
-            nullptr, &old_perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanCodeMemory,
+            nullptr, &old_perm, nullptr, addr, size, KMemoryState::FlagCanCodeMemory,
             KMemoryState::FlagCanCodeMemory, KMemoryPermission::All,
             KMemoryPermission::UserReadWrite, KMemoryAttribute::All, KMemoryAttribute::None)};
         result.IsError()) {
@@ -1107,7 +1095,7 @@ ResultCode KPageTable::UnlockForCodeMemory(VAddr addr, std::size_t size) {
     KMemoryPermission old_perm{};
 
     if (const ResultCode result{CheckMemoryState(
-            nullptr, &old_perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanCodeMemory,
+            nullptr, &old_perm, nullptr, addr, size, KMemoryState::FlagCanCodeMemory,
             KMemoryState::FlagCanCodeMemory, KMemoryPermission::None, KMemoryPermission::None,
             KMemoryAttribute::All, KMemoryAttribute::Locked)};
         result.IsError()) {
@@ -1237,19 +1225,18 @@ constexpr VAddr KPageTable::GetRegionAddress(KMemoryState state) const {
         return alias_region_start;
     case KMemoryState::Stack:
         return stack_region_start;
+    case KMemoryState::Io:
     case KMemoryState::Static:
     case KMemoryState::ThreadLocal:
         return kernel_map_region_start;
-    case KMemoryState::Io:
     case KMemoryState::Shared:
     case KMemoryState::AliasCode:
     case KMemoryState::AliasCodeData:
-    case KMemoryState::Transfered:
-    case KMemoryState::SharedTransfered:
+    case KMemoryState::Transferred:
+    case KMemoryState::SharedTransferred:
     case KMemoryState::SharedCode:
     case KMemoryState::GeneratedCode:
     case KMemoryState::CodeOut:
-    case KMemoryState::Coverage:
         return alias_code_region_start;
     case KMemoryState::Code:
     case KMemoryState::CodeData:
@@ -1273,19 +1260,18 @@ constexpr std::size_t KPageTable::GetRegionSize(KMemoryState state) const {
         return alias_region_end - alias_region_start;
     case KMemoryState::Stack:
         return stack_region_end - stack_region_start;
+    case KMemoryState::Io:
     case KMemoryState::Static:
     case KMemoryState::ThreadLocal:
         return kernel_map_region_end - kernel_map_region_start;
-    case KMemoryState::Io:
     case KMemoryState::Shared:
     case KMemoryState::AliasCode:
     case KMemoryState::AliasCodeData:
-    case KMemoryState::Transfered:
-    case KMemoryState::SharedTransfered:
+    case KMemoryState::Transferred:
+    case KMemoryState::SharedTransferred:
     case KMemoryState::SharedCode:
     case KMemoryState::GeneratedCode:
     case KMemoryState::CodeOut:
-    case KMemoryState::Coverage:
         return alias_code_region_end - alias_code_region_start;
     case KMemoryState::Code:
     case KMemoryState::CodeData:
@@ -1297,18 +1283,15 @@ constexpr std::size_t KPageTable::GetRegionSize(KMemoryState state) const {
 }
 
 bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) const {
-    const VAddr end = addr + size;
-    const VAddr last = end - 1;
+    const VAddr end{addr + size};
+    const VAddr last{end - 1};
+    const VAddr region_start{GetRegionAddress(state)};
+    const std::size_t region_size{GetRegionSize(state)};
+    const bool is_in_region{region_start <= addr && addr < end &&
+                            last <= region_start + region_size - 1};
+    const bool is_in_heap{!(end <= heap_region_start || heap_region_end <= addr)};
+    const bool is_in_alias{!(end <= alias_region_start || alias_region_end <= addr)};
 
-    const VAddr region_start = this->GetRegionAddress(state);
-    const size_t region_size = this->GetRegionSize(state);
-
-    const bool is_in_region =
-        region_start <= addr && addr < end && last <= region_start + region_size - 1;
-    const bool is_in_heap = !(end <= heap_region_start || heap_region_end <= addr ||
-                              heap_region_start == heap_region_end);
-    const bool is_in_alias = !(end <= alias_region_start || alias_region_end <= addr ||
-                               alias_region_start == alias_region_end);
     switch (state) {
     case KMemoryState::Free:
     case KMemoryState::Kernel:
@@ -1322,12 +1305,11 @@ bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) co
     case KMemoryState::AliasCodeData:
     case KMemoryState::Stack:
     case KMemoryState::ThreadLocal:
-    case KMemoryState::Transfered:
-    case KMemoryState::SharedTransfered:
+    case KMemoryState::Transferred:
+    case KMemoryState::SharedTransferred:
     case KMemoryState::SharedCode:
     case KMemoryState::GeneratedCode:
     case KMemoryState::CodeOut:
-    case KMemoryState::Coverage:
         return is_in_region && !is_in_heap && !is_in_alias;
     case KMemoryState::Normal:
         ASSERT(is_in_heap);
@@ -1342,91 +1324,100 @@ bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) co
     }
 }
 
-ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
-                                        KMemoryState state, KMemoryPermission perm_mask,
-                                        KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                        KMemoryAttribute attr) const {
-    // Validate the states match expectation.
-    R_UNLESS((info.state & state_mask) == state, ResultInvalidCurrentMemory);
-    R_UNLESS((info.perm & perm_mask) == perm, ResultInvalidCurrentMemory);
-    R_UNLESS((info.attribute & attr_mask) == attr, ResultInvalidCurrentMemory);
-
-    return ResultSuccess;
-}
-
-ResultCode KPageTable::CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr,
-                                                  std::size_t size, KMemoryState state_mask,
+constexpr ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
                                                   KMemoryState state, KMemoryPermission perm_mask,
                                                   KMemoryPermission perm,
                                                   KMemoryAttribute attr_mask,
                                                   KMemoryAttribute attr) const {
-    ASSERT(this->IsLockedByCurrentThread());
-
-    // Get information about the first block.
-    const VAddr last_addr = addr + size - 1;
-    KMemoryBlockManager::const_iterator it = block_manager->FindIterator(addr);
-    KMemoryInfo info = it->GetMemoryInfo();
-
-    // If the start address isn't aligned, we need a block.
-    const size_t blocks_for_start_align =
-        (Common::AlignDown(addr, PageSize) != info.GetAddress()) ? 1 : 0;
-
-    while (true) {
-        // Validate against the provided masks.
-        R_TRY(this->CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr));
-
-        // Break once we're done.
-        if (last_addr <= info.GetLastAddress()) {
-            break;
-        }
-
-        // Advance our iterator.
-        it++;
-        ASSERT(it != block_manager->cend());
-        info = it->GetMemoryInfo();
+    // Validate the states match expectation
+    if ((info.state & state_mask) != state) {
+        return ResultInvalidCurrentMemory;
     }
-
-    // If the end address isn't aligned, we need a block.
-    const size_t blocks_for_end_align =
-        (Common::AlignUp(addr + size, PageSize) != info.GetEndAddress()) ? 1 : 0;
-
-    if (out_blocks_needed != nullptr) {
-        *out_blocks_needed = blocks_for_start_align + blocks_for_end_align;
+    if ((info.perm & perm_mask) != perm) {
+        return ResultInvalidCurrentMemory;
+    }
+    if ((info.attribute & attr_mask) != attr) {
+        return ResultInvalidCurrentMemory;
     }
 
     return ResultSuccess;
 }
 
 ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                                        KMemoryAttribute* out_attr, std::size_t* out_blocks_needed,
-                                        VAddr addr, std::size_t size, KMemoryState state_mask,
-                                        KMemoryState state, KMemoryPermission perm_mask,
-                                        KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                        KMemoryAttribute attr, KMemoryAttribute ignore_attr) const {
-    ASSERT(this->IsLockedByCurrentThread());
+                                        KMemoryAttribute* out_attr, VAddr addr, std::size_t size,
+                                        KMemoryState state_mask, KMemoryState state,
+                                        KMemoryPermission perm_mask, KMemoryPermission perm,
+                                        KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                                        KMemoryAttribute ignore_attr) {
+    std::lock_guard lock{page_table_lock};
 
+    // Get information about the first block
+    const VAddr last_addr{addr + size - 1};
+    KMemoryBlockManager::const_iterator it{block_manager->FindIterator(addr)};
+    KMemoryInfo info{it->GetMemoryInfo()};
+
+    // Validate all blocks in the range have correct state
+    const KMemoryState first_state{info.state};
+    const KMemoryPermission first_perm{info.perm};
+    const KMemoryAttribute first_attr{info.attribute};
+
+    while (true) {
+        // Validate the current block
+        if (!(info.state == first_state)) {
+            return ResultInvalidCurrentMemory;
+        }
+        if (!(info.perm == first_perm)) {
+            return ResultInvalidCurrentMemory;
+        }
+        if (!((info.attribute | static_cast<KMemoryAttribute>(ignore_attr)) ==
+              (first_attr | static_cast<KMemoryAttribute>(ignore_attr)))) {
+            return ResultInvalidCurrentMemory;
+        }
+
+        // Validate against the provided masks
+        CASCADE_CODE(CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr));
+
+        // Break once we're done
+        if (last_addr <= info.GetLastAddress()) {
+            break;
+        }
+
+        // Advance our iterator
+        it++;
+        ASSERT(it != block_manager->cend());
+        info = it->GetMemoryInfo();
+    }
+
+    // Write output state
+    if (out_state) {
+        *out_state = first_state;
+    }
+    if (out_perm) {
+        *out_perm = first_perm;
+    }
+    if (out_attr) {
+        *out_attr = first_attr & static_cast<KMemoryAttribute>(~ignore_attr);
+    }
+
+    return ResultSuccess;
+}
+
+ResultCode KPageTable::CheckMemoryState(size_t* out_blocks_needed, VAddr addr, size_t size,
+                                        KMemoryState state_mask, KMemoryState state,
+                                        KMemoryPermission perm_mask, KMemoryPermission perm,
+                                        KMemoryAttribute attr_mask, KMemoryAttribute attr) const {
     // Get information about the first block.
     const VAddr last_addr = addr + size - 1;
-    KMemoryBlockManager::const_iterator it = block_manager->FindIterator(addr);
+    KMemoryBlockManager::const_iterator it{block_manager->FindIterator(addr)};
     KMemoryInfo info = it->GetMemoryInfo();
 
     // If the start address isn't aligned, we need a block.
     const size_t blocks_for_start_align =
         (Common::AlignDown(addr, PageSize) != info.GetAddress()) ? 1 : 0;
 
-    // Validate all blocks in the range have correct state.
-    const KMemoryState first_state = info.state;
-    const KMemoryPermission first_perm = info.perm;
-    const KMemoryAttribute first_attr = info.attribute;
     while (true) {
-        // Validate the current block.
-        R_UNLESS(info.state == first_state, ResultInvalidCurrentMemory);
-        R_UNLESS(info.perm == first_perm, ResultInvalidCurrentMemory);
-        R_UNLESS((info.attribute | ignore_attr) == (first_attr | ignore_attr),
-                 ResultInvalidCurrentMemory);
-
         // Validate against the provided masks.
-        R_TRY(this->CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr));
+        R_TRY(CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr));
 
         // Break once we're done.
         if (last_addr <= info.GetLastAddress()) {
@@ -1435,7 +1426,6 @@ ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermissi
 
         // Advance our iterator.
         it++;
-        ASSERT(it != block_manager->cend());
         info = it->GetMemoryInfo();
     }
 
@@ -1443,19 +1433,10 @@ ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermissi
     const size_t blocks_for_end_align =
         (Common::AlignUp(addr + size, PageSize) != info.GetEndAddress()) ? 1 : 0;
 
-    // Write output state.
-    if (out_state != nullptr) {
-        *out_state = first_state;
-    }
-    if (out_perm != nullptr) {
-        *out_perm = first_perm;
-    }
-    if (out_attr != nullptr) {
-        *out_attr = static_cast<KMemoryAttribute>(first_attr & ~ignore_attr);
-    }
     if (out_blocks_needed != nullptr) {
         *out_blocks_needed = blocks_for_start_align + blocks_for_end_align;
     }
+
     return ResultSuccess;
 }
 

src/core/hle/kernel/k_page_table.h

@@ -48,7 +48,8 @@ public:
     ResultCode ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm);
     ResultCode ResetTransferMemory(VAddr addr, std::size_t size);
     ResultCode SetMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission perm);
-    ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr);
+    ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask,
+                                  KMemoryAttribute value);
     ResultCode SetMaxHeapSize(std::size_t size);
     ResultCode SetHeapSize(VAddr* out, std::size_t size);
     ResultVal<VAddr> AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
@@ -101,50 +102,28 @@ private:
     constexpr VAddr GetRegionAddress(KMemoryState state) const;
     constexpr std::size_t GetRegionSize(KMemoryState state) const;
 
-    ResultCode CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr,
-                                          std::size_t size, KMemoryState state_mask,
+    constexpr ResultCode CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
                                           KMemoryState state, KMemoryPermission perm_mask,
                                           KMemoryPermission perm, KMemoryAttribute attr_mask,
                                           KMemoryAttribute attr) const;
-    ResultCode CheckMemoryStateContiguous(VAddr addr, std::size_t size, KMemoryState state_mask,
-                                          KMemoryState state, KMemoryPermission perm_mask,
-                                          KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                          KMemoryAttribute attr) const {
-        return this->CheckMemoryStateContiguous(nullptr, addr, size, state_mask, state, perm_mask,
-                                                perm, attr_mask, attr);
-    }
-
-    ResultCode CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
-                                KMemoryState state, KMemoryPermission perm_mask,
-                                KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                KMemoryAttribute attr) const;
     ResultCode CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                                KMemoryAttribute* out_attr, std::size_t* out_blocks_needed,
-                                VAddr addr, std::size_t size, KMemoryState state_mask,
-                                KMemoryState state, KMemoryPermission perm_mask,
-                                KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                KMemoryAttribute attr,
-                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
-    ResultCode CheckMemoryState(std::size_t* out_blocks_needed, VAddr addr, std::size_t size,
+                                KMemoryAttribute* out_attr, VAddr addr, std::size_t size,
                                 KMemoryState state_mask, KMemoryState state,
                                 KMemoryPermission perm_mask, KMemoryPermission perm,
                                 KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
-        return CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size,
-                                state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr);
-    }
-    ResultCode CheckMemoryState(VAddr addr, size_t size, KMemoryState state_mask,
+                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr);
+    ResultCode CheckMemoryState(VAddr addr, std::size_t size, KMemoryState state_mask,
                                 KMemoryState state, KMemoryPermission perm_mask,
                                 KMemoryPermission perm, KMemoryAttribute attr_mask,
                                 KMemoryAttribute attr,
-                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
-        return this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm,
-                                      attr_mask, attr, ignore_attr);
-    }
-
-    bool IsLockedByCurrentThread() const {
-        return true;
+                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) {
+        return CheckMemoryState(nullptr, nullptr, nullptr, addr, size, state_mask, state, perm_mask,
+                                perm, attr_mask, attr, ignore_attr);
     }
+    ResultCode CheckMemoryState(size_t* out_blocks_needed, VAddr addr, size_t size,
+                                KMemoryState state_mask, KMemoryState state,
+                                KMemoryPermission perm_mask, KMemoryPermission perm,
+                                KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
 
     std::recursive_mutex page_table_lock;
     std::unique_ptr<KMemoryBlockManager> block_manager;

src/core/hle/kernel/svc.cpp

@@ -168,9 +168,6 @@ constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
 
 static ResultCode SetMemoryPermission(Core::System& system, VAddr address, u64 size,
                                       MemoryPermission perm) {
-    LOG_DEBUG(Kernel_SVC, "called, address=0x{:016X}, size=0x{:X}, perm=0x{:08X", address, size,
-              perm);
-
     // Validate address / size.
     R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
     R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
@@ -189,33 +186,46 @@ static ResultCode SetMemoryPermission(Core::System& system, VAddr address, u64 s
 }
 
 static ResultCode SetMemoryAttribute(Core::System& system, VAddr address, u64 size, u32 mask,
-                                     u32 attr) {
+                                     u32 attribute) {
     LOG_DEBUG(Kernel_SVC,
               "called, address=0x{:016X}, size=0x{:X}, mask=0x{:08X}, attribute=0x{:08X}", address,
-              size, mask, attr);
+              size, mask, attribute);
 
-    // Validate address / size.
-    R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
-    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
-    R_UNLESS(size > 0, ResultInvalidSize);
-    R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
+    if (!Common::Is4KBAligned(address)) {
+        LOG_ERROR(Kernel_SVC, "Address not page aligned (0x{:016X})", address);
+        return ResultInvalidAddress;
+    }
 
-    // Validate the attribute and mask.
-    constexpr u32 SupportedMask = static_cast<u32>(MemoryAttribute::Uncached);
-    R_UNLESS((mask | attr) == mask, ResultInvalidCombination);
-    R_UNLESS((mask | attr | SupportedMask) == SupportedMask, ResultInvalidCombination);
+    if (size == 0 || !Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Invalid size (0x{:X}). Size must be non-zero and page aligned.",
+                  size);
+        return ResultInvalidAddress;
+    }
+
+    if (!IsValidAddressRange(address, size)) {
+        LOG_ERROR(Kernel_SVC, "Address range overflowed (Address: 0x{:016X}, Size: 0x{:016X})",
+                  address, size);
+        return ResultInvalidCurrentMemory;
+    }
+
+    const auto attributes{static_cast<MemoryAttribute>(mask | attribute)};
+    if (attributes != static_cast<MemoryAttribute>(mask) ||
+        (attributes | MemoryAttribute::Uncached) != MemoryAttribute::Uncached) {
+        LOG_ERROR(Kernel_SVC,
+                  "Memory attribute doesn't match the given mask (Attribute: 0x{:X}, Mask: {:X}",
+                  attribute, mask);
+        return ResultInvalidCombination;
+    }
 
-    // Validate that the region is in range for the current process.
     auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
-    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
 
-    // Set the memory attribute.
-    return page_table.SetMemoryAttribute(address, size, mask, attr);
+    return page_table.SetMemoryAttribute(address, size, static_cast<KMemoryAttribute>(mask),
+                                         static_cast<KMemoryAttribute>(attribute));
 }
 
 static ResultCode SetMemoryAttribute32(Core::System& system, u32 address, u32 size, u32 mask,
-                                       u32 attr) {
-    return SetMemoryAttribute(system, address, size, mask, attr);
+                                       u32 attribute) {
+    return SetMemoryAttribute(system, address, size, mask, attribute);
 }
 
 /// Maps a memory range into a different range.

src/core/hle/kernel/svc_types.h

@@ -32,7 +32,6 @@ enum class MemoryState : u32 {
     Kernel = 0x13,
     GeneratedCode = 0x14,
     CodeOut = 0x15,
-    Coverage = 0x16,
 };
 DECLARE_ENUM_FLAG_OPERATORS(MemoryState);
 

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

@@ -37,8 +37,7 @@ namespace Service::HID {
 // Period time is obtained by measuring the number of samples in a second on HW using a homebrew
 constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};            // (4ms, 250Hz)
 constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz)
-// TODO: Correct update rate for motion is 5ms. Check why some games don't behave at that speed
-constexpr auto motion_update_ns = std::chrono::nanoseconds{10 * 1000 * 1000}; // (10ms, 100Hz)
+constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000};         // (5ms, 200Hz)
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
 
 IAppletResource::IAppletResource(Core::System& system_,

src/input_common/drivers/sdl_driver.cpp

@@ -663,7 +663,6 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding() const {
         {Settings::NativeButton::SL, SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
         {Settings::NativeButton::SR, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
         {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
-        {Settings::NativeButton::Screenshot, SDL_CONTROLLER_BUTTON_MISC1},
     };
 }
 
@@ -700,7 +699,6 @@ ButtonBindings SDLDriver::GetNintendoButtonBinding(
         {Settings::NativeButton::SL, sl_button},
         {Settings::NativeButton::SR, sr_button},
         {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
-        {Settings::NativeButton::Screenshot, SDL_CONTROLLER_BUTTON_MISC1},
     };
 }
 

src/input_common/drivers/sdl_driver.h

@@ -24,7 +24,7 @@ namespace InputCommon {
 class SDLJoystick;
 
 using ButtonBindings =
-    std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 18>;
+    std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 17>;
 using ZButtonBindings =
     std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerAxis>, 2>;
 

src/input_common/drivers/tas_input.cpp

@@ -23,7 +23,7 @@ enum class Tas::TasAxis : u8 {
 };
 
 // Supported keywords and buttons from a TAS file
-constexpr std::array<std::pair<std::string_view, TasButton>, 18> text_to_tas_button = {
+constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_button = {
     std::pair{"KEY_A", TasButton::BUTTON_A},
     {"KEY_B", TasButton::BUTTON_B},
     {"KEY_X", TasButton::BUTTON_X},
@@ -40,9 +40,8 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 18> text_to_tas_but
     {"KEY_DDOWN", TasButton::BUTTON_DOWN},
     {"KEY_SL", TasButton::BUTTON_SL},
     {"KEY_SR", TasButton::BUTTON_SR},
-    // These buttons are disabled to avoid TAS input from activating hotkeys
-    // {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE},
-    // {"KEY_HOME", TasButton::BUTTON_HOME},
+    {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE},
+    {"KEY_HOME", TasButton::BUTTON_HOME},
     {"KEY_ZL", TasButton::TRIGGER_ZL},
     {"KEY_ZR", TasButton::TRIGGER_ZR},
 };

src/tests/CMakeLists.txt

@@ -16,6 +16,6 @@ add_executable(tests
 create_target_directory_groups(tests)
 
 target_link_libraries(tests PRIVATE common core input_common)
-target_link_libraries(tests PRIVATE ${PLATFORM_LIBRARIES} Catch2::Catch2 Threads::Threads)
+target_link_libraries(tests PRIVATE ${PLATFORM_LIBRARIES} catch-single-include Threads::Threads)
 
 add_test(NAME tests COMMAND tests)

src/yuzu/configuration/config.cpp

@@ -66,27 +66,27 @@ const std::array<int, 2> Config::default_stick_mod = {
 // UISetting::values.shortcuts, which is alphabetically ordered.
 // clang-format off
 const std::array<UISettings::Shortcut, 21> Config::default_hotkeys{{
-    {QStringLiteral("Capture Screenshot"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"),  QStringLiteral("Screenshot"), Qt::WidgetWithChildrenShortcut}},
-    {QStringLiteral("Change Docked Mode"),       QStringLiteral("Main Window"), {QStringLiteral("F10"),     QStringLiteral("Home+X"), Qt::ApplicationShortcut}},
-    {QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"),      QStringLiteral("Home+Plus"), Qt::WindowShortcut}},
-    {QStringLiteral("Decrease Speed Limit"),     QStringLiteral("Main Window"), {QStringLiteral("-"),       QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("Exit Fullscreen"),          QStringLiteral("Main Window"), {QStringLiteral("Esc"),     QStringLiteral(""), Qt::WindowShortcut}},
-    {QStringLiteral("Exit yuzu"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"),  QStringLiteral("Home+Minus"), Qt::WindowShortcut}},
-    {QStringLiteral("Fullscreen"),               QStringLiteral("Main Window"), {QStringLiteral("F11"),     QStringLiteral("Home+B"), Qt::WindowShortcut}},
-    {QStringLiteral("Increase Speed Limit"),     QStringLiteral("Main Window"), {QStringLiteral("+"),       QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("Load Amiibo"),              QStringLiteral("Main Window"), {QStringLiteral("F2"),      QStringLiteral("Home+A"), Qt::WidgetWithChildrenShortcut}},
-    {QStringLiteral("Load File"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"),  QStringLiteral(""), Qt::WidgetWithChildrenShortcut}},
-    {QStringLiteral("Mute Audio"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+M"),  QStringLiteral(""), Qt::WindowShortcut}},
-    {QStringLiteral("Restart Emulation"),        QStringLiteral("Main Window"), {QStringLiteral("F6"),      QStringLiteral(""), Qt::WindowShortcut}},
-    {QStringLiteral("Stop Emulation"),           QStringLiteral("Main Window"), {QStringLiteral("F5"),      QStringLiteral(""), Qt::WindowShortcut}},
-    {QStringLiteral("TAS Start/Stop"),           QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F5"), QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("TAS Reset"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F6"), QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("TAS Record"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F7"), QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("Toggle Filter Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"),  QStringLiteral(""), Qt::WindowShortcut}},
-    {QStringLiteral("Toggle Framerate Limit"),   QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"),  QStringLiteral("Home+Y"), Qt::ApplicationShortcut}},
-    {QStringLiteral("Toggle Mouse Panning"),     QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("Toggle Speed Limit"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"),  QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("Toggle Status Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"),  QStringLiteral(""), Qt::WindowShortcut}},
+    {QStringLiteral("Capture Screenshot"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"), Qt::WidgetWithChildrenShortcut}},
+    {QStringLiteral("Change Docked Mode"),       QStringLiteral("Main Window"), {QStringLiteral("F10"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"), Qt::WindowShortcut}},
+    {QStringLiteral("Decrease Speed Limit"),     QStringLiteral("Main Window"), {QStringLiteral("-"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Exit Fullscreen"),          QStringLiteral("Main Window"), {QStringLiteral("Esc"), Qt::WindowShortcut}},
+    {QStringLiteral("Exit yuzu"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"), Qt::WindowShortcut}},
+    {QStringLiteral("Fullscreen"),               QStringLiteral("Main Window"), {QStringLiteral("F11"), Qt::WindowShortcut}},
+    {QStringLiteral("Increase Speed Limit"),     QStringLiteral("Main Window"), {QStringLiteral("+"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Load Amiibo"),              QStringLiteral("Main Window"), {QStringLiteral("F2"), Qt::WidgetWithChildrenShortcut}},
+    {QStringLiteral("Load File"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"), Qt::WidgetWithChildrenShortcut}},
+    {QStringLiteral("Mute Audio"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+M"), Qt::WindowShortcut}},
+    {QStringLiteral("Restart Emulation"),        QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}},
+    {QStringLiteral("Stop Emulation"),           QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}},
+    {QStringLiteral("TAS Start/Stop"),           QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F5"), Qt::ApplicationShortcut}},
+    {QStringLiteral("TAS Reset"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F6"), Qt::ApplicationShortcut}},
+    {QStringLiteral("TAS Record"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F7"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Toggle Filter Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}},
+    {QStringLiteral("Toggle Framerate Limit"),   QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Toggle Mouse Panning"),     QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Toggle Speed Limit"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}},
+    {QStringLiteral("Toggle Status Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}},
 }};
 // clang-format on
 
@@ -679,6 +679,7 @@ void Config::ReadShortcutValues() {
     qt_config->beginGroup(QStringLiteral("Shortcuts"));
 
     for (const auto& [name, group, shortcut] : default_hotkeys) {
+        const auto& [keyseq, context] = shortcut;
         qt_config->beginGroup(group);
         qt_config->beginGroup(name);
         // No longer using ReadSetting for shortcut.second as it innacurately returns a value of 1
@@ -687,10 +688,7 @@ void Config::ReadShortcutValues() {
         UISettings::values.shortcuts.push_back(
             {name,
              group,
-             {ReadSetting(QStringLiteral("KeySeq"), shortcut.keyseq).toString(),
-              ReadSetting(QStringLiteral("Controller_KeySeq"), shortcut.controller_keyseq)
-                  .toString(),
-              shortcut.context}});
+             {ReadSetting(QStringLiteral("KeySeq"), keyseq).toString(), shortcut.second}});
         qt_config->endGroup();
         qt_config->endGroup();
     }
@@ -1229,10 +1227,8 @@ void Config::SaveShortcutValues() {
 
         qt_config->beginGroup(group);
         qt_config->beginGroup(name);
-        WriteSetting(QStringLiteral("KeySeq"), shortcut.keyseq, default_hotkey.keyseq);
-        WriteSetting(QStringLiteral("Controller_KeySeq"), shortcut.controller_keyseq,
-                     default_hotkey.controller_keyseq);
-        WriteSetting(QStringLiteral("Context"), shortcut.context, default_hotkey.context);
+        WriteSetting(QStringLiteral("KeySeq"), shortcut.first, default_hotkey.first);
+        WriteSetting(QStringLiteral("Context"), shortcut.second, default_hotkey.second);
         qt_config->endGroup();
         qt_config->endGroup();
     }

src/yuzu/configuration/configure_dialog.cpp

@@ -45,7 +45,7 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
       general_tab{std::make_unique<ConfigureGeneral>(system_, this)},
       graphics_tab{std::make_unique<ConfigureGraphics>(system_, this)},
       graphics_advanced_tab{std::make_unique<ConfigureGraphicsAdvanced>(system_, this)},
-      hotkeys_tab{std::make_unique<ConfigureHotkeys>(system_.HIDCore(), this)},
+      hotkeys_tab{std::make_unique<ConfigureHotkeys>(this)},
       input_tab{std::make_unique<ConfigureInput>(system_, this)},
       network_tab{std::make_unique<ConfigureNetwork>(system_, this)},
       profile_tab{std::make_unique<ConfigureProfileManager>(system_, this)},

src/yuzu/configuration/configure_hotkeys.cpp

@@ -5,24 +5,15 @@
 #include <QMenu>
 #include <QMessageBox>
 #include <QStandardItemModel>
-#include <QTimer>
-
-#include "core/hid/emulated_controller.h"
-#include "core/hid/hid_core.h"
-
+#include "common/settings.h"
 #include "ui_configure_hotkeys.h"
 #include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_hotkeys.h"
 #include "yuzu/hotkeys.h"
 #include "yuzu/util/sequence_dialog/sequence_dialog.h"
 
-constexpr int name_column = 0;
-constexpr int hotkey_column = 1;
-constexpr int controller_column = 2;
-
-ConfigureHotkeys::ConfigureHotkeys(Core::HID::HIDCore& hid_core, QWidget* parent)
-    : QWidget(parent), ui(std::make_unique<Ui::ConfigureHotkeys>()),
-      timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()) {
+ConfigureHotkeys::ConfigureHotkeys(QWidget* parent)
+    : QWidget(parent), ui(std::make_unique<Ui::ConfigureHotkeys>()) {
     ui->setupUi(this);
     setFocusPolicy(Qt::ClickFocus);
 
@@ -35,24 +26,16 @@ ConfigureHotkeys::ConfigureHotkeys(Core::HID::HIDCore& hid_core, QWidget* parent
     ui->hotkey_list->setContextMenuPolicy(Qt::CustomContextMenu);
     ui->hotkey_list->setModel(model);
 
-    ui->hotkey_list->setColumnWidth(name_column, 200);
-    ui->hotkey_list->resizeColumnToContents(hotkey_column);
+    // TODO(Kloen): Make context configurable as well (hiding the column for now)
+    ui->hotkey_list->hideColumn(2);
+
+    ui->hotkey_list->setColumnWidth(0, 200);
+    ui->hotkey_list->resizeColumnToContents(1);
 
     connect(ui->button_restore_defaults, &QPushButton::clicked, this,
             &ConfigureHotkeys::RestoreDefaults);
     connect(ui->button_clear_all, &QPushButton::clicked, this, &ConfigureHotkeys::ClearAll);
 
-    controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1);
-
-    connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); });
-
-    connect(poll_timer.get(), &QTimer::timeout, [this] {
-        const auto buttons = controller->GetNpadButtons();
-        if (buttons.raw != Core::HID::NpadButton::None) {
-            SetPollingResult(buttons.raw, false);
-            return;
-        }
-    });
     RetranslateUI();
 }
 
@@ -66,18 +49,15 @@ void ConfigureHotkeys::Populate(const HotkeyRegistry& registry) {
             auto* action = new QStandardItem(hotkey.first);
             auto* keyseq =
                 new QStandardItem(hotkey.second.keyseq.toString(QKeySequence::NativeText));
-            auto* controller_keyseq = new QStandardItem(hotkey.second.controller_keyseq);
             action->setEditable(false);
             keyseq->setEditable(false);
-            controller_keyseq->setEditable(false);
-            parent_item->appendRow({action, keyseq, controller_keyseq});
+            parent_item->appendRow({action, keyseq});
         }
         model->appendRow(parent_item);
     }
 
     ui->hotkey_list->expandAll();
-    ui->hotkey_list->resizeColumnToContents(name_column);
-    ui->hotkey_list->resizeColumnToContents(hotkey_column);
+    ui->hotkey_list->resizeColumnToContents(0);
 }
 
 void ConfigureHotkeys::changeEvent(QEvent* event) {
@@ -91,7 +71,7 @@ void ConfigureHotkeys::changeEvent(QEvent* event) {
 void ConfigureHotkeys::RetranslateUI() {
     ui->retranslateUi(this);
 
-    model->setHorizontalHeaderLabels({tr("Action"), tr("Hotkey"), tr("Controller Hotkey")});
+    model->setHorizontalHeaderLabels({tr("Action"), tr("Hotkey"), tr("Context")});
 }
 
 void ConfigureHotkeys::Configure(QModelIndex index) {
@@ -99,15 +79,7 @@ void ConfigureHotkeys::Configure(QModelIndex index) {
         return;
     }
 
-    // Controller configuration is selected
-    if (index.column() == controller_column) {
-        ConfigureController(index);
-        return;
-    }
-
-    // Swap to the hotkey column
-    index = index.sibling(index.row(), hotkey_column);
-
+    index = index.sibling(index.row(), 1);
     const auto previous_key = model->data(index);
 
     SequenceDialog hotkey_dialog{this};
@@ -127,113 +99,13 @@ void ConfigureHotkeys::Configure(QModelIndex index) {
         model->setData(index, key_sequence.toString(QKeySequence::NativeText));
     }
 }
-void ConfigureHotkeys::ConfigureController(QModelIndex index) {
-    if (timeout_timer->isActive()) {
-        return;
-    }
-
-    const auto previous_key = model->data(index);
-
-    input_setter = [this, index, previous_key](const Core::HID::NpadButton button,
-                                               const bool cancel) {
-        if (cancel) {
-            model->setData(index, previous_key);
-            return;
-        }
-
-        const QString button_string = tr("Home+%1").arg(GetButtonName(button));
-
-        const auto [key_sequence_used, used_action] = IsUsedControllerKey(button_string);
-
-        if (key_sequence_used) {
-            QMessageBox::warning(
-                this, tr("Conflicting Key Sequence"),
-                tr("The entered key sequence is already assigned to: %1").arg(used_action));
-            model->setData(index, previous_key);
-        } else {
-            model->setData(index, button_string);
-        }
-    };
-
-    model->setData(index, tr("[waiting]"));
-    timeout_timer->start(2500); // Cancel after 2.5 seconds
-    poll_timer->start(200);     // Check for new inputs every 200ms
-    // We need to disable configuration to be able to read npad buttons
-    controller->DisableConfiguration();
-    controller->DisableSystemButtons();
-}
-
-void ConfigureHotkeys::SetPollingResult(Core::HID::NpadButton button, const bool cancel) {
-    timeout_timer->stop();
-    poll_timer->stop();
-    // Re-Enable configuration
-    controller->EnableConfiguration();
-    controller->EnableSystemButtons();
-
-    (*input_setter)(button, cancel);
-
-    input_setter = std::nullopt;
-}
-
-QString ConfigureHotkeys::GetButtonName(Core::HID::NpadButton button) const {
-    Core::HID::NpadButtonState state{button};
-    if (state.a) {
-        return tr("A");
-    }
-    if (state.b) {
-        return tr("B");
-    }
-    if (state.x) {
-        return tr("X");
-    }
-    if (state.y) {
-        return tr("Y");
-    }
-    if (state.l || state.right_sl || state.left_sl) {
-        return tr("L");
-    }
-    if (state.r || state.right_sr || state.left_sr) {
-        return tr("R");
-    }
-    if (state.zl) {
-        return tr("ZL");
-    }
-    if (state.zr) {
-        return tr("ZR");
-    }
-    if (state.left) {
-        return tr("Dpad_Left");
-    }
-    if (state.right) {
-        return tr("Dpad_Right");
-    }
-    if (state.up) {
-        return tr("Dpad_Up");
-    }
-    if (state.down) {
-        return tr("Dpad_Down");
-    }
-    if (state.stick_l) {
-        return tr("Left_Stick");
-    }
-    if (state.stick_r) {
-        return tr("Right_Stick");
-    }
-    if (state.minus) {
-        return tr("Minus");
-    }
-    if (state.plus) {
-        return tr("Plus");
-    }
-    return tr("Invalid");
-}
 
 std::pair<bool, QString> ConfigureHotkeys::IsUsedKey(QKeySequence key_sequence) const {
     for (int r = 0; r < model->rowCount(); ++r) {
         const QStandardItem* const parent = model->item(r, 0);
 
         for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
-            const QStandardItem* const key_seq_item = parent->child(r2, hotkey_column);
+            const QStandardItem* const key_seq_item = parent->child(r2, 1);
             const auto key_seq_str = key_seq_item->text();
             const auto key_seq = QKeySequence::fromString(key_seq_str, QKeySequence::NativeText);
 
@@ -246,31 +118,12 @@ std::pair<bool, QString> ConfigureHotkeys::IsUsedKey(QKeySequence key_sequence)
     return std::make_pair(false, QString());
 }
 
-std::pair<bool, QString> ConfigureHotkeys::IsUsedControllerKey(const QString& key_sequence) const {
-    for (int r = 0; r < model->rowCount(); ++r) {
-        const QStandardItem* const parent = model->item(r, 0);
-
-        for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
-            const QStandardItem* const key_seq_item = parent->child(r2, controller_column);
-            const auto key_seq_str = key_seq_item->text();
-
-            if (key_sequence == key_seq_str) {
-                return std::make_pair(true, parent->child(r2, 0)->text());
-            }
-        }
-    }
-
-    return std::make_pair(false, QString());
-}
-
 void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
     for (int key_id = 0; key_id < model->rowCount(); key_id++) {
         const QStandardItem* parent = model->item(key_id, 0);
         for (int key_column_id = 0; key_column_id < parent->rowCount(); key_column_id++) {
-            const QStandardItem* action = parent->child(key_column_id, name_column);
-            const QStandardItem* keyseq = parent->child(key_column_id, hotkey_column);
-            const QStandardItem* controller_keyseq =
-                parent->child(key_column_id, controller_column);
+            const QStandardItem* action = parent->child(key_column_id, 0);
+            const QStandardItem* keyseq = parent->child(key_column_id, 1);
             for (auto& [group, sub_actions] : registry.hotkey_groups) {
                 if (group != parent->text())
                     continue;
@@ -278,7 +131,6 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
                     if (action_name != action->text())
                         continue;
                     hotkey.keyseq = QKeySequence(keyseq->text());
-                    hotkey.controller_keyseq = controller_keyseq->text();
                 }
             }
         }
@@ -292,12 +144,7 @@ void ConfigureHotkeys::RestoreDefaults() {
         const QStandardItem* parent = model->item(r, 0);
 
         for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
-            model->item(r, 0)
-                ->child(r2, hotkey_column)
-                ->setText(Config::default_hotkeys[r2].shortcut.keyseq);
-            model->item(r, 0)
-                ->child(r2, controller_column)
-                ->setText(Config::default_hotkeys[r2].shortcut.controller_keyseq);
+            model->item(r, 0)->child(r2, 1)->setText(Config::default_hotkeys[r2].shortcut.first);
         }
     }
 }
@@ -307,8 +154,7 @@ void ConfigureHotkeys::ClearAll() {
         const QStandardItem* parent = model->item(r, 0);
 
         for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
-            model->item(r, 0)->child(r2, hotkey_column)->setText(QString{});
-            model->item(r, 0)->child(r2, controller_column)->setText(QString{});
+            model->item(r, 0)->child(r2, 1)->setText(QString{});
         }
     }
 }
@@ -319,52 +165,28 @@ void ConfigureHotkeys::PopupContextMenu(const QPoint& menu_location) {
         return;
     }
 
-    // Swap to the hotkey column if the controller hotkey column is not selected
-    if (index.column() != controller_column) {
-        index = index.sibling(index.row(), hotkey_column);
-    }
-
+    const auto selected = index.sibling(index.row(), 1);
     QMenu context_menu;
 
     QAction* restore_default = context_menu.addAction(tr("Restore Default"));
     QAction* clear = context_menu.addAction(tr("Clear"));
 
-    connect(restore_default, &QAction::triggered, [this, index] {
-        if (index.column() == controller_column) {
-            RestoreControllerHotkey(index);
-            return;
+    connect(restore_default, &QAction::triggered, [this, selected] {
+        const QKeySequence& default_key_sequence = QKeySequence::fromString(
+            Config::default_hotkeys[selected.row()].shortcut.first, QKeySequence::NativeText);
+        const auto [key_sequence_used, used_action] = IsUsedKey(default_key_sequence);
+
+        if (key_sequence_used &&
+            default_key_sequence != QKeySequence(model->data(selected).toString())) {
+
+            QMessageBox::warning(
+                this, tr("Conflicting Key Sequence"),
+                tr("The default key sequence is already assigned to: %1").arg(used_action));
+        } else {
+            model->setData(selected, default_key_sequence.toString(QKeySequence::NativeText));
         }
-        RestoreHotkey(index);
     });
-    connect(clear, &QAction::triggered, [this, index] { model->setData(index, QString{}); });
+    connect(clear, &QAction::triggered, [this, selected] { model->setData(selected, QString{}); });
 
     context_menu.exec(ui->hotkey_list->viewport()->mapToGlobal(menu_location));
 }
-
-void ConfigureHotkeys::RestoreControllerHotkey(QModelIndex index) {
-    const QString& default_key_sequence =
-        Config::default_hotkeys[index.row()].shortcut.controller_keyseq;
-    const auto [key_sequence_used, used_action] = IsUsedControllerKey(default_key_sequence);
-
-    if (key_sequence_used && default_key_sequence != model->data(index).toString()) {
-        QMessageBox::warning(
-            this, tr("Conflicting Button Sequence"),
-            tr("The default button sequence is already assigned to: %1").arg(used_action));
-    } else {
-        model->setData(index, default_key_sequence);
-    }
-}
-
-void ConfigureHotkeys::RestoreHotkey(QModelIndex index) {
-    const QKeySequence& default_key_sequence = QKeySequence::fromString(
-        Config::default_hotkeys[index.row()].shortcut.keyseq, QKeySequence::NativeText);
-    const auto [key_sequence_used, used_action] = IsUsedKey(default_key_sequence);
-
-    if (key_sequence_used && default_key_sequence != QKeySequence(model->data(index).toString())) {
-        QMessageBox::warning(
-            this, tr("Conflicting Key Sequence"),
-            tr("The default key sequence is already assigned to: %1").arg(used_action));
-    } else {
-        model->setData(index, default_key_sequence.toString(QKeySequence::NativeText));
-    }
-}

src/yuzu/configuration/configure_hotkeys.h

@@ -7,16 +7,6 @@
 #include <memory>
 #include <QWidget>
 
-namespace Common {
-class ParamPackage;
-}
-
-namespace Core::HID {
-class HIDCore;
-class EmulatedController;
-enum class NpadButton : u64;
-} // namespace Core::HID
-
 namespace Ui {
 class ConfigureHotkeys;
 }
@@ -28,7 +18,7 @@ class ConfigureHotkeys : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ConfigureHotkeys(Core::HID::HIDCore& hid_core_, QWidget* parent = nullptr);
+    explicit ConfigureHotkeys(QWidget* parent = nullptr);
     ~ConfigureHotkeys() override;
 
     void ApplyConfiguration(HotkeyRegistry& registry);
@@ -45,24 +35,13 @@ private:
     void RetranslateUI();
 
     void Configure(QModelIndex index);
-    void ConfigureController(QModelIndex index);
     std::pair<bool, QString> IsUsedKey(QKeySequence key_sequence) const;
-    std::pair<bool, QString> IsUsedControllerKey(const QString& key_sequence) const;
 
     void RestoreDefaults();
     void ClearAll();
     void PopupContextMenu(const QPoint& menu_location);
-    void RestoreControllerHotkey(QModelIndex index);
-    void RestoreHotkey(QModelIndex index);
 
     std::unique_ptr<Ui::ConfigureHotkeys> ui;
 
     QStandardItemModel* model;
-
-    void SetPollingResult(Core::HID::NpadButton button, bool cancel);
-    QString GetButtonName(Core::HID::NpadButton button) const;
-    Core::HID::EmulatedController* controller;
-    std::unique_ptr<QTimer> timeout_timer;
-    std::unique_ptr<QTimer> poll_timer;
-    std::optional<std::function<void(Core::HID::NpadButton, bool)>> input_setter;
 };

src/yuzu/hotkeys.cpp

@@ -2,13 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <sstream>
 #include <QKeySequence>
 #include <QShortcut>
 #include <QTreeWidgetItem>
 #include <QtGlobal>
-
-#include "core/hid/emulated_controller.h"
 #include "yuzu/hotkeys.h"
 #include "yuzu/uisettings.h"
 
@@ -21,9 +18,8 @@ void HotkeyRegistry::SaveHotkeys() {
         for (const auto& hotkey : group.second) {
             UISettings::values.shortcuts.push_back(
                 {hotkey.first, group.first,
-                 UISettings::ContextualShortcut({hotkey.second.keyseq.toString(),
-                                                 hotkey.second.controller_keyseq,
-                                                 hotkey.second.context})});
+                 UISettings::ContextualShortcut(hotkey.second.keyseq.toString(),
+                                                hotkey.second.context)});
         }
     }
 }
@@ -33,49 +29,28 @@ void HotkeyRegistry::LoadHotkeys() {
     // beginGroup()
     for (auto shortcut : UISettings::values.shortcuts) {
         Hotkey& hk = hotkey_groups[shortcut.group][shortcut.name];
-        if (!shortcut.shortcut.keyseq.isEmpty()) {
-            hk.keyseq =
-                QKeySequence::fromString(shortcut.shortcut.keyseq, QKeySequence::NativeText);
-            hk.context = static_cast<Qt::ShortcutContext>(shortcut.shortcut.context);
-        }
-        if (!shortcut.shortcut.controller_keyseq.isEmpty()) {
-            hk.controller_keyseq = shortcut.shortcut.controller_keyseq;
+        if (!shortcut.shortcut.first.isEmpty()) {
+            hk.keyseq = QKeySequence::fromString(shortcut.shortcut.first, QKeySequence::NativeText);
+            hk.context = static_cast<Qt::ShortcutContext>(shortcut.shortcut.second);
         }
         if (hk.shortcut) {
             hk.shortcut->disconnect();
             hk.shortcut->setKey(hk.keyseq);
         }
-        if (hk.controller_shortcut) {
-            hk.controller_shortcut->disconnect();
-            hk.controller_shortcut->SetKey(hk.controller_keyseq);
-        }
     }
 }
 
 QShortcut* HotkeyRegistry::GetHotkey(const QString& group, const QString& action, QWidget* widget) {
     Hotkey& hk = hotkey_groups[group][action];
 
-    if (!hk.shortcut) {
+    if (!hk.shortcut)
         hk.shortcut = new QShortcut(hk.keyseq, widget, nullptr, nullptr, hk.context);
-    }
 
     hk.shortcut->setAutoRepeat(false);
 
     return hk.shortcut;
 }
 
-ControllerShortcut* HotkeyRegistry::GetControllerHotkey(const QString& group, const QString& action,
-                                                        Core::HID::EmulatedController* controller) {
-    Hotkey& hk = hotkey_groups[group][action];
-
-    if (!hk.controller_shortcut) {
-        hk.controller_shortcut = new ControllerShortcut(controller);
-        hk.controller_shortcut->SetKey(hk.controller_keyseq);
-    }
-
-    return hk.controller_shortcut;
-}
-
 QKeySequence HotkeyRegistry::GetKeySequence(const QString& group, const QString& action) {
     return hotkey_groups[group][action].keyseq;
 }
@@ -84,131 +59,3 @@ Qt::ShortcutContext HotkeyRegistry::GetShortcutContext(const QString& group,
                                                        const QString& action) {
     return hotkey_groups[group][action].context;
 }
-
-ControllerShortcut::ControllerShortcut(Core::HID::EmulatedController* controller) {
-    emulated_controller = controller;
-    Core::HID::ControllerUpdateCallback engine_callback{
-        .on_change = [this](Core::HID::ControllerTriggerType type) { ControllerUpdateEvent(type); },
-        .is_npad_service = false,
-    };
-    callback_key = emulated_controller->SetCallback(engine_callback);
-    is_enabled = true;
-}
-
-ControllerShortcut::~ControllerShortcut() {
-    emulated_controller->DeleteCallback(callback_key);
-}
-
-void ControllerShortcut::SetKey(const ControllerButtonSequence& buttons) {
-    button_sequence = buttons;
-}
-
-void ControllerShortcut::SetKey(const QString& buttons_shortcut) {
-    ControllerButtonSequence sequence{};
-    name = buttons_shortcut.toStdString();
-    std::istringstream command_line(buttons_shortcut.toStdString());
-    std::string line;
-    while (std::getline(command_line, line, '+')) {
-        if (line.empty()) {
-            continue;
-        }
-        if (line == "A") {
-            sequence.npad.a.Assign(1);
-        }
-        if (line == "B") {
-            sequence.npad.b.Assign(1);
-        }
-        if (line == "X") {
-            sequence.npad.x.Assign(1);
-        }
-        if (line == "Y") {
-            sequence.npad.y.Assign(1);
-        }
-        if (line == "L") {
-            sequence.npad.l.Assign(1);
-        }
-        if (line == "R") {
-            sequence.npad.r.Assign(1);
-        }
-        if (line == "ZL") {
-            sequence.npad.zl.Assign(1);
-        }
-        if (line == "ZR") {
-            sequence.npad.zr.Assign(1);
-        }
-        if (line == "Dpad_Left") {
-            sequence.npad.left.Assign(1);
-        }
-        if (line == "Dpad_Right") {
-            sequence.npad.right.Assign(1);
-        }
-        if (line == "Dpad_Up") {
-            sequence.npad.up.Assign(1);
-        }
-        if (line == "Dpad_Down") {
-            sequence.npad.down.Assign(1);
-        }
-        if (line == "Left_Stick") {
-            sequence.npad.stick_l.Assign(1);
-        }
-        if (line == "Right_Stick") {
-            sequence.npad.stick_r.Assign(1);
-        }
-        if (line == "Minus") {
-            sequence.npad.minus.Assign(1);
-        }
-        if (line == "Plus") {
-            sequence.npad.plus.Assign(1);
-        }
-        if (line == "Home") {
-            sequence.home.home.Assign(1);
-        }
-        if (line == "Screenshot") {
-            sequence.capture.capture.Assign(1);
-        }
-    }
-
-    button_sequence = sequence;
-}
-
-ControllerButtonSequence ControllerShortcut::ButtonSequence() const {
-    return button_sequence;
-}
-
-void ControllerShortcut::SetEnabled(bool enable) {
-    is_enabled = enable;
-}
-
-bool ControllerShortcut::IsEnabled() const {
-    return is_enabled;
-}
-
-void ControllerShortcut::ControllerUpdateEvent(Core::HID::ControllerTriggerType type) {
-    if (!is_enabled) {
-        return;
-    }
-    if (type != Core::HID::ControllerTriggerType::Button) {
-        return;
-    }
-    if (button_sequence.npad.raw == Core::HID::NpadButton::None &&
-        button_sequence.capture.raw == 0 && button_sequence.home.raw == 0) {
-        return;
-    }
-
-    const auto player_npad_buttons =
-        emulated_controller->GetNpadButtons().raw & button_sequence.npad.raw;
-    const u64 player_capture_buttons =
-        emulated_controller->GetCaptureButtons().raw & button_sequence.capture.raw;
-    const u64 player_home_buttons =
-        emulated_controller->GetHomeButtons().raw & button_sequence.home.raw;
-
-    if (player_npad_buttons == button_sequence.npad.raw &&
-        player_capture_buttons == button_sequence.capture.raw &&
-        player_home_buttons == button_sequence.home.raw && !active) {
-        // Force user to press the home or capture button again
-        active = true;
-        emit Activated();
-        return;
-    }
-    active = false;
-}

src/yuzu/hotkeys.h

@@ -5,53 +5,11 @@
 #pragma once
 
 #include <map>
-#include "core/hid/hid_types.h"
 
 class QDialog;
 class QKeySequence;
 class QSettings;
 class QShortcut;
-class ControllerShortcut;
-
-namespace Core::HID {
-enum class ControllerTriggerType;
-class EmulatedController;
-} // namespace Core::HID
-
-struct ControllerButtonSequence {
-    Core::HID::CaptureButtonState capture{};
-    Core::HID::HomeButtonState home{};
-    Core::HID::NpadButtonState npad{};
-};
-
-class ControllerShortcut : public QObject {
-    Q_OBJECT
-
-public:
-    explicit ControllerShortcut(Core::HID::EmulatedController* controller);
-    ~ControllerShortcut();
-
-    void SetKey(const ControllerButtonSequence& buttons);
-    void SetKey(const QString& buttons_shortcut);
-
-    ControllerButtonSequence ButtonSequence() const;
-
-    void SetEnabled(bool enable);
-    bool IsEnabled() const;
-
-Q_SIGNALS:
-    void Activated();
-
-private:
-    void ControllerUpdateEvent(Core::HID::ControllerTriggerType type);
-
-    bool is_enabled{};
-    bool active{};
-    int callback_key{};
-    ControllerButtonSequence button_sequence{};
-    std::string name{};
-    Core::HID::EmulatedController* emulated_controller = nullptr;
-};
 
 class HotkeyRegistry final {
 public:
@@ -88,8 +46,6 @@ public:
      *          QShortcut's parent.
      */
     QShortcut* GetHotkey(const QString& group, const QString& action, QWidget* widget);
-    ControllerShortcut* GetControllerHotkey(const QString& group, const QString& action,
-                                            Core::HID::EmulatedController* controller);
 
     /**
      * Returns a QKeySequence object whose signal can be connected to QAction::setShortcut.
@@ -112,9 +68,7 @@ public:
 private:
     struct Hotkey {
         QKeySequence keyseq;
-        QString controller_keyseq;
         QShortcut* shortcut = nullptr;
-        ControllerShortcut* controller_shortcut = nullptr;
         Qt::ShortcutContext context = Qt::WindowShortcut;
     };
 

src/yuzu/main.cpp

@@ -32,7 +32,6 @@
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/am/applets/applets.h"
-#include "yuzu/util/controller_navigation.h"
 
 // These are wrappers to avoid the calls to CreateDirectory and CreateFile because of the Windows
 // defines.
@@ -967,12 +966,6 @@ void GMainWindow::LinkActionShortcut(QAction* action, const QString& action_name
     action->setShortcutContext(hotkey_registry.GetShortcutContext(main_window, action_name));
 
     this->addAction(action);
-
-    auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
-    const auto* controller_hotkey =
-        hotkey_registry.GetControllerHotkey(main_window, action_name, controller);
-    connect(controller_hotkey, &ControllerShortcut::Activated, this,
-            [action] { action->trigger(); });
 }
 
 void GMainWindow::InitializeHotkeys() {
@@ -994,12 +987,8 @@ void GMainWindow::InitializeHotkeys() {
 
     static const QString main_window = QStringLiteral("Main Window");
     const auto connect_shortcut = [&]<typename Fn>(const QString& action_name, const Fn& function) {
-        const auto* hotkey = hotkey_registry.GetHotkey(main_window, action_name, this);
-        auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
-        const auto* controller_hotkey =
-            hotkey_registry.GetControllerHotkey(main_window, action_name, controller);
+        const QShortcut* hotkey = hotkey_registry.GetHotkey(main_window, action_name, this);
         connect(hotkey, &QShortcut::activated, this, function);
-        connect(controller_hotkey, &ControllerShortcut::Activated, this, function);
     };
 
     connect_shortcut(QStringLiteral("Exit Fullscreen"), [&] {
@@ -1176,7 +1165,8 @@ void GMainWindow::ConnectMenuEvents() {
     connect_menu(ui->action_Single_Window_Mode, &GMainWindow::ToggleWindowMode);
     connect_menu(ui->action_Display_Dock_Widget_Headers, &GMainWindow::OnDisplayTitleBars);
     connect_menu(ui->action_Show_Filter_Bar, &GMainWindow::OnToggleFilterBar);
-    connect_menu(ui->action_Show_Status_Bar, &GMainWindow::OnToggleStatusBar);
+
+    connect(ui->action_Show_Status_Bar, &QAction::triggered, statusBar(), &QStatusBar::setVisible);
 
     connect_menu(ui->action_Reset_Window_Size_720, &GMainWindow::ResetWindowSize720);
     connect_menu(ui->action_Reset_Window_Size_900, &GMainWindow::ResetWindowSize900);
@@ -2178,11 +2168,6 @@ void GMainWindow::OnGameListOpenPerGameProperties(const std::string& file) {
 }
 
 void GMainWindow::OnMenuLoadFile() {
-    if (is_load_file_select_active) {
-        return;
-    }
-
-    is_load_file_select_active = true;
     const QString extensions =
         QStringLiteral("*.")
             .append(GameList::supported_file_extensions.join(QStringLiteral(" *.")))
@@ -2192,7 +2177,6 @@ void GMainWindow::OnMenuLoadFile() {
                                     .arg(extensions);
     const QString filename = QFileDialog::getOpenFileName(
         this, tr("Load File"), UISettings::values.roms_path, file_filter);
-    is_load_file_select_active = false;
 
     if (filename.isEmpty()) {
         return;
@@ -2825,11 +2809,6 @@ void GMainWindow::OnTasStartStop() {
     if (!emulation_running) {
         return;
     }
-
-    // Disable system buttons to prevent TAS from executing a hotkey
-    auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
-    controller->ResetSystemButtons();
-
     input_subsystem->GetTas()->StartStop();
     OnTasStateChanged();
 }
@@ -2838,34 +2817,12 @@ void GMainWindow::OnTasRecord() {
     if (!emulation_running) {
         return;
     }
-    if (is_tas_recording_dialog_active) {
-        return;
-    }
-
-    // Disable system buttons to prevent TAS from recording a hotkey
-    auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
-    controller->ResetSystemButtons();
-
     const bool is_recording = input_subsystem->GetTas()->Record();
     if (!is_recording) {
-        is_tas_recording_dialog_active = true;
-        ControllerNavigation* controller_navigation =
-            new ControllerNavigation(system->HIDCore(), this);
-        // Use QMessageBox instead of question so we can link controller navigation
-        QMessageBox* box_dialog = new QMessageBox();
-        box_dialog->setWindowTitle(tr("TAS Recording"));
-        box_dialog->setText(tr("Overwrite file of player 1?"));
-        box_dialog->setStandardButtons(QMessageBox::Yes | QMessageBox::No);
-        box_dialog->setDefaultButton(QMessageBox::Yes);
-        connect(controller_navigation, &ControllerNavigation::TriggerKeyboardEvent,
-                [box_dialog](Qt::Key key) {
-                    QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, key, Qt::NoModifier);
-                    QCoreApplication::postEvent(box_dialog, event);
-                });
-        int res = box_dialog->exec();
-        controller_navigation->UnloadController();
+        const auto res =
+            QMessageBox::question(this, tr("TAS Recording"), tr("Overwrite file of player 1?"),
+                                  QMessageBox::Yes | QMessageBox::No);
         input_subsystem->GetTas()->SaveRecording(res == QMessageBox::Yes);
-        is_tas_recording_dialog_active = false;
     }
     OnTasStateChanged();
 }
@@ -2914,15 +2871,10 @@ void GMainWindow::OnLoadAmiibo() {
     if (emu_thread == nullptr || !emu_thread->IsRunning()) {
         return;
     }
-    if (is_amiibo_file_select_active) {
-        return;
-    }
 
-    is_amiibo_file_select_active = true;
     const QString extensions{QStringLiteral("*.bin")};
     const QString file_filter = tr("Amiibo File (%1);; All Files (*.*)").arg(extensions);
     const QString filename = QFileDialog::getOpenFileName(this, tr("Load Amiibo"), {}, file_filter);
-    is_amiibo_file_select_active = false;
 
     if (filename.isEmpty()) {
         return;
@@ -2982,10 +2934,6 @@ void GMainWindow::OnToggleFilterBar() {
     }
 }
 
-void GMainWindow::OnToggleStatusBar() {
-    statusBar()->setVisible(ui->action_Show_Status_Bar->isChecked());
-}
-
 void GMainWindow::OnCaptureScreenshot() {
     if (emu_thread == nullptr || !emu_thread->IsRunning()) {
         return;
@@ -3678,8 +3626,8 @@ int main(int argc, char* argv[]) {
     QCoreApplication::setApplicationName(QStringLiteral("yuzu"));
 
 #ifdef _WIN32
-    // Increases the maximum open file limit to 4096
-    _setmaxstdio(4096);
+    // Increases the maximum open file limit to 8192
+    _setmaxstdio(8192);
 #endif
 
 #ifdef __APPLE__

src/yuzu/main.h

@@ -186,9 +186,6 @@ public slots:
     void OnTasStateChanged();
 
 private:
-    /// Updates an action's shortcut and text to reflect an updated hotkey from the hotkey registry.
-    void LinkActionShortcut(QAction* action, const QString& action_name);
-
     void RegisterMetaTypes();
 
     void InitializeWidgets();
@@ -289,7 +286,6 @@ private slots:
     void OnOpenYuzuFolder();
     void OnAbout();
     void OnToggleFilterBar();
-    void OnToggleStatusBar();
     void OnDisplayTitleBars(bool);
     void InitializeHotkeys();
     void ToggleFullscreen();
@@ -307,6 +303,9 @@ private slots:
     void OnMouseActivity();
 
 private:
+    /// Updates an action's shortcut and text to reflect an updated hotkey from the hotkey registry.
+    void LinkActionShortcut(QAction* action, const QString& action_name);
+
     void RemoveBaseContent(u64 program_id, const QString& entry_type);
     void RemoveUpdateContent(u64 program_id, const QString& entry_type);
     void RemoveAddOnContent(u64 program_id, const QString& entry_type);
@@ -401,16 +400,6 @@ private:
 
     // Applets
     QtSoftwareKeyboardDialog* software_keyboard = nullptr;
-
-    // True if amiibo file select is visible
-    bool is_amiibo_file_select_active{};
-
-    // True if load file select is visible
-    bool is_load_file_select_active{};
-
-    // True if TAS recording dialog is visible
-    bool is_tas_recording_dialog_active{};
-
 #ifdef __linux__
     QDBusObjectPath wake_lock{};
 #endif

src/yuzu/uisettings.h

@@ -17,11 +17,7 @@
 
 namespace UISettings {
 
-struct ContextualShortcut {
-    QString keyseq;
-    QString controller_keyseq;
-    int context;
-};
+using ContextualShortcut = std::pair<QString, int>;
 
 struct Shortcut {
     QString name;