input_common: Add option to configure gyro threshold

externals/FidelityFX-FSR/ffx-fsr/ffx_fsr1.h

@@ -747,12 +747,12 @@ AF1 sharpness){
   // Immediate constants for peak range.
   AF2 peakC=AF2(1.0,-1.0*4.0);
   // Limiters, these need to be high precision RCPs.
-  AF1 hitMinR=min(mn4R,eR)*ARcpF1(AF1_(4.0)*mx4R);
-  AF1 hitMinG=min(mn4G,eG)*ARcpF1(AF1_(4.0)*mx4G);
-  AF1 hitMinB=min(mn4B,eB)*ARcpF1(AF1_(4.0)*mx4B);
-  AF1 hitMaxR=(peakC.x-max(mx4R,eR))*ARcpF1(AF1_(4.0)*mn4R+peakC.y);
-  AF1 hitMaxG=(peakC.x-max(mx4G,eG))*ARcpF1(AF1_(4.0)*mn4G+peakC.y);
-  AF1 hitMaxB=(peakC.x-max(mx4B,eB))*ARcpF1(AF1_(4.0)*mn4B+peakC.y);
+  AF1 hitMinR=mn4R*ARcpF1(AF1_(4.0)*mx4R);
+  AF1 hitMinG=mn4G*ARcpF1(AF1_(4.0)*mx4G);
+  AF1 hitMinB=mn4B*ARcpF1(AF1_(4.0)*mx4B);
+  AF1 hitMaxR=(peakC.x-mx4R)*ARcpF1(AF1_(4.0)*mn4R+peakC.y);
+  AF1 hitMaxG=(peakC.x-mx4G)*ARcpF1(AF1_(4.0)*mn4G+peakC.y);
+  AF1 hitMaxB=(peakC.x-mx4B)*ARcpF1(AF1_(4.0)*mn4B+peakC.y);
   AF1 lobeR=max(-hitMinR,hitMaxR);
   AF1 lobeG=max(-hitMinG,hitMaxG);
   AF1 lobeB=max(-hitMinB,hitMaxB);
@@ -845,12 +845,12 @@ AF1 sharpness){
   // Immediate constants for peak range.
   AH2 peakC=AH2(1.0,-1.0*4.0);
   // Limiters, these need to be high precision RCPs.
-  AH1 hitMinR=min(mn4R,eR)*ARcpH1(AH1_(4.0)*mx4R);
-  AH1 hitMinG=min(mn4G,eG)*ARcpH1(AH1_(4.0)*mx4G);
-  AH1 hitMinB=min(mn4B,eB)*ARcpH1(AH1_(4.0)*mx4B);
-  AH1 hitMaxR=(peakC.x-max(mx4R,eR))*ARcpH1(AH1_(4.0)*mn4R+peakC.y);
-  AH1 hitMaxG=(peakC.x-max(mx4G,eG))*ARcpH1(AH1_(4.0)*mn4G+peakC.y);
-  AH1 hitMaxB=(peakC.x-max(mx4B,eB))*ARcpH1(AH1_(4.0)*mn4B+peakC.y);
+  AH1 hitMinR=mn4R*ARcpH1(AH1_(4.0)*mx4R);
+  AH1 hitMinG=mn4G*ARcpH1(AH1_(4.0)*mx4G);
+  AH1 hitMinB=mn4B*ARcpH1(AH1_(4.0)*mx4B);
+  AH1 hitMaxR=(peakC.x-mx4R)*ARcpH1(AH1_(4.0)*mn4R+peakC.y);
+  AH1 hitMaxG=(peakC.x-mx4G)*ARcpH1(AH1_(4.0)*mn4G+peakC.y);
+  AH1 hitMaxB=(peakC.x-mx4B)*ARcpH1(AH1_(4.0)*mn4B+peakC.y);
   AH1 lobeR=max(-hitMinR,hitMaxR);
   AH1 lobeG=max(-hitMinG,hitMaxG);
   AH1 lobeB=max(-hitMinB,hitMaxB);
@@ -963,12 +963,12 @@ AF1 sharpness){
   // Immediate constants for peak range.
   AH2 peakC=AH2(1.0,-1.0*4.0);
   // Limiters, these need to be high precision RCPs.
-  AH2 hitMinR=min(mn4R,eR)*ARcpH2(AH2_(4.0)*mx4R);
-  AH2 hitMinG=min(mn4G,eG)*ARcpH2(AH2_(4.0)*mx4G);
-  AH2 hitMinB=min(mn4B,eB)*ARcpH2(AH2_(4.0)*mx4B);
-  AH2 hitMaxR=(peakC.x-max(mx4R,eR))*ARcpH2(AH2_(4.0)*mn4R+peakC.y);
-  AH2 hitMaxG=(peakC.x-max(mx4G,eG))*ARcpH2(AH2_(4.0)*mn4G+peakC.y);
-  AH2 hitMaxB=(peakC.x-max(mx4B,eB))*ARcpH2(AH2_(4.0)*mn4B+peakC.y);
+  AH2 hitMinR=mn4R*ARcpH2(AH2_(4.0)*mx4R);
+  AH2 hitMinG=mn4G*ARcpH2(AH2_(4.0)*mx4G);
+  AH2 hitMinB=mn4B*ARcpH2(AH2_(4.0)*mx4B);
+  AH2 hitMaxR=(peakC.x-mx4R)*ARcpH2(AH2_(4.0)*mn4R+peakC.y);
+  AH2 hitMaxG=(peakC.x-mx4G)*ARcpH2(AH2_(4.0)*mn4G+peakC.y);
+  AH2 hitMaxB=(peakC.x-mx4B)*ARcpH2(AH2_(4.0)*mn4B+peakC.y);
   AH2 lobeR=max(-hitMinR,hitMaxR);
   AH2 lobeG=max(-hitMinG,hitMaxG);
   AH2 lobeB=max(-hitMinB,hitMaxB);

src/common/settings.h

@@ -554,7 +554,6 @@ struct Values {
     Setting<bool> use_docked_mode{true, "use_docked_mode"};
 
     BasicSetting<bool> enable_raw_input{false, "enable_raw_input"};
-    BasicSetting<bool> controller_navigation{true, "controller_navigation"};
 
     Setting<bool> vibration_enabled{true, "vibration_enabled"};
     Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};

src/common/x64/xbyak_abi.h

@@ -37,12 +37,12 @@ constexpr Xbyak::Reg IndexToReg(size_t reg_index) {
     }
 }
 
-constexpr std::bitset<32> BuildRegSet(std::initializer_list<Xbyak::Reg> regs) {
-    size_t bits = 0;
+inline std::bitset<32> BuildRegSet(std::initializer_list<Xbyak::Reg> regs) {
+    std::bitset<32> bits;
     for (const Xbyak::Reg& reg : regs) {
-        bits |= size_t{1} << RegToIndex(reg);
+        bits[RegToIndex(reg)] = true;
     }
-    return {bits};
+    return bits;
 }
 
 constexpr inline std::bitset<32> ABI_ALL_GPRS(0x0000FFFF);
@@ -57,7 +57,7 @@ constexpr inline Xbyak::Reg ABI_PARAM2 = Xbyak::util::rdx;
 constexpr inline Xbyak::Reg ABI_PARAM3 = Xbyak::util::r8;
 constexpr inline Xbyak::Reg ABI_PARAM4 = Xbyak::util::r9;
 
-constexpr inline std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
+const std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
     // GPRs
     Xbyak::util::rcx,
     Xbyak::util::rdx,
@@ -74,7 +74,7 @@ constexpr inline std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
     Xbyak::util::xmm5,
 });
 
-constexpr inline std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
+const std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
     // GPRs
     Xbyak::util::rbx,
     Xbyak::util::rsi,
@@ -108,7 +108,7 @@ constexpr inline Xbyak::Reg ABI_PARAM2 = Xbyak::util::rsi;
 constexpr inline Xbyak::Reg ABI_PARAM3 = Xbyak::util::rdx;
 constexpr inline Xbyak::Reg ABI_PARAM4 = Xbyak::util::rcx;
 
-constexpr inline std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
+const std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
     // GPRs
     Xbyak::util::rcx,
     Xbyak::util::rdx,
@@ -137,7 +137,7 @@ constexpr inline std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
     Xbyak::util::xmm15,
 });
 
-constexpr inline std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
+const std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
     // GPRs
     Xbyak::util::rbx,
     Xbyak::util::rbp,

src/core/hid/emulated_controller.cpp

@@ -749,6 +749,7 @@ void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback
         raw_status.gyro.y.value,
         raw_status.gyro.z.value,
     });
+    emulated.SetGyroThreshold(raw_status.gyro.x.properties.threshold);
     emulated.UpdateRotation(raw_status.delta_timestamp);
     emulated.UpdateOrientation(raw_status.delta_timestamp);
     force_update_motion = raw_status.force_update;

src/core/hid/motion_input.cpp

