2026-09-06 20:57:36

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/dynarmic/tests/A32/fuzz_arm.cpp

@@ -321,8 +321,6 @@ static void RunTestInstance(Dynarmic::A32::Jit& jit,
     uni_env.PadCodeMem();
     jit_env.modified_memory.clear();
     uni_env.modified_memory.clear();
-    jit_env.interrupts.clear();
-    uni_env.interrupts.clear();
 
     jit.Regs() = regs;
     jit.ExtRegs() = vecs;

src/dynarmic/tests/A64/fuzz_with_unicorn.cpp

@@ -176,8 +176,6 @@ static void RunTestInstance(Dynarmic::A64::Jit& jit, A64Unicorn& uni, A64TestEnv
     uni_env.code_mem_start_address = instructions_start;
     jit_env.modified_memory.clear();
     uni_env.modified_memory.clear();
-    jit_env.interrupts.clear();
-    uni_env.interrupts.clear();
 
     const u64 initial_sp = RandInt<u64>(0x30'0000'0000, 0x40'0000'0000) * 4;
 

src/dynarmic/tests/print_info.cpp

@@ -282,20 +282,17 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    const char* const hex_instruction = [argv] {
-        if (strlen(argv[2]) > 2 && argv[2][0] == '0' && argv[2][1] == 'x') {
-            return argv[2] + 2;
-        }
-        return argv[2];
+    const char* const hex_instruction = [s = argv[2]] {
+        if (strlen(s) > 2 && s[0] == '0' && s[1] == 'x')
+            return s + 2;
+        return s;
     }();
-
     if (strlen(hex_instruction) > 8) {
         fmt::print("hex string too long\n");
         return 1;
     }
 
     const u32 instruction = strtol(hex_instruction, nullptr, 16);
-
     if (strcmp(argv[1], "a32") == 0) {
         PrintA32Instruction(instruction);
     } else if (strcmp(argv[1], "a64") == 0) {
@@ -306,13 +303,11 @@ int main(int argc, char** argv) {
         fmt::print("Invalid mode: {}\nValid values: a32, a64, thumb\n", argv[1]);
         return 1;
     }
-
     if (argc == 4) {
         if (strcmp(argv[3], "-exec") != 0) {
             fmt::print("Invalid option {}\n", argv[3]);
             return 1;
         }
-
         if (strcmp(argv[1], "a32") == 0) {
             ExecuteA32Instruction(instruction);
         } else {
@@ -320,6 +315,5 @@ int main(int argc, char** argv) {
             return 1;
         }
     }
-
     return 0;
 }

src/dynarmic/tests/test_generator.cpp

@@ -354,6 +354,8 @@ u32 GenRandomA64Inst(u64 pc, bool is_last_inst) {
             "MSR_reg",
             "MSR_imm",
             "MRS",
+            // generates F16
+            "FCADD_vec",
         };
 
         for (const auto& [fn, bitstring] : list) {
@@ -440,7 +442,6 @@ void RunTestInstance(Dynarmic::A32::Jit& jit,
         std::copy(instructions.begin(), instructions.end(), jit_env.code_mem.begin() + num_words);
         jit_env.PadCodeMem();
         jit_env.modified_memory.clear();
-        jit_env.interrupts.clear();
 
         jit.Regs() = regs;
         jit.ExtRegs() = vecs;
@@ -510,7 +511,6 @@ void RunTestInstance(Dynarmic::A64::Jit& jit,
         jit_env.code_mem.emplace_back(0x14000000);  // B .
         jit_env.code_mem_start_address = start_address;
         jit_env.modified_memory.clear();
-        jit_env.interrupts.clear();
 
         jit.SetRegisters(regs);
         jit.SetVectors(vecs);
@@ -536,36 +536,52 @@ void RunTestInstance(Dynarmic::A64::Jit& jit,
         fmt::print("initial_regs:");
         for (u64 i : regs)
             fmt::print(" {:016x}", i);
-        fmt::print("\n");
-        fmt::print("initial_vecs:");
+        fmt::print(
+            "\n"
+            "initial_vecs:"
+        );
         for (auto i : vecs)
             fmt::print(" {:016x}:{:016x}", i[0], i[1]);
-        fmt::print("\n");
-        fmt::print("initial_sp: {:016x}\n", initial_sp);
-        fmt::print("initial_pstate: {:08x}\n", pstate);
-        fmt::print("initial_fpcr: {:08x}\n", fpcr);
-        fmt::print("final_regs:");
+        fmt::print(
+            "\n"
+            "initial_sp: {:016x}\n"
+            "initial_pstate: {:08x}\n"
+            "initial_fpcr: {:08x}\n"
+            "final_regs:"
+            , initial_sp
+            , pstate
+            , fpcr
+        );
         for (u64 i : jit.GetRegisters())
             fmt::print(" {:016x}", i);
-        fmt::print("\n");
-        fmt::print("final_vecs:");
+        fmt::print(
+            "\n"
+            "final_vecs:"
+        );
         for (auto i : jit.GetVectors())
             fmt::print(" {:016x}:{:016x}", i[0], i[1]);
-        fmt::print("\n");
-        fmt::print("final_sp: {:016x}\n", jit.GetSP());
-        fmt::print("final_pc: {:016x}\n", jit.GetPC());
-        fmt::print("final_pstate: {:08x}\n", jit.GetPstate());
-        fmt::print("final_fpcr: {:08x}\n", jit.GetFpcr());
-        fmt::print("final_qc : {}\n", FP::FPSR{jit.GetFpsr()}.QC());
-        fmt::print("mod_mem:");
+        fmt::print(
+            "\n"
+            "final_sp: {:016x}\n"
+            "final_pc: {:016x}\n"
+            "final_pstate: {:08x}\n"
+            "final_fpcr: {:08x}\n"
+            "final_qc : {}\n"
+            "mod_mem:"
+            , jit.GetSP()
+            , jit.GetPC()
+            , jit.GetPstate()
+            , jit.GetFpcr()
+            , FP::FPSR{jit.GetFpsr()}.QC()
+        );
         for (auto [addr, value] : jit_env.modified_memory)
             fmt::print(" {:08x}:{:02x}", addr, value);
-        fmt::print("\n");
-        fmt::print("interrupts:\n");
-        for (const auto& i : jit_env.interrupts)
-            std::puts(i.c_str());
-        fmt::print("===\n");
-        fmt::print("{}", jit.Disassemble());
+        fmt::print(
+            "\n"
+            "===\n"
+            "{}"
+            , jit.Disassemble()
+        );
     }
 }
 

src/dynarmic/tests/test_reader.cpp

@@ -99,7 +99,6 @@ void RunTestInstance(Dynarmic::A32::Jit& jit,
         std::copy(instructions.begin(), instructions.end(), jit_env.code_mem.begin() + num_words);
         jit_env.PadCodeMem();
         jit_env.modified_memory.clear();
-        jit_env.interrupts.clear();
 
         jit.Regs() = regs;
         jit.ExtRegs() = vecs;
@@ -192,7 +191,6 @@ void RunTestInstance(A64::Jit& jit,
         jit_env.code_mem.emplace_back(0x14000000);  // B .
         jit_env.code_mem_start_address = start_address;
         jit_env.modified_memory.clear();
-        jit_env.interrupts.clear();
 
         jit.SetRegisters(regs);
         jit.SetVectors(vecs);

src/input_common/drivers/mouse.cpp

@@ -4,16 +4,17 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <chrono>
+#include <thread>
 #include <fmt/ranges.h>
 #include <math.h>
 
 #include "common/param_package.h"
 #include "common/settings.h"
-#include "common/steady_clock.h"
+#include "common/thread.h"
 #include "input_common/drivers/mouse.h"
 
 namespace InputCommon {
+constexpr int update_time = 10;
 constexpr float default_panning_sensitivity = 0.0010f;
 constexpr float default_stick_sensitivity = 0.0006f;
 constexpr float default_deadzone_counterweight = 0.01f;
@@ -73,7 +74,7 @@ Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_))
     last_motion_change = {};
 }
 
-void Mouse::UpdateStickInput(Common::SteadyClock::time_point timestamp) {
+void Mouse::UpdateStickInput() {
     if (!IsMousePanningEnabled()) {
         return;
     }
@@ -99,9 +100,12 @@ void Mouse::UpdateStickInput(Common::SteadyClock::time_point timestamp) {
     last_mouse_change *= clamped_decay;
 }
 
-void Mouse::UpdateMotionInput(Common::SteadyClock::time_point timestamp) {
-    const float sensitivity = IsMousePanningEnabled() ? default_motion_panning_sensitivity : default_motion_sensitivity;
-    const float rotation_velocity = std::sqrt(last_motion_change.x * last_motion_change.x + last_motion_change.y * last_motion_change.y);
+void Mouse::UpdateMotionInput() {
+    const float sensitivity =
+        IsMousePanningEnabled() ? default_motion_panning_sensitivity : default_motion_sensitivity;
+
+    const float rotation_velocity = std::sqrt(last_motion_change.x * last_motion_change.x +
+                                              last_motion_change.y * last_motion_change.y);
 
     // Clamp rotation speed
     if (rotation_velocity > maximum_rotation_speed / sensitivity) {
@@ -117,7 +121,7 @@ void Mouse::UpdateMotionInput(Common::SteadyClock::time_point timestamp) {
         .accel_x = 0,
         .accel_y = 0,
         .accel_z = 0,
-        .delta_timestamp = u64(std::chrono::duration_cast<std::chrono::microseconds>(timestamp - last_notify_timestamp).count()),
+        .delta_timestamp = update_time * 1000,
     };
 
     if (IsMousePanningEnabled()) {
@@ -173,10 +177,8 @@ void Mouse::Move(int x, int y, int center_x, int center_y) {
 }
 
 void Mouse::NotifyChanged() {
-    auto const timestamp = Common::SteadyClock::Now();
-    UpdateStickInput(timestamp);
-    UpdateMotionInput(timestamp);
-    last_notify_timestamp = Common::SteadyClock::Now();
+    UpdateStickInput();
+    UpdateMotionInput();
 }
 
 void Mouse::MouseMove(f32 touch_x, f32 touch_y) {

src/input_common/drivers/mouse.h

@@ -7,9 +7,7 @@
 #pragma once
 
 #include <thread>
-#include <chrono>
 
-#include "common/steady_clock.h"
 #include "common/polyfill_thread.h"
 #include "common/vector_math.h"
 #include "input_common/input_engine.h"
@@ -103,18 +101,17 @@ public:
     Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
 
 private:
-    void UpdateStickInput(Common::SteadyClock::time_point timestamp);
-    void UpdateMotionInput(Common::SteadyClock::time_point timestamp);
+    void UpdateStickInput();
+    void UpdateMotionInput();
     bool IsMousePanningEnabled();
 
     Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
 
-    Common::Vec2<int> mouse_origin{};
-    Common::Vec2<int> last_mouse_position{};
-    Common::Vec2<float> last_mouse_change{};
-    Common::Vec3<float> last_motion_change{};
-    Common::Vec2<int> wheel_position{};
-    Common::SteadyClock::time_point last_notify_timestamp{};
+    Common::Vec2<int> mouse_origin;
+    Common::Vec2<int> last_mouse_position;
+    Common::Vec2<float> last_mouse_change;
+    Common::Vec3<float> last_motion_change;
+    Common::Vec2<int> wheel_position;
     bool button_pressed = false;
 };
 

src/yuzu/bootmanager.cpp

@@ -538,7 +538,6 @@ void GRenderWindow::mouseReleaseEvent(QMouseEvent* event) {
 }
 
 void GRenderWindow::ConstrainMouse() {
-    input_subsystem->GetMouse()->NotifyChanged(); // required to reset mouse once it's no longer moved
     if (QtCommon::emu_thread == nullptr || !Settings::values.mouse_panning) {
         mouse_constrain_timer.stop();
         return;
@@ -553,12 +552,15 @@ void GRenderWindow::ConstrainMouse() {
         const auto pos = mapFromGlobal(QCursor::pos());
         const int new_pos_x = std::clamp(pos.x(), 0, width());
         const int new_pos_y = std::clamp(pos.y(), 0, height());
+
         QCursor::setPos(mapToGlobal(QPoint{new_pos_x, new_pos_y}));
-    } else {
-        const int center_x = width() / 2;
-        const int center_y = height() / 2;
-        QCursor::setPos(mapToGlobal(QPoint{center_x, center_y}));
+        return;
     }
+
+    const int center_x = width() / 2;
+    const int center_y = height() / 2;
+
+    QCursor::setPos(mapToGlobal(QPoint{center_x, center_y}));
 }
 
 void GRenderWindow::wheelEvent(QWheelEvent* event) {

src/yuzu_cmd/emu_window/emu_window_sdl3.cpp

@@ -37,16 +37,10 @@ EmuWindow_SDL3::EmuWindow_SDL3(InputCommon::InputSubsystem* input_subsystem_, Co
         SDL_SetWindowTitle(this_->render_window, title.c_str());
         return 2000;
     }, this);
-    mouse_timer = SDL_AddTimer(100, [](void *userdata, SDL_TimerID, Uint32) -> Uint32 {
-        auto* this_ = (EmuWindow_SDL3*)userdata;
-        this_->input_subsystem->GetMouse()->NotifyChanged();
-        return 100;
-    }, this);
 }
 
 EmuWindow_SDL3::~EmuWindow_SDL3() {
     SDL_RemoveTimer(titlebar_timer);
-    SDL_RemoveTimer(mouse_timer);
     system.HIDCore().UnloadInputDevices();
     input_subsystem->Shutdown();
     SDL_Quit();

src/yuzu_cmd/emu_window/emu_window_sdl3.h

@@ -84,9 +84,6 @@ protected:
     /// Periodic changer of titlebar (independent of event loop)
     SDL_TimerID titlebar_timer;
 
-    // Mouse resetter once it
-    SDL_TimerID mouse_timer;
-
     /// Is the window still open?
     bool is_open = true;