@@ -10,7 +10,7 @@ namespace Core::HID {
 MotionInput::MotionInput() {
     // Initialize PID constants with default values
     SetPID(0.3f, 0.005f, 0.0f);
-    SetGyroThreshold(0.00005f);
+    SetGyroThreshold(0.007f);
 }
 
 void MotionInput::SetPID(f32 new_kp, f32 new_ki, f32 new_kd) {
@@ -31,7 +31,7 @@ void MotionInput::SetGyroscope(const Common::Vec3f& gyroscope) {
         gyro_bias = (gyro_bias * 0.9999f) + (gyroscope * 0.0001f);
     }
 
-    if (gyro.Length2() < gyro_threshold) {
+    if (gyro.Length() < gyro_threshold) {
         gyro = {};
     } else {
         only_accelerometer = false;

src/core/hle/kernel/k_affinity_mask.h

@@ -31,6 +31,8 @@ public:
     }
 
     constexpr void SetAffinity(s32 core, bool set) {
+        ASSERT(0 <= core && core < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
+
         if (set) {
             this->mask |= GetCoreBit(core);
         } else {

src/core/hle/kernel/k_page_table.cpp

@@ -276,23 +276,22 @@ ResultCode KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_
 
 ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemoryState state,
                                       KMemoryPermission perm) {
-    const u64 size{num_pages * PageSize};
-
-    // Validate the mapping request.
-    R_UNLESS(this->CanContain(addr, size, state), ResultInvalidCurrentMemory);
-
-    // Lock the table.
     std::lock_guard lock{page_table_lock};
 
-    // Verify that the destination memory is unmapped.
-    R_TRY(this->CheckMemoryState(addr, size, KMemoryState::All, KMemoryState::Free,
-                                 KMemoryPermission::None, KMemoryPermission::None,
-                                 KMemoryAttribute::None, KMemoryAttribute::None));
+    const u64 size{num_pages * PageSize};
+
+    if (!CanContain(addr, size, state)) {
+        return ResultInvalidCurrentMemory;
+    }
+
+    if (IsRegionMapped(addr, size)) {
+        return ResultInvalidCurrentMemory;
+    }
 
     KPageLinkedList page_linked_list;
-    R_TRY(system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool,
-                                                   allocation_option));
-    R_TRY(Operate(addr, num_pages, page_linked_list, OperationType::MapGroup));
+    CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool,
+                                                          allocation_option));
+    CASCADE_CODE(Operate(addr, num_pages, page_linked_list, OperationType::MapGroup));
 
     block_manager->Update(addr, num_pages, state, perm);
 
@@ -396,12 +395,39 @@ ResultCode KPageTable::UnmapProcessMemory(VAddr dst_addr, std::size_t size,
 
     return ResultSuccess;
 }
+void KPageTable::MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start, VAddr end) {
+    auto node{page_linked_list.Nodes().begin()};
+    PAddr map_addr{node->GetAddress()};
+    std::size_t src_num_pages{node->GetNumPages()};
+
+    block_manager->IterateForRange(start, end, [&](const KMemoryInfo& info) {
+        if (info.state != KMemoryState::Free) {
+            return;
+        }
+
+        std::size_t dst_num_pages{GetSizeInRange(info, start, end) / PageSize};
+        VAddr dst_addr{GetAddressInRange(info, start)};
+
+        while (dst_num_pages) {
+            if (!src_num_pages) {
+                node = std::next(node);
+                map_addr = node->GetAddress();
+                src_num_pages = node->GetNumPages();
+            }
+
+            const std::size_t num_pages{std::min(src_num_pages, dst_num_pages)};
+            Operate(dst_addr, num_pages, KMemoryPermission::UserReadWrite, OperationType::Map,
+                    map_addr);
+
+            dst_addr += num_pages * PageSize;
+            map_addr += num_pages * PageSize;
+            src_num_pages -= num_pages;
+            dst_num_pages -= num_pages;
+        }
+    });
+}
 
 ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
-    // Lock the physical memory lock.
-    std::lock_guard phys_lk(map_physical_memory_lock);
-
-    // Lock the table.
     std::lock_guard lock{page_table_lock};
 
     std::size_t mapped_size{};
@@ -437,35 +463,7 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
     // We succeeded, so commit the memory reservation.
     memory_reservation.Commit();
 
-    // Map the memory.
-    auto node{page_linked_list.Nodes().begin()};
-    PAddr map_addr{node->GetAddress()};
-    std::size_t src_num_pages{node->GetNumPages()};
-    block_manager->IterateForRange(addr, end_addr, [&](const KMemoryInfo& info) {
-        if (info.state != KMemoryState::Free) {
-            return;
-        }
-
-        std::size_t dst_num_pages{GetSizeInRange(info, addr, end_addr) / PageSize};
-        VAddr dst_addr{GetAddressInRange(info, addr)};
-
-        while (dst_num_pages) {
-            if (!src_num_pages) {
-                node = std::next(node);
-                map_addr = node->GetAddress();
-                src_num_pages = node->GetNumPages();
-            }
-
-            const std::size_t num_pages{std::min(src_num_pages, dst_num_pages)};
-            Operate(dst_addr, num_pages, KMemoryPermission::UserReadWrite, OperationType::Map,
-                    map_addr);
-
-            dst_addr += num_pages * PageSize;
-            map_addr += num_pages * PageSize;
-            src_num_pages -= num_pages;
-            dst_num_pages -= num_pages;
-        }
-    });
+    MapPhysicalMemory(page_linked_list, addr, end_addr);
 
     mapped_physical_memory_size += remaining_size;
 
@@ -505,8 +503,23 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
         return ResultSuccess;
     }
 
-    // Unmap each region within the range
+    CASCADE_CODE(UnmapMemory(addr, size));
+
+    auto process{system.Kernel().CurrentProcess()};
+    process->GetResourceLimit()->Release(LimitableResource::PhysicalMemory, mapped_size);
+    mapped_physical_memory_size -= mapped_size;
+
+    return ResultSuccess;
+}
+
+ResultCode KPageTable::UnmapMemory(VAddr addr, std::size_t size) {
+    std::lock_guard lock{page_table_lock};
+
+    const VAddr end_addr{addr + size};
+    ResultCode result{ResultSuccess};
     KPageLinkedList page_linked_list;
+
+    // Unmap each region within the range
     block_manager->IterateForRange(addr, end_addr, [&](const KMemoryInfo& info) {
         if (info.state == KMemoryState::Normal) {
             const std::size_t block_size{GetSizeInRange(info, addr, end_addr)};
@@ -522,6 +535,7 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
             }
         }
     });
+
     if (result.IsError()) {
         return result;
     }
@@ -532,14 +546,10 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
 
     block_manager->Update(addr, num_pages, KMemoryState::Free);
 
-    auto process{system.Kernel().CurrentProcess()};
-    process->GetResourceLimit()->Release(LimitableResource::PhysicalMemory, mapped_size);
-    mapped_physical_memory_size -= mapped_size;
-
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryState src_state{};
@@ -578,7 +588,7 @@ ResultCode KPageTable::MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t siz
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryState src_state{};
@@ -642,26 +652,24 @@ ResultCode KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_l
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapPages(VAddr address, KPageLinkedList& page_linked_list,
-                                KMemoryState state, KMemoryPermission perm) {
-    // Check that the map is in range.
-    const std::size_t num_pages{page_linked_list.GetNumPages()};
-    const std::size_t size{num_pages * PageSize};
-    R_UNLESS(this->CanContain(address, size, state), ResultInvalidCurrentMemory);
-
-    // Lock the table.
+ResultCode KPageTable::MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
+                                KMemoryPermission perm) {
     std::lock_guard lock{page_table_lock};
 
-    // Check the memory state.
-    R_TRY(this->CheckMemoryState(address, size, KMemoryState::All, KMemoryState::Free,
-                                 KMemoryPermission::None, KMemoryPermission::None,
-                                 KMemoryAttribute::None, KMemoryAttribute::None));
+    const std::size_t num_pages{page_linked_list.GetNumPages()};
+    const std::size_t size{num_pages * PageSize};
 
-    // Map the pages.
-    R_TRY(MapPages(address, page_linked_list, perm));
+    if (!CanContain(addr, size, state)) {
+        return ResultInvalidCurrentMemory;
+    }
 
-    // Update the blocks.
-    block_manager->Update(address, num_pages, state, perm);
+    if (IsRegionMapped(addr, num_pages * PageSize)) {
+        return ResultInvalidCurrentMemory;
+    }
+
+    CASCADE_CODE(MapPages(addr, page_linked_list, perm));
+
+    block_manager->Update(addr, num_pages, state, perm);
 
     return ResultSuccess;
 }
@@ -685,23 +693,21 @@ ResultCode KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked
 
 ResultCode KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list,
                                   KMemoryState state) {
-    // Check that the unmap is in range.
-    const std::size_t num_pages{page_linked_list.GetNumPages()};
-    const std::size_t size{num_pages * PageSize};
-    R_UNLESS(this->Contains(addr, size), ResultInvalidCurrentMemory);
-
-    // Lock the table.
     std::lock_guard lock{page_table_lock};
 
-    // Check the memory state.
-    R_TRY(this->CheckMemoryState(addr, size, KMemoryState::All, state, KMemoryPermission::None,
-                                 KMemoryPermission::None, KMemoryAttribute::All,
-                                 KMemoryAttribute::None));
+    const std::size_t num_pages{page_linked_list.GetNumPages()};
+    const std::size_t size{num_pages * PageSize};
 
-    // Perform the unmap.
-    R_TRY(UnmapPages(addr, page_linked_list));
+    if (!CanContain(addr, size, state)) {
+        return ResultInvalidCurrentMemory;
+    }
+
+    if (IsRegionMapped(addr, num_pages * PageSize)) {
+        return ResultInvalidCurrentMemory;
+    }
+
+    CASCADE_CODE(UnmapPages(addr, page_linked_list));
 
-    // Update the blocks.
     block_manager->Update(addr, num_pages, state, KMemoryPermission::None);
 
     return ResultSuccess;
@@ -759,6 +765,7 @@ ResultCode KPageTable::SetProcessMemoryPermission(VAddr addr, std::size_t size,
 
     // Ensure cache coherency, if we're setting pages as executable.
     if (is_x) {
+        // Memory execution state is changing, invalidate CPU cache range
         system.InvalidateCpuInstructionCacheRange(addr, size);
     }
 
@@ -786,12 +793,12 @@ ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemo
     KMemoryState state{};
     KMemoryAttribute attribute{};
 
-    R_TRY(CheckMemoryState(&state, nullptr, &attribute, nullptr, addr, size,
-                           KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
-                           KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
-                           KMemoryPermission::All, KMemoryPermission::UserReadWrite,
-                           KMemoryAttribute::Mask, KMemoryAttribute::None,
-                           KMemoryAttribute::IpcAndDeviceMapped));
+    CASCADE_CODE(CheckMemoryState(
+        &state, nullptr, &attribute, nullptr, addr, size,
+        KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
+        KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, KMemoryPermission::All,
+        KMemoryPermission::UserReadWrite, KMemoryAttribute::Mask, KMemoryAttribute::None,
+        KMemoryAttribute::IpcAndDeviceMapped));
 
     block_manager->Update(addr, size / PageSize, state, perm, attribute | KMemoryAttribute::Locked);
 
@@ -803,11 +810,12 @@ ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
 
     KMemoryState state{};
 
-    R_TRY(CheckMemoryState(&state, nullptr, nullptr, nullptr, addr, size,
-                           KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
-                           KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
-                           KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::Mask,
-                           KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped));
+    CASCADE_CODE(
+        CheckMemoryState(&state, nullptr, nullptr, nullptr, addr, size,
+                         KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
+                         KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
+                         KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::Mask,
+                         KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped));
 
     block_manager->Update(addr, size / PageSize, state, KMemoryPermission::UserReadWrite);
     return ResultSuccess;
@@ -863,9 +871,8 @@ ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask
         AttributeTestMask, KMemoryAttribute::None, ~AttributeTestMask));
 
     // Determine the new attribute.
-    const KMemoryAttribute new_attr =
-        static_cast<KMemoryAttribute>(((old_attr & static_cast<KMemoryAttribute>(~mask)) |
-                                       static_cast<KMemoryAttribute>(attr & mask)));
+    const auto new_attr = ((old_attr & static_cast<KMemoryAttribute>(~mask)) |
+                           static_cast<KMemoryAttribute>(attr & mask));
 
     // Perform operation.
     this->Operate(addr, num_pages, old_perm, OperationType::ChangePermissionsAndRefresh);
@@ -889,9 +896,6 @@ ResultCode KPageTable::SetMaxHeapSize(std::size_t size) {
 }
 
 ResultCode KPageTable::SetHeapSize(VAddr* out, std::size_t size) {
-    // Lock the physical memory lock.
-    std::lock_guard phys_lk(map_physical_memory_lock);
-
     // Try to perform a reduction in heap, instead of an extension.
     VAddr cur_address{};
     std::size_t allocation_size{};
@@ -1021,12 +1025,12 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages,
     }
 
     if (is_map_only) {
-        R_TRY(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
+        CASCADE_CODE(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
     } else {
         KPageLinkedList page_group;
-        R_TRY(system.Kernel().MemoryManager().Allocate(page_group, needed_num_pages, memory_pool,
-                                                       allocation_option));
-        R_TRY(Operate(addr, needed_num_pages, page_group, OperationType::MapGroup));
+        CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_group, needed_num_pages,
+                                                              memory_pool, allocation_option));
+        CASCADE_CODE(Operate(addr, needed_num_pages, page_group, OperationType::MapGroup));
     }
 
     block_manager->Update(addr, needed_num_pages, state, perm);
@@ -1182,7 +1186,7 @@ VAddr KPageTable::AllocateVirtualMemory(VAddr start, std::size_t region_num_page
 
 ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
                                OperationType operation) {
-    ASSERT(this->IsLockedByCurrentThread());
+    std::lock_guard lock{page_table_lock};
 
     ASSERT(Common::IsAligned(addr, PageSize));
     ASSERT(num_pages > 0);
@@ -1207,7 +1211,7 @@ ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLin
 
 ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
                                OperationType operation, PAddr map_addr) {
-    ASSERT(this->IsLockedByCurrentThread());
+    std::lock_guard lock{page_table_lock};
 
     ASSERT(num_pages > 0);
     ASSERT(Common::IsAligned(addr, PageSize));

src/core/hle/kernel/k_page_table.h

@@ -37,8 +37,9 @@ public:
                                   VAddr src_addr);
     ResultCode MapPhysicalMemory(VAddr addr, std::size_t size);
     ResultCode UnmapPhysicalMemory(VAddr addr, std::size_t size);
-    ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
+    ResultCode UnmapMemory(VAddr addr, std::size_t size);
+    ResultCode Map(VAddr dst_addr, VAddr src_addr, std::size_t size);
+    ResultCode Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size);
     ResultCode MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
                         KMemoryPermission perm);
     ResultCode UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state);
@@ -87,6 +88,7 @@ private:
     ResultCode MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
                         KMemoryPermission perm);
     ResultCode UnmapPages(VAddr addr, const KPageLinkedList& page_linked_list);
+    void MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start, VAddr end);
     bool IsRegionMapped(VAddr address, u64 size);
     bool IsRegionContiguous(VAddr addr, u64 size) const;
     void AddRegionToPages(VAddr start, std::size_t num_pages, KPageLinkedList& page_linked_list);
@@ -146,7 +148,6 @@ private:
     }
 
     std::recursive_mutex page_table_lock;
-    std::mutex map_physical_memory_lock;
     std::unique_ptr<KMemoryBlockManager> block_manager;
 
 public:
@@ -248,9 +249,7 @@ public:
         return !IsOutsideASLRRegion(address, size);
     }
     constexpr PAddr GetPhysicalAddr(VAddr addr) {
-        const auto backing_addr = page_table_impl.backing_addr[addr >> PageBits];
-        ASSERT(backing_addr);
-        return backing_addr + addr;
+        return page_table_impl.backing_addr[addr >> PageBits] + addr;
     }
     constexpr bool Contains(VAddr addr) const {
         return address_space_start <= addr && addr <= address_space_end - 1;

src/core/hle/kernel/k_process.cpp

@@ -146,13 +146,6 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st
     // Open a reference to the resource limit.
     process->resource_limit->Open();
 
-    // Clear remaining fields.
-    process->num_running_threads = 0;
-    process->is_signaled = false;
-    process->exception_thread = nullptr;
-    process->is_suspended = false;
-    process->schedule_count = 0;
-
     return ResultSuccess;
 }
 
@@ -164,17 +157,20 @@ KResourceLimit* KProcess::GetResourceLimit() const {
     return resource_limit;
 }
 
-void KProcess::IncrementRunningThreadCount() {
-    ASSERT(num_running_threads.load() >= 0);
-    ++num_running_threads;
+void KProcess::IncrementThreadCount() {
+    ASSERT(num_threads >= 0);
+    num_created_threads++;
+
+    if (const auto count = ++num_threads; count > peak_num_threads) {
+        peak_num_threads = count;
+    }
 }
 
-void KProcess::DecrementRunningThreadCount() {
-    ASSERT(num_running_threads.load() > 0);
+void KProcess::DecrementThreadCount() {
+    ASSERT(num_threads > 0);
 
-    if (const auto prev = num_running_threads--; prev == 1) {
-        // TODO(bunnei): Process termination to be implemented when multiprocess is supported.
-        UNIMPLEMENTED_MSG("KProcess termination is not implemennted!");
+    if (const auto count = --num_threads; count == 0) {
+        LOG_WARNING(Kernel, "Process termination is not fully implemented.");
     }
 }
 

src/core/hle/kernel/k_process.h

@@ -235,8 +235,8 @@ public:
         ++schedule_count;
     }
 
-    void IncrementRunningThreadCount();
-    void DecrementRunningThreadCount();
+    void IncrementThreadCount();
+    void DecrementThreadCount();
 
     void SetRunningThread(s32 core, KThread* thread, u64 idle_count) {
         running_threads[core] = thread;
@@ -473,7 +473,9 @@ private:
     bool is_suspended{};
     bool is_initialized{};
 
-    std::atomic<u16> num_running_threads{};
+    std::atomic<s32> num_created_threads{};
+    std::atomic<u16> num_threads{};
+    u16 peak_num_threads{};
 
     std::array<KThread*, Core::Hardware::NUM_CPU_CORES> running_threads{};
     std::array<u64, Core::Hardware::NUM_CPU_CORES> running_thread_idle_counts{};

src/core/hle/kernel/k_thread.cpp

@@ -215,6 +215,7 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s
 
         parent = owner;
         parent->Open();
+        parent->IncrementThreadCount();
     }
 
     // Initialize thread context.
@@ -326,6 +327,11 @@ void KThread::Finalize() {
         }
     }
 
+    // Decrement the parent process's thread count.
+    if (parent != nullptr) {
+        parent->DecrementThreadCount();
+    }
+
     // Perform inherited finalization.
     KSynchronizationObject::Finalize();
 }
@@ -1005,7 +1011,7 @@ ResultCode KThread::Run() {
             if (IsUserThread() && IsSuspended()) {
                 this->UpdateState();
             }
-            owner->IncrementRunningThreadCount();
+            owner->IncrementThreadCount();
         }
 
         // Set our state and finish.
@@ -1020,11 +1026,10 @@ ResultCode KThread::Run() {
 void KThread::Exit() {
     ASSERT(this == GetCurrentThreadPointer(kernel));
 
-    // Release the thread resource hint, running thread count from parent.
+    // Release the thread resource hint from parent.
     if (parent != nullptr) {
         parent->GetResourceLimit()->Release(Kernel::LimitableResource::Threads, 0, 1);
         resource_limit_release_hint = true;
-        parent->DecrementRunningThreadCount();
     }
 
     // Perform termination.

src/core/hle/kernel/svc.cpp

@@ -230,7 +230,7 @@ static ResultCode MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr
         return result;
     }
 
-    return page_table.MapMemory(dst_addr, src_addr, size);
+    return page_table.Map(dst_addr, src_addr, size);
 }
 
 static ResultCode MapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
@@ -249,7 +249,7 @@ static ResultCode UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_ad
         return result;
     }
 
-    return page_table.UnmapMemory(dst_addr, src_addr, size);
+    return page_table.Unmap(dst_addr, src_addr, size);
 }
 
 static ResultCode UnmapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {

src/input_common/drivers/udp_client.cpp

@@ -339,7 +339,7 @@ void UDPClient::StartCommunication(std::size_t client, const std::string& host,
     }
 }
 
-PadIdentifier UDPClient::GetPadIdentifier(std::size_t pad_index) const {
+const PadIdentifier UDPClient::GetPadIdentifier(std::size_t pad_index) const {
     const std::size_t client = pad_index / PADS_PER_CLIENT;
     return {
         .guid = clients[client].uuid,
@@ -348,9 +348,9 @@ PadIdentifier UDPClient::GetPadIdentifier(std::size_t pad_index) const {
     };
 }
 
-Common::UUID UDPClient::GetHostUUID(const std::string& host) const {
-    const auto ip = boost::asio::ip::make_address_v4(host);
-    const auto hex_host = fmt::format("{:06x}", ip.to_uint());
+const Common::UUID UDPClient::GetHostUUID(const std::string host) const {
+    const auto ip = boost::asio::ip::address_v4::from_string(host);
+    const auto hex_host = fmt::format("{:06x}", ip.to_ulong());
     return Common::UUID{hex_host};
 }
 

src/input_common/drivers/udp_client.h

@@ -145,8 +145,8 @@ private:
     void OnPortInfo(Response::PortInfo);
     void OnPadData(Response::PadData, std::size_t client);
     void StartCommunication(std::size_t client, const std::string& host, u16 port);
-    PadIdentifier GetPadIdentifier(std::size_t pad_index) const;
-    Common::UUID GetHostUUID(const std::string& host) const;
+    const PadIdentifier GetPadIdentifier(std::size_t pad_index) const;
+    const Common::UUID GetHostUUID(const std::string host) const;
 
     Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
 

src/input_common/input_engine.h

@@ -16,7 +16,7 @@
 
 // Pad Identifier of data source
 struct PadIdentifier {
-    Common::UUID guid{Common::INVALID_UUID};
+    Common::UUID guid{};
     std::size_t port{};
     std::size_t pad{};
 
@@ -89,7 +89,7 @@ struct UpdateCallback {
 
 // Triggered if data changed on the controller and the engine is on configuring mode
 struct MappingCallback {
-    std::function<void(const MappingData&)> on_data;
+    std::function<void(MappingData)> on_data;
 };
 
 // Input Identifier of data source

src/input_common/input_mapping.cpp

@@ -2,13 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included
 
+#include "common/common_types.h"
 #include "common/settings.h"
 #include "input_common/input_engine.h"
 #include "input_common/input_mapping.h"
 
 namespace InputCommon {
 
-MappingFactory::MappingFactory() = default;
+MappingFactory::MappingFactory() {}
 
 void MappingFactory::BeginMapping(Polling::InputType type) {
     is_enabled = true;
@@ -18,7 +19,7 @@ void MappingFactory::BeginMapping(Polling::InputType type) {
     second_axis = -1;
 }
 
-Common::ParamPackage MappingFactory::GetNextInput() {
+[[nodiscard]] const Common::ParamPackage MappingFactory::GetNextInput() {
     Common::ParamPackage input;
     input_queue.Pop(input);
     return input;
@@ -56,7 +57,7 @@ void MappingFactory::StopMapping() {
 void MappingFactory::RegisterButton(const MappingData& data) {
     Common::ParamPackage new_input;
     new_input.Set("engine", data.engine);
-    if (data.pad.guid.IsValid()) {
+    if (data.pad.guid != Common::UUID{}) {
         new_input.Set("guid", data.pad.guid.Format());
     }
     new_input.Set("port", static_cast<int>(data.pad.port));
@@ -92,7 +93,7 @@ void MappingFactory::RegisterButton(const MappingData& data) {
 void MappingFactory::RegisterStick(const MappingData& data) {
     Common::ParamPackage new_input;
     new_input.Set("engine", data.engine);
-    if (data.pad.guid.IsValid()) {
+    if (data.pad.guid != Common::UUID{}) {
         new_input.Set("guid", data.pad.guid.Format());
     }
     new_input.Set("port", static_cast<int>(data.pad.port));
@@ -137,7 +138,7 @@ void MappingFactory::RegisterStick(const MappingData& data) {
 void MappingFactory::RegisterMotion(const MappingData& data) {
     Common::ParamPackage new_input;
     new_input.Set("engine", data.engine);
-    if (data.pad.guid.IsValid()) {
+    if (data.pad.guid != Common::UUID{}) {
         new_input.Set("guid", data.pad.guid.Format());
     }
     new_input.Set("port", static_cast<int>(data.pad.port));

src/input_common/input_mapping.h

@@ -3,14 +3,8 @@
 // Refer to the license.txt file included
 
 #pragma once
-
-#include "common/param_package.h"
 #include "common/threadsafe_queue.h"
 
-namespace InputCommon::Polling {
-enum class InputType;
-}
-
 namespace InputCommon {
 class InputEngine;
 struct MappingData;
@@ -26,7 +20,7 @@ public:
     void BeginMapping(Polling::InputType type);
 
     /// Returns an input event with mapping information from the input_queue
-    [[nodiscard]] Common::ParamPackage GetNextInput();
+    [[nodiscard]] const Common::ParamPackage GetNextInput();
 
     /**
      * Registers mapping input data from the driver

src/input_common/input_poller.cpp

@@ -504,9 +504,10 @@ private:
 
 class InputFromMotion final : public Common::Input::InputDevice {
 public:
-    explicit InputFromMotion(PadIdentifier identifier_, int motion_sensor_,
+    explicit InputFromMotion(PadIdentifier identifier_, int motion_sensor_, float gyro_threshold_,
                              InputEngine* input_engine_)
-        : identifier(identifier_), motion_sensor(motion_sensor_), input_engine(input_engine_) {
+        : identifier(identifier_), motion_sensor(motion_sensor_), gyro_threshold(gyro_threshold_),
+          input_engine(input_engine_) {
         UpdateCallback engine_callback{[this]() { OnChange(); }};
         const InputIdentifier input_identifier{
             .identifier = identifier,
@@ -525,8 +526,9 @@ public:
         const auto basic_motion = input_engine->GetMotion(identifier, motion_sensor);
         Common::Input::MotionStatus status{};
         const Common::Input::AnalogProperties properties = {
-            .deadzone = 0.001f,
+            .deadzone = 0.0f,
             .range = 1.0f,
+            .threshold = gyro_threshold,
             .offset = 0.0f,
         };
         status.accel.x = {.raw_value = basic_motion.accel_x, .properties = properties};
@@ -551,6 +553,7 @@ public:
 private:
     const PadIdentifier identifier;
     const int motion_sensor;
+    const float gyro_threshold;
     int callback_key;
     InputEngine* input_engine;
 };
@@ -873,9 +876,11 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
 
     if (params.Has("motion")) {
         const auto motion_sensor = params.Get("motion", 0);
+        const auto gyro_threshold = params.Get("threshold", 0.007f);
         input_engine->PreSetController(identifier);
         input_engine->PreSetMotion(identifier, motion_sensor);
-        return std::make_unique<InputFromMotion>(identifier, motion_sensor, input_engine.get());
+        return std::make_unique<InputFromMotion>(identifier, motion_sensor, gyro_threshold,
+                                                 input_engine.get());
     }
 
     const auto deadzone = std::clamp(params.Get("deadzone", 0.15f), 0.0f, 1.0f);

src/input_common/main.cpp

@@ -27,7 +27,7 @@ namespace InputCommon {
 struct InputSubsystem::Impl {
     void Initialize() {
         mapping_factory = std::make_shared<MappingFactory>();
-        MappingCallback mapping_callback{[this](const MappingData& data) { RegisterInput(data); }};
+        MappingCallback mapping_callback{[this](MappingData data) { RegisterInput(data); }};
 
         keyboard = std::make_shared<Keyboard>("keyboard");
         keyboard->SetMappingCallback(mapping_callback);
@@ -284,7 +284,7 @@ struct InputSubsystem::Impl {
 #endif
     }
 
-    void RegisterInput(const MappingData& data) {
+    void RegisterInput(MappingData data) {
         mapping_factory->RegisterInput(data);
     }
 
@@ -394,7 +394,7 @@ void InputSubsystem::BeginMapping(Polling::InputType type) {
     impl->mapping_factory->BeginMapping(type);
 }
 
-Common::ParamPackage InputSubsystem::GetNextInput() const {
+const Common::ParamPackage InputSubsystem::GetNextInput() const {
     return impl->mapping_factory->GetNextInput();
 }
 

src/input_common/main.h

@@ -126,7 +126,7 @@ public:
     void BeginMapping(Polling::InputType type);
 
     /// Returns an input event with mapping information.
-    [[nodiscard]] Common::ParamPackage GetNextInput() const;
+    [[nodiscard]] const Common::ParamPackage GetNextInput() const;
 
     /// Stop polling from all backends.
     void StopMapping() const;

src/shader_recompiler/frontend/maxwell/translate_program.h

@@ -21,6 +21,7 @@ namespace Shader::Maxwell {
 [[nodiscard]] IR::Program MergeDualVertexPrograms(IR::Program& vertex_a, IR::Program& vertex_b,
                                                   Environment& env_vertex_b);
 
-void ConvertLegacyToGeneric(IR::Program& program, const RuntimeInfo& runtime_info);
+[[nodiscard]] void ConvertLegacyToGeneric(IR::Program& program,
+                                          const Shader::RuntimeInfo& runtime_info);
 
 } // namespace Shader::Maxwell

src/video_core/buffer_cache/buffer_cache.h

@@ -1474,8 +1474,6 @@ typename BufferCache<P>::OverlapResult BufferCache<P>::ResolveOverlaps(VAddr cpu
             // When this memory region has been joined a bunch of times, we assume it's being used
             // as a stream buffer. Increase the size to skip constantly recreating buffers.
             has_stream_leap = true;
-            begin -= PAGE_SIZE * 256;
-            cpu_addr = begin;
             end += PAGE_SIZE * 256;
         }
     }

src/video_core/engines/maxwell_3d.cpp

@@ -240,7 +240,7 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
         ((method - MacroRegistersStart) >> 1) % static_cast<u32>(macro_positions.size());
 
     // Execute the current macro.
-    macro_engine->Execute(macro_positions[entry], parameters);
+    macro_engine->Execute(*this, macro_positions[entry], parameters);
     if (mme_draw.current_mode != MMEDrawMode::Undefined) {
         FlushMMEInlineDraw();
     }

src/video_core/gpu.h

@@ -12,6 +12,9 @@
 #include "video_core/framebuffer_config.h"
 
 namespace Core {
+namespace Frontend {
+class EmuWindow;
+}
 class System;
 } // namespace Core
 
@@ -22,6 +25,7 @@ class ShaderNotify;
 
 namespace Tegra {
 class DmaPusher;
+class CDmaPusher;
 struct CommandList;
 
 enum class RenderTargetFormat : u32 {
@@ -84,9 +88,15 @@ enum class DepthFormat : u32 {
     D32_FLOAT_S8X24_UINT = 0x19,
 };
 
+struct CommandListHeader;
+class DebugContext;
+
 namespace Engines {
+class Fermi2D;
 class Maxwell3D;
+class MaxwellDMA;
 class KeplerCompute;
+class KeplerMemory;
 } // namespace Engines
 
 enum class EngineID {
@@ -180,6 +190,12 @@ public:
     /// Returns a const reference to the GPU DMA pusher.
     [[nodiscard]] const Tegra::DmaPusher& DmaPusher() const;
 
+    /// Returns a reference to the GPU CDMA pusher.
+    [[nodiscard]] Tegra::CDmaPusher& CDmaPusher();
+
+    /// Returns a const reference to the GPU CDMA pusher.
+    [[nodiscard]] const Tegra::CDmaPusher& CDmaPusher() const;
+
     /// Returns a reference to the underlying renderer.
     [[nodiscard]] VideoCore::RendererBase& Renderer();
 

src/video_core/macro/macro.cpp

@@ -2,13 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
 #include <optional>
-
 #include <boost/container_hash/hash.hpp>
-
 #include "common/assert.h"
+#include "common/logging/log.h"
 #include "common/settings.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/macro/macro.h"
 #include "video_core/macro/macro_hle.h"
 #include "video_core/macro/macro_interpreter.h"
@@ -25,7 +24,8 @@ void MacroEngine::AddCode(u32 method, u32 data) {
     uploaded_macro_code[method].push_back(data);
 }
 
-void MacroEngine::Execute(u32 method, const std::vector<u32>& parameters) {
+void MacroEngine::Execute(Engines::Maxwell3D& maxwell3d, u32 method,
+                          const std::vector<u32>& parameters) {
     auto compiled_macro = macro_cache.find(method);
     if (compiled_macro != macro_cache.end()) {
         const auto& cache_info = compiled_macro->second;
@@ -66,9 +66,10 @@ void MacroEngine::Execute(u32 method, const std::vector<u32>& parameters) {
             cache_info.lle_program = Compile(code);
         }
 
-        if (auto hle_program = hle_macros->GetHLEProgram(cache_info.hash)) {
+        auto hle_program = hle_macros->GetHLEProgram(cache_info.hash);
+        if (hle_program.has_value()) {
             cache_info.has_hle_program = true;
-            cache_info.hle_program = std::move(hle_program);
+            cache_info.hle_program = std::move(hle_program.value());
             cache_info.hle_program->Execute(parameters, method);
         } else {
             cache_info.lle_program->Execute(parameters, method);

src/video_core/macro/macro.h

@@ -119,7 +119,7 @@ public:
     void AddCode(u32 method, u32 data);
 
     // Compiles the macro if its not in the cache, and executes the compiled macro
-    void Execute(u32 method, const std::vector<u32>& parameters);
+    void Execute(Engines::Maxwell3D& maxwell3d, u32 method, const std::vector<u32>& parameters);
 
 protected:
     virtual std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) = 0;

src/video_core/macro/macro_hle.cpp

@@ -5,15 +5,12 @@
 #include <array>
 #include <vector>
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro/macro.h"
 #include "video_core/macro/macro_hle.h"
 #include "video_core/rasterizer_interface.h"
 
 namespace Tegra {
+
 namespace {
-
-using HLEFunction = void (*)(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters);
-
 // HLE'd functions
 void HLE_771BB18C62444DA0(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
     const u32 instance_count = parameters[2] & maxwell3d.GetRegisterValue(0xD1B);
@@ -80,6 +77,7 @@ void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
     maxwell3d.CallMethodFromMME(0x8e5, 0x0);
     maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
 }
+} // Anonymous namespace
 
 constexpr std::array<std::pair<u64, HLEFunction>, 3> hle_funcs{{
     {0x771BB18C62444DA0, &HLE_771BB18C62444DA0},
@@ -87,31 +85,25 @@ constexpr std::array<std::pair<u64, HLEFunction>, 3> hle_funcs{{
     {0x0217920100488FF7, &HLE_0217920100488FF7},
 }};
 
-class HLEMacroImpl final : public CachedMacro {
-public:
-    explicit HLEMacroImpl(Engines::Maxwell3D& maxwell3d_, HLEFunction func_)
-        : maxwell3d{maxwell3d_}, func{func_} {}
-
-    void Execute(const std::vector<u32>& parameters, u32 method) override {
-        func(maxwell3d, parameters);
-    }
-
-private:
-    Engines::Maxwell3D& maxwell3d;
-    HLEFunction func;
-};
-} // Anonymous namespace
-
 HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d_) : maxwell3d{maxwell3d_} {}
 HLEMacro::~HLEMacro() = default;
 
-std::unique_ptr<CachedMacro> HLEMacro::GetHLEProgram(u64 hash) const {
+std::optional<std::unique_ptr<CachedMacro>> HLEMacro::GetHLEProgram(u64 hash) const {
     const auto it = std::find_if(hle_funcs.cbegin(), hle_funcs.cend(),
                                  [hash](const auto& pair) { return pair.first == hash; });
     if (it == hle_funcs.end()) {
-        return nullptr;
+        return std::nullopt;
     }
     return std::make_unique<HLEMacroImpl>(maxwell3d, it->second);
 }
 
+HLEMacroImpl::~HLEMacroImpl() = default;
+
+HLEMacroImpl::HLEMacroImpl(Engines::Maxwell3D& maxwell3d_, HLEFunction func_)
+    : maxwell3d{maxwell3d_}, func{func_} {}
+
+void HLEMacroImpl::Execute(const std::vector<u32>& parameters, u32 method) {
+    func(maxwell3d, parameters);
+}
+
 } // namespace Tegra

src/video_core/macro/macro_hle.h

@@ -5,7 +5,10 @@
 #pragma once
 
 #include <memory>
+#include <optional>
+#include <vector>
 #include "common/common_types.h"
+#include "video_core/macro/macro.h"
 
 namespace Tegra {
 
@@ -13,17 +16,29 @@ namespace Engines {
 class Maxwell3D;
 }
 
+using HLEFunction = void (*)(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters);
+
 class HLEMacro {
 public:
     explicit HLEMacro(Engines::Maxwell3D& maxwell3d_);
     ~HLEMacro();
 
-    // Allocates and returns a cached macro if the hash matches a known function.
-    // Returns nullptr otherwise.
-    [[nodiscard]] std::unique_ptr<CachedMacro> GetHLEProgram(u64 hash) const;
+    std::optional<std::unique_ptr<CachedMacro>> GetHLEProgram(u64 hash) const;
 
 private:
     Engines::Maxwell3D& maxwell3d;
 };
 
+class HLEMacroImpl : public CachedMacro {
+public:
+    explicit HLEMacroImpl(Engines::Maxwell3D& maxwell3d, HLEFunction func);
+    ~HLEMacroImpl();
+
+    void Execute(const std::vector<u32>& parameters, u32 method) override;
+
+private:
+    Engines::Maxwell3D& maxwell3d;
+    HLEFunction func;
+};
+
 } // namespace Tegra

src/video_core/macro/macro_interpreter.cpp

@@ -2,9 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
-#include <optional>
-
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
@@ -14,81 +11,16 @@
 MICROPROFILE_DEFINE(MacroInterp, "GPU", "Execute macro interpreter", MP_RGB(128, 128, 192));
 
 namespace Tegra {
-namespace {
-class MacroInterpreterImpl final : public CachedMacro {
-public:
-    explicit MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_)
-        : maxwell3d{maxwell3d_}, code{code_} {}
+MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d_)
+    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}
 
-    void Execute(const std::vector<u32>& params, u32 method) override;
+std::unique_ptr<CachedMacro> MacroInterpreter::Compile(const std::vector<u32>& code) {
+    return std::make_unique<MacroInterpreterImpl>(maxwell3d, code);
+}
 
-private:
-    /// Resets the execution engine state, zeroing registers, etc.
-    void Reset();
-
-    /**
-     * Executes a single macro instruction located at the current program counter. Returns whether
-     * the interpreter should keep running.
-     *
-     * @param is_delay_slot Whether the current step is being executed due to a delay slot in a
-     *                      previous instruction.
-     */
-    bool Step(bool is_delay_slot);
-
-    /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(Macro::ALUOperation operation, u32 src_a, u32 src_b);
-
-    /// Performs the result operation on the input result and stores it in the specified register
-    /// (if necessary).
-    void ProcessResult(Macro::ResultOperation operation, u32 reg, u32 result);
-
-    /// Evaluates the branch condition and returns whether the branch should be taken or not.
-    bool EvaluateBranchCondition(Macro::BranchCondition cond, u32 value) const;
-
-    /// Reads an opcode at the current program counter location.
-    Macro::Opcode GetOpcode() const;
-
-    /// Returns the specified register's value. Register 0 is hardcoded to always return 0.
-    u32 GetRegister(u32 register_id) const;
-
-    /// Sets the register to the input value.
-    void SetRegister(u32 register_id, u32 value);
-
-    /// Sets the method address to use for the next Send instruction.
-    void SetMethodAddress(u32 address);
-
-    /// Calls a GPU Engine method with the input parameter.
-    void Send(u32 value);
-
-    /// Reads a GPU register located at the method address.
-    u32 Read(u32 method) const;
-
-    /// Returns the next parameter in the parameter queue.
-    u32 FetchParameter();
-
-    Engines::Maxwell3D& maxwell3d;
-
-    /// Current program counter
-    u32 pc{};
-    /// Program counter to execute at after the delay slot is executed.
-    std::optional<u32> delayed_pc;
-
-    /// General purpose macro registers.
-    std::array<u32, Macro::NUM_MACRO_REGISTERS> registers = {};
-
-    /// Method address to use for the next Send instruction.
-    Macro::MethodAddress method_address = {};
-
-    /// Input parameters of the current macro.
-    std::unique_ptr<u32[]> parameters;
-    std::size_t num_parameters = 0;
-    std::size_t parameters_capacity = 0;
-    /// Index of the next parameter that will be fetched by the 'parm' instruction.
-    u32 next_parameter_index = 0;
-
-    bool carry_flag = false;
-    const std::vector<u32>& code;
-};
+MacroInterpreterImpl::MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d_,
+                                           const std::vector<u32>& code_)
+    : maxwell3d{maxwell3d_}, code{code_} {}
 
 void MacroInterpreterImpl::Execute(const std::vector<u32>& params, u32 method) {
     MICROPROFILE_SCOPE(MacroInterp);
@@ -351,13 +283,5 @@ u32 MacroInterpreterImpl::FetchParameter() {
     ASSERT(next_parameter_index < num_parameters);
     return parameters[next_parameter_index++];
 }
-} // Anonymous namespace
-
-MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d_)
-    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}
-
-std::unique_ptr<CachedMacro> MacroInterpreter::Compile(const std::vector<u32>& code) {
-    return std::make_unique<MacroInterpreterImpl>(maxwell3d, code);
-}
 
 } // namespace Tegra

src/video_core/macro/macro_interpreter.h

@@ -3,9 +3,10 @@
 // Refer to the license.txt file included.
 
 #pragma once
-
+#include <array>
+#include <optional>
 #include <vector>
-
+#include "common/bit_field.h"
 #include "common/common_types.h"
 #include "video_core/macro/macro.h"
 
@@ -25,4 +26,77 @@ private:
     Engines::Maxwell3D& maxwell3d;
 };
 
+class MacroInterpreterImpl : public CachedMacro {
+public:
+    explicit MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_);
+    void Execute(const std::vector<u32>& params, u32 method) override;
+
+private:
+    /// Resets the execution engine state, zeroing registers, etc.
+    void Reset();
+
+    /**
+     * Executes a single macro instruction located at the current program counter. Returns whether
+     * the interpreter should keep running.
+     *
+     * @param is_delay_slot Whether the current step is being executed due to a delay slot in a
+     *                      previous instruction.
+     */
+    bool Step(bool is_delay_slot);
+
+    /// Calculates the result of an ALU operation. src_a OP src_b;
+    u32 GetALUResult(Macro::ALUOperation operation, u32 src_a, u32 src_b);
+
+    /// Performs the result operation on the input result and stores it in the specified register
+    /// (if necessary).
+    void ProcessResult(Macro::ResultOperation operation, u32 reg, u32 result);
+
+    /// Evaluates the branch condition and returns whether the branch should be taken or not.
+    bool EvaluateBranchCondition(Macro::BranchCondition cond, u32 value) const;
+
+    /// Reads an opcode at the current program counter location.
+    Macro::Opcode GetOpcode() const;
+
+    /// Returns the specified register's value. Register 0 is hardcoded to always return 0.
+    u32 GetRegister(u32 register_id) const;
+
+    /// Sets the register to the input value.
+    void SetRegister(u32 register_id, u32 value);
+
+    /// Sets the method address to use for the next Send instruction.
+    void SetMethodAddress(u32 address);
+
+    /// Calls a GPU Engine method with the input parameter.
+    void Send(u32 value);
+
+    /// Reads a GPU register located at the method address.
+    u32 Read(u32 method) const;
+
+    /// Returns the next parameter in the parameter queue.
+    u32 FetchParameter();
+
+    Engines::Maxwell3D& maxwell3d;
+
+    /// Current program counter
+    u32 pc;
+    /// Program counter to execute at after the delay slot is executed.
+    std::optional<u32> delayed_pc;
+
+    /// General purpose macro registers.
+    std::array<u32, Macro::NUM_MACRO_REGISTERS> registers = {};
+
+    /// Method address to use for the next Send instruction.
+    Macro::MethodAddress method_address = {};
+
+    /// Input parameters of the current macro.
+    std::unique_ptr<u32[]> parameters;
+    std::size_t num_parameters = 0;
+    std::size_t parameters_capacity = 0;
+    /// Index of the next parameter that will be fetched by the 'parm' instruction.
+    u32 next_parameter_index = 0;
+
+    bool carry_flag = false;
+    const std::vector<u32>& code;
+};
+
 } // namespace Tegra

src/video_core/macro/macro_jit_x64.cpp

@@ -2,17 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
-#include <bitset>
-#include <optional>
-
-#include <xbyak/xbyak.h>
-
 #include "common/assert.h"
-#include "common/bit_field.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
-#include "common/x64/xbyak_abi.h"
 #include "common/x64/xbyak_util.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/macro/macro_interpreter.h"
@@ -22,14 +14,13 @@ MICROPROFILE_DEFINE(MacroJitCompile, "GPU", "Compile macro JIT", MP_RGB(173, 255
 MICROPROFILE_DEFINE(MacroJitExecute, "GPU", "Execute macro JIT", MP_RGB(255, 255, 0));
 
 namespace Tegra {
-namespace {
 constexpr Xbyak::Reg64 STATE = Xbyak::util::rbx;
 constexpr Xbyak::Reg32 RESULT = Xbyak::util::ebp;
 constexpr Xbyak::Reg64 PARAMETERS = Xbyak::util::r12;
 constexpr Xbyak::Reg32 METHOD_ADDRESS = Xbyak::util::r14d;
 constexpr Xbyak::Reg64 BRANCH_HOLDER = Xbyak::util::r15;
 
-constexpr std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
+static const std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
     STATE,
     RESULT,
     PARAMETERS,
@@ -37,75 +28,19 @@ constexpr std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
     BRANCH_HOLDER,
 });
 
-// Arbitrarily chosen based on current booting games.
-constexpr size_t MAX_CODE_SIZE = 0x10000;
+MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d_)
+    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}
 
-std::bitset<32> PersistentCallerSavedRegs() {
-    return PERSISTENT_REGISTERS & Common::X64::ABI_ALL_CALLER_SAVED;
+std::unique_ptr<CachedMacro> MacroJITx64::Compile(const std::vector<u32>& code) {
+    return std::make_unique<MacroJITx64Impl>(maxwell3d, code);
 }
 
-class MacroJITx64Impl final : public Xbyak::CodeGenerator, public CachedMacro {
-public:
-    explicit MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_)
-        : CodeGenerator{MAX_CODE_SIZE}, code{code_}, maxwell3d{maxwell3d_} {
-        Compile();
-    }
+MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_)
+    : CodeGenerator{MAX_CODE_SIZE}, code{code_}, maxwell3d{maxwell3d_} {
+    Compile();
+}
 
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
-
-    void Compile_ALU(Macro::Opcode opcode);
-    void Compile_AddImmediate(Macro::Opcode opcode);
-    void Compile_ExtractInsert(Macro::Opcode opcode);
-    void Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode);
-    void Compile_ExtractShiftLeftRegister(Macro::Opcode opcode);
-    void Compile_Read(Macro::Opcode opcode);
-    void Compile_Branch(Macro::Opcode opcode);
-
-private:
-    void Optimizer_ScanFlags();
-
-    void Compile();
-    bool Compile_NextInstruction();
-
-    Xbyak::Reg32 Compile_FetchParameter();
-    Xbyak::Reg32 Compile_GetRegister(u32 index, Xbyak::Reg32 dst);
-
-    void Compile_ProcessResult(Macro::ResultOperation operation, u32 reg);
-    void Compile_Send(Xbyak::Reg32 value);
-
-    Macro::Opcode GetOpCode() const;
-
-    struct JITState {
-        Engines::Maxwell3D* maxwell3d{};
-        std::array<u32, Macro::NUM_MACRO_REGISTERS> registers{};
-        u32 carry_flag{};
-    };
-    static_assert(offsetof(JITState, maxwell3d) == 0, "Maxwell3D is not at 0x0");
-    using ProgramType = void (*)(JITState*, const u32*);
-
-    struct OptimizerState {
-        bool can_skip_carry{};
-        bool has_delayed_pc{};
-        bool zero_reg_skip{};
-        bool skip_dummy_addimmediate{};
-        bool optimize_for_method_move{};
-        bool enable_asserts{};
-    };
-    OptimizerState optimizer{};
-
-    std::optional<Macro::Opcode> next_opcode{};
-    ProgramType program{nullptr};
-
-    std::array<Xbyak::Label, MAX_CODE_SIZE> labels;
-    std::array<Xbyak::Label, MAX_CODE_SIZE> delay_skip;
-    Xbyak::Label end_of_code{};
-
-    bool is_delay_slot{};
-    u32 pc{};
-
-    const std::vector<u32>& code;
-    Engines::Maxwell3D& maxwell3d;
-};
+MacroJITx64Impl::~MacroJITx64Impl() = default;
 
 void MacroJITx64Impl::Execute(const std::vector<u32>& parameters, u32 method) {
     MICROPROFILE_SCOPE(MacroJitExecute);
@@ -372,11 +307,11 @@ void MacroJITx64Impl::Compile_Read(Macro::Opcode opcode) {
     Compile_ProcessResult(opcode.result_operation, opcode.dst);
 }
 
-void Send(Engines::Maxwell3D* maxwell3d, Macro::MethodAddress method_address, u32 value) {
+static void Send(Engines::Maxwell3D* maxwell3d, Macro::MethodAddress method_address, u32 value) {
     maxwell3d->CallMethodFromMME(method_address.address, value);
 }
 
-void MacroJITx64Impl::Compile_Send(Xbyak::Reg32 value) {
+void Tegra::MacroJITx64Impl::Compile_Send(Xbyak::Reg32 value) {
     Common::X64::ABI_PushRegistersAndAdjustStack(*this, PersistentCallerSavedRegs(), 0);
     mov(Common::X64::ABI_PARAM1, qword[STATE]);
     mov(Common::X64::ABI_PARAM2, METHOD_ADDRESS);
@@ -403,7 +338,7 @@ void MacroJITx64Impl::Compile_Send(Xbyak::Reg32 value) {
     L(dont_process);
 }
 
-void MacroJITx64Impl::Compile_Branch(Macro::Opcode opcode) {
+void Tegra::MacroJITx64Impl::Compile_Branch(Macro::Opcode opcode) {
     ASSERT_MSG(!is_delay_slot, "Executing a branch in a delay slot is not valid");
     const s32 jump_address =
         static_cast<s32>(pc) + static_cast<s32>(opcode.GetBranchTarget() / sizeof(s32));
@@ -457,7 +392,7 @@ void MacroJITx64Impl::Compile_Branch(Macro::Opcode opcode) {
     L(end);
 }
 
-void MacroJITx64Impl::Optimizer_ScanFlags() {
+void Tegra::MacroJITx64Impl::Optimizer_ScanFlags() {
     optimizer.can_skip_carry = true;
     optimizer.has_delayed_pc = false;
     for (auto raw_op : code) {
@@ -599,7 +534,7 @@ bool MacroJITx64Impl::Compile_NextInstruction() {
     return true;
 }
 
-Xbyak::Reg32 MacroJITx64Impl::Compile_FetchParameter() {
+Xbyak::Reg32 Tegra::MacroJITx64Impl::Compile_FetchParameter() {
     mov(eax, dword[PARAMETERS]);
     add(PARAMETERS, sizeof(u32));
     return eax;
@@ -676,12 +611,9 @@ Macro::Opcode MacroJITx64Impl::GetOpCode() const {
     ASSERT(pc < code.size());
     return {code[pc]};
 }
-} // Anonymous namespace
 
-MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d_)
-    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}
-
-std::unique_ptr<CachedMacro> MacroJITx64::Compile(const std::vector<u32>& code) {
-    return std::make_unique<MacroJITx64Impl>(maxwell3d, code);
+std::bitset<32> MacroJITx64Impl::PersistentCallerSavedRegs() const {
+    return PERSISTENT_REGISTERS & Common::X64::ABI_ALL_CALLER_SAVED;
 }
+
 } // namespace Tegra

src/video_core/macro/macro_jit_x64.h

@@ -4,7 +4,12 @@
 
 #pragma once
 
+#include <array>
+#include <bitset>
+#include <xbyak/xbyak.h>
+#include "common/bit_field.h"
 #include "common/common_types.h"
+#include "common/x64/xbyak_abi.h"
 #include "video_core/macro/macro.h"
 
 namespace Tegra {
@@ -13,6 +18,9 @@ namespace Engines {
 class Maxwell3D;
 }
 
+/// MAX_CODE_SIZE is arbitrarily chosen based on current booting games
+constexpr size_t MAX_CODE_SIZE = 0x10000;
+
 class MacroJITx64 final : public MacroEngine {
 public:
     explicit MacroJITx64(Engines::Maxwell3D& maxwell3d_);
@@ -24,4 +32,67 @@ private:
     Engines::Maxwell3D& maxwell3d;
 };
 
+class MacroJITx64Impl : public Xbyak::CodeGenerator, public CachedMacro {
+public:
+    explicit MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_);
+    ~MacroJITx64Impl();
+
+    void Execute(const std::vector<u32>& parameters, u32 method) override;
+
+    void Compile_ALU(Macro::Opcode opcode);
+    void Compile_AddImmediate(Macro::Opcode opcode);
+    void Compile_ExtractInsert(Macro::Opcode opcode);
+    void Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode);
+    void Compile_ExtractShiftLeftRegister(Macro::Opcode opcode);
+    void Compile_Read(Macro::Opcode opcode);
+    void Compile_Branch(Macro::Opcode opcode);
+
+private:
+    void Optimizer_ScanFlags();
+
+    void Compile();
+    bool Compile_NextInstruction();
+
+    Xbyak::Reg32 Compile_FetchParameter();
+    Xbyak::Reg32 Compile_GetRegister(u32 index, Xbyak::Reg32 dst);
+
+    void Compile_ProcessResult(Macro::ResultOperation operation, u32 reg);
+    void Compile_Send(Xbyak::Reg32 value);
+
+    Macro::Opcode GetOpCode() const;
+    std::bitset<32> PersistentCallerSavedRegs() const;
+
+    struct JITState {
+        Engines::Maxwell3D* maxwell3d{};
+        std::array<u32, Macro::NUM_MACRO_REGISTERS> registers{};
+        u32 carry_flag{};
+    };
+    static_assert(offsetof(JITState, maxwell3d) == 0, "Maxwell3D is not at 0x0");
+    using ProgramType = void (*)(JITState*, const u32*);
+
+    struct OptimizerState {
+        bool can_skip_carry{};
+        bool has_delayed_pc{};
+        bool zero_reg_skip{};
+        bool skip_dummy_addimmediate{};
+        bool optimize_for_method_move{};
+        bool enable_asserts{};
+    };
+    OptimizerState optimizer{};
+
+    std::optional<Macro::Opcode> next_opcode{};
+    ProgramType program{nullptr};
+
+    std::array<Xbyak::Label, MAX_CODE_SIZE> labels;
+    std::array<Xbyak::Label, MAX_CODE_SIZE> delay_skip;
+    Xbyak::Label end_of_code{};
+
+    bool is_delay_slot{};
+    u32 pc{};
+    std::optional<u32> delayed_pc;
+
+    const std::vector<u32>& code;
+    Engines::Maxwell3D& maxwell3d;
+};
+
 } // namespace Tegra

src/video_core/renderer_vulkan/vk_fsr.cpp

@@ -214,7 +214,7 @@ VkImageView FSR::Draw(VKScheduler& scheduler, size_t image_index, VkImageView im
 
         {
             VkImageMemoryBarrier fsr_write_barrier = base_barrier;
-            fsr_write_barrier.image = *images[image_index];
+            fsr_write_barrier.image = *images[image_index],
             fsr_write_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,

src/yuzu/configuration/config.cpp

@@ -393,8 +393,6 @@ void Config::ReadControlValues() {
     ReadGlobalSetting(Settings::values.enable_accurate_vibrations);
     ReadGlobalSetting(Settings::values.motion_enabled);
 
-    ReadBasicSetting(Settings::values.controller_navigation);
-
     qt_config->endGroup();
 }
 
@@ -1003,7 +1001,6 @@ void Config::SaveControlValues() {
     WriteBasicSetting(Settings::values.keyboard_enabled);
     WriteBasicSetting(Settings::values.emulate_analog_keyboard);
     WriteBasicSetting(Settings::values.mouse_panning_sensitivity);
-    WriteBasicSetting(Settings::values.controller_navigation);
 
     WriteBasicSetting(Settings::values.tas_enable);
     WriteBasicSetting(Settings::values.tas_loop);

src/yuzu/configuration/configure_graphics.ui

@@ -429,7 +429,7 @@
              </item>
              <item>
               <property name="text">
-               <string>AMD FidelityFX™️ Super Resolution (Vulkan Only)</string>
+               <string>AMD FidelityFX™️ Super Resolution [Vulkan Only]</string>
               </property>
              </item>
             </widget>

src/yuzu/configuration/configure_input_advanced.cpp

@@ -131,7 +131,6 @@ void ConfigureInputAdvanced::ApplyConfiguration() {
     Settings::values.touchscreen.enabled = ui->touchscreen_enabled->isChecked();
     Settings::values.enable_raw_input = ui->enable_raw_input->isChecked();
     Settings::values.enable_udp_controller = ui->enable_udp_controller->isChecked();
-    Settings::values.controller_navigation = ui->controller_navigation->isChecked();
 }
 
 void ConfigureInputAdvanced::LoadConfiguration() {
@@ -163,7 +162,6 @@ void ConfigureInputAdvanced::LoadConfiguration() {
     ui->touchscreen_enabled->setChecked(Settings::values.touchscreen.enabled);
     ui->enable_raw_input->setChecked(Settings::values.enable_raw_input.GetValue());
     ui->enable_udp_controller->setChecked(Settings::values.enable_udp_controller.GetValue());
-    ui->controller_navigation->setChecked(Settings::values.controller_navigation.GetValue());
 
     UpdateUIEnabled();
 }

src/yuzu/configuration/configure_input_advanced.ui

@@ -2655,19 +2655,6 @@
                      </widget>
                    </item>
                    <item row="4" column="0">
-                     <widget class="QCheckBox" name="controller_navigation">
-                       <property name="minimumSize">
-                         <size>
-                           <width>0</width>
-                           <height>23</height>
-                         </size>
-                       </property>
-                       <property name="text">
-                         <string>Controller navigation</string>
-                       </property>
-                     </widget>
-                   </item>
-                   <item row="5" column="0">
                      <widget class="QCheckBox" name="mouse_panning">
                        <property name="minimumSize">
                          <size>
@@ -2680,7 +2667,7 @@
                        </property>
                      </widget>
                    </item>
-                   <item row="5" column="2">
+                   <item row="4" column="2">
                      <widget class="QSpinBox" name="mouse_panning_sensitivity">
                        <property name="toolTip">
                          <string>Mouse sensitivity</string>
@@ -2702,14 +2689,14 @@
                        </property>
                      </widget>
                    </item>
-                   <item row="6" column="0">
+                   <item row="5" column="0">
                      <widget class="QLabel" name="motion_touch">
                        <property name="text">
                          <string>Motion / Touch</string>
                        </property>
                      </widget>
                    </item>
-                   <item row="6" column="2">
+                   <item row="5" column="2">
                      <widget class="QPushButton" name="buttonMotionTouch">
                        <property name="text">
                          <string>Configure</string>

src/yuzu/configuration/configure_input_player.cpp

@@ -147,7 +147,7 @@ QString ConfigureInputPlayer::ButtonToText(const Common::ParamPackage& param) {
     // Retrieve the names from Qt
     if (param.Get("engine", "") == "keyboard") {
         const QString button_str = GetKeyName(param.Get("code", 0));
-        return QObject::tr("%1%2%3").arg(toggle, inverted, button_str);
+        return QObject::tr("%1%2").arg(toggle, button_str);
     }
 
     if (common_button_name == Common::Input::ButtonNames::Invalid) {
@@ -341,7 +341,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                         emulated_controller->SetButtonParam(button_id, {});
                         button_map[button_id]->setText(tr("[not set]"));
                     });
-                    if (param.Has("code") || param.Has("button") || param.Has("hat")) {
+                    if (param.Has("button") || param.Has("hat")) {
                         context_menu.addAction(tr("Toggle button"), [&] {
                             const bool toggle_value = !param.Get("toggle", false);
                             param.Set("toggle", toggle_value);
@@ -349,8 +349,8 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                             emulated_controller->SetButtonParam(button_id, param);
                         });
                         context_menu.addAction(tr("Invert button"), [&] {
-                            const bool invert_value = !param.Get("inverted", false);
-                            param.Set("inverted", invert_value);
+                            const bool toggle_value = !param.Get("inverted", false);
+                            param.Set("inverted", toggle_value);
                             button_map[button_id]->setText(ButtonToText(param));
                             emulated_controller->SetButtonParam(button_id, param);
                         });
@@ -403,10 +403,22 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
         connect(button, &QPushButton::customContextMenuRequested,
                 [=, this](const QPoint& menu_location) {
                     QMenu context_menu;
+                    Common::ParamPackage param = emulated_controller->GetMotionParam(motion_id);
                     context_menu.addAction(tr("Clear"), [&] {
                         emulated_controller->SetMotionParam(motion_id, {});
                         motion_map[motion_id]->setText(tr("[not set]"));
                     });
+                    if (param.Has("motion")) {
+                        context_menu.addAction(tr("Set gyro threshold"), [&] {
+                            const int gyro_threshold =
+                                static_cast<int>(param.Get("threshold", 0.007f) * 1000.0f);
+                            const int new_threshold = QInputDialog::getInt(
+                                this, tr("Set threshold"), tr("Choose a value between 0% and 100%"),
+                                gyro_threshold, 0, 100);
+                            param.Set("threshold", new_threshold / 1000.0f);
+                            emulated_controller->SetMotionParam(motion_id, param);
+                        });
+                    }
                     context_menu.exec(motion_map[motion_id]->mapToGlobal(menu_location));
                 });
     }
@@ -510,37 +522,28 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 
         analog_map_modifier_button[analog_id]->setContextMenuPolicy(Qt::CustomContextMenu);
 
-        connect(
-            analog_map_modifier_button[analog_id], &QPushButton::customContextMenuRequested,
-            [=, this](const QPoint& menu_location) {
-                QMenu context_menu;
-                Common::ParamPackage param = emulated_controller->GetStickParam(analog_id);
-                context_menu.addAction(tr("Clear"), [&] {
-                    param.Set("modifier", "");
-                    analog_map_modifier_button[analog_id]->setText(tr("[not set]"));
-                    emulated_controller->SetStickParam(analog_id, param);
+        connect(analog_map_modifier_button[analog_id], &QPushButton::customContextMenuRequested,
+                [=, this](const QPoint& menu_location) {
+                    QMenu context_menu;
+                    Common::ParamPackage param = emulated_controller->GetStickParam(analog_id);
+                    context_menu.addAction(tr("Clear"), [&] {
+                        param.Set("modifier", "");
+                        analog_map_modifier_button[analog_id]->setText(tr("[not set]"));
+                        emulated_controller->SetStickParam(analog_id, param);
+                    });
+                    context_menu.addAction(tr("Toggle button"), [&] {
+                        Common::ParamPackage modifier_param =
+                            Common::ParamPackage{param.Get("modifier", "")};
+                        const bool toggle_value = !modifier_param.Get("toggle", false);
+                        modifier_param.Set("toggle", toggle_value);
+                        param.Set("modifier", modifier_param.Serialize());
+                        analog_map_modifier_button[analog_id]->setText(
+                            ButtonToText(modifier_param));
+                        emulated_controller->SetStickParam(analog_id, param);
+                    });
+                    context_menu.exec(
+                        analog_map_modifier_button[analog_id]->mapToGlobal(menu_location));
                 });
-                context_menu.addAction(tr("Toggle button"), [&] {
-                    Common::ParamPackage modifier_param =
-                        Common::ParamPackage{param.Get("modifier", "")};
-                    const bool toggle_value = !modifier_param.Get("toggle", false);
-                    modifier_param.Set("toggle", toggle_value);
-                    param.Set("modifier", modifier_param.Serialize());
-                    analog_map_modifier_button[analog_id]->setText(ButtonToText(modifier_param));
-                    emulated_controller->SetStickParam(analog_id, param);
-                });
-                context_menu.addAction(tr("Invert button"), [&] {
-                    Common::ParamPackage modifier_param =
-                        Common::ParamPackage{param.Get("modifier", "")};
-                    const bool invert_value = !modifier_param.Get("inverted", false);
-                    modifier_param.Set("inverted", invert_value);
-                    param.Set("modifier", modifier_param.Serialize());
-                    analog_map_modifier_button[analog_id]->setText(ButtonToText(modifier_param));
-                    emulated_controller->SetStickParam(analog_id, param);
-                });
-                context_menu.exec(
-                    analog_map_modifier_button[analog_id]->mapToGlobal(menu_location));
-            });
 
         connect(analog_map_range_spinbox[analog_id], qOverload<int>(&QSpinBox::valueChanged),
                 [=, this] {

src/yuzu/hotkeys.cpp

@@ -190,9 +190,6 @@ void ControllerShortcut::ControllerUpdateEvent(Core::HID::ControllerTriggerType
     if (type != Core::HID::ControllerTriggerType::Button) {
         return;
     }
-    if (!Settings::values.controller_navigation) {
-        return;
-    }
     if (button_sequence.npad.raw == Core::HID::NpadButton::None &&
         button_sequence.capture.raw == 0 && button_sequence.home.raw == 0) {
         return;

src/yuzu/util/controller_navigation.cpp

@@ -40,9 +40,6 @@ void ControllerNavigation::TriggerButton(Settings::NativeButton::Values native_b
 
 void ControllerNavigation::ControllerUpdateEvent(Core::HID::ControllerTriggerType type) {
     std::lock_guard lock{mutex};
-    if (!Settings::values.controller_navigation) {
-        return;
-    }
     if (type == Core::HID::ControllerTriggerType::Button) {
         ControllerUpdateButton();
         return;