Trigger build

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

src/dynarmic/CMakeLists.txt

@@ -11,15 +11,34 @@ set(dynarmic_VERSION ${dynarmic_VERSION_MAJOR}.${dynarmic_VERSION_MINOR}.${dynar
 
 project(dynarmic LANGUAGES C CXX ASM VERSION ${dynarmic_VERSION})
 
+# Determine if we're built as a subproject (using add_subdirectory)
+# or if this is the master project.
+set(MASTER_PROJECT OFF)
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  set(MASTER_PROJECT ON)
+endif()
+
+if (MASTER_PROJECT)
+    include(CTest)
+endif()
+
+# Dynarmic project options
+option(DYNARMIC_ENABLE_CPU_FEATURE_DETECTION "Turning this off causes dynarmic to assume the host CPU doesn't support anything later than SSE3" ON)
+
 if (OPENBSD OR DRAGONFLY OR NETBSD)
     set(REQUIRE_WX ON)
 else()
     set(REQUIRE_WX OFF)
 endif()
 option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" ${REQUIRE_WX})
+
+option(DYNARMIC_IGNORE_ASSERTS "Ignore asserts" ON)
 option(DYNARMIC_TESTS_USE_UNICORN "Enable fuzzing tests against unicorn" OFF)
 CMAKE_DEPENDENT_OPTION(DYNARMIC_USE_LLVM "Support disassembly of jitted x86_64 code using LLVM" OFF "NOT YUZU_DISABLE_LLVM" OFF)
 
+option(DYNARMIC_INSTALL "Install dynarmic headers and CMake files" OFF)
+option(DYNARMIC_USE_BUNDLED_EXTERNALS "Use all bundled externals (useful when e.g. cross-compiling)" OFF)
+
 # Set hard requirements for C++
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -69,7 +88,7 @@ if (MSVC)
              -Wno-missing-braces)
     endif()
 else()
-    list(APPEND DYNARMIC_CXX_FLAGS
+    set(DYNARMIC_CXX_FLAGS
         -Wall
         -Wextra
         -Wcast-qual
@@ -84,35 +103,37 @@ else()
         # to Address& after first checking isMEM(), and that code is inlined in a situation where
         # GCC knows that the variable is actually a Reg64.  isMEM() will never return true for a
         # Reg64, but GCC doesn't know that.
-        list(APPEND DYNARMIC_CXX_FLAGS
-            -Wno-array-bounds
-            -Wstack-usage=4096)
+        list(APPEND DYNARMIC_CXX_FLAGS -Wno-array-bounds)
+        list(APPEND DYNARMIC_CXX_FLAGS -Wstack-usage=4096)
     endif()
     if (CXX_CLANG)
-        list(APPEND DYNARMIC_CXX_FLAGS
-            # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
-            # And this in turns limits the size of a std::array.
-            -fbracket-depth=1024
-            # Clang mistakenly blames CMake for using unused arguments during compilation
-            -Wno-unused-command-line-argument)
+        # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
+        # And this in turns limits the size of a std::array.
+        list(APPEND DYNARMIC_CXX_FLAGS -fbracket-depth=1024)
+        # Clang mistakenly blames CMake for using unused arguments during compilation
+        list(APPEND DYNARMIC_CXX_FLAGS -Wno-unused-command-line-argument)
     endif()
 endif()
 
 if (NOT Boost_FOUND)
     find_package(Boost 1.57 REQUIRED)
 endif()
+
 find_package(fmt 8 CONFIG)
 
-if (ARCHITECTURE_arm64)
+if ("arm64" IN_LIST ARCHITECTURE OR DYNARMIC_TESTS)
     find_package(oaknut 2.0.1 CONFIG)
 endif()
-if (ARCHITECTURE_riscv64)
+
+if ("riscv64" IN_LIST ARCHITECTURE)
     find_package(biscuit 0.9.1 REQUIRED)
 endif()
-if (ARCHITECTURE_loongarch64)
+
+if ("loongarch64" IN_LIST ARCHITECTURE)
     find_package(lagoon REQUIRED)
 endif()
-if (ARCHITECTURE_x86_64)
+
+if ("x86_64" IN_LIST ARCHITECTURE)
     find_package(xbyak 7 CONFIG)
 endif()
 
@@ -121,12 +142,44 @@ if (DYNARMIC_USE_LLVM)
     separate_arguments(LLVM_DEFINITIONS)
 endif()
 
-# Dynarmic project files
-add_subdirectory(src/dynarmic)
 if (DYNARMIC_TESTS)
     find_package(Catch2 3 CONFIG)
     if (DYNARMIC_TESTS_USE_UNICORN)
         find_package(Unicorn REQUIRED)
     endif()
+endif()
+
+# Dynarmic project files
+add_subdirectory(src/dynarmic)
+if (DYNARMIC_TESTS)
     add_subdirectory(tests)
 endif()
+
+#
+# Install
+#
+if (DYNARMIC_INSTALL)
+    include(GNUInstallDirs)
+    include(CMakePackageConfigHelpers)
+
+    install(TARGETS dynarmic EXPORT dynarmicTargets)
+    install(EXPORT dynarmicTargets
+        NAMESPACE dynarmic::
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/dynarmic"
+    )
+
+    configure_package_config_file(CMakeModules/dynarmicConfig.cmake.in
+        dynarmicConfig.cmake
+        INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/dynarmic"
+    )
+    write_basic_package_version_file(dynarmicConfigVersion.cmake
+        COMPATIBILITY SameMajorVersion
+    )
+    install(FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/dynarmicConfig.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/dynarmicConfigVersion.cmake"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/dynarmic"
+    )
+
+    install(DIRECTORY src/dynarmic TYPE INCLUDE FILES_MATCHING PATTERN "*.h")
+endif()

src/dynarmic/CMakeModules/TargetArchitectureSpecificSources.cmake

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+function(target_architecture_specific_sources project arch)
+    if (NOT MULTIARCH_BUILD)
+        target_sources("${project}" PRIVATE ${ARGN})
+        return()
+    endif()
+
+    foreach(input_file IN LISTS ARGN)
+        if(input_file MATCHES ".cpp$")
+            if(NOT IS_ABSOLUTE ${input_file})
+                set(input_file "${CMAKE_CURRENT_SOURCE_DIR}/${input_file}")
+            endif()
+
+            set(output_file "${CMAKE_CURRENT_BINARY_DIR}/arch_gen/${input_file}")
+            add_custom_command(
+                OUTPUT "${output_file}"
+                COMMAND ${CMAKE_COMMAND} "-Darch=${arch}"
+                                         "-Dinput_file=${input_file}"
+                                         "-Doutput_file=${output_file}"
+                                         -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/impl/TargetArchitectureSpecificSourcesWrapFile.cmake"
+                DEPENDS "${input_file}"
+                VERBATIM
+            )
+            target_sources(${project} PRIVATE "${output_file}")
+        endif()
+    endforeach()
+endfunction()

src/dynarmic/CMakeModules/dynarmicConfig.cmake.in

@@ -0,0 +1,31 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+set(ARCHITECTURE "@ARCHITECTURE@")
+
+if (NOT @BUILD_SHARED_LIBS@)
+    find_dependency(Boost 1.57)
+    find_dependency(fmt 9)
+    find_dependency(mcl 0.1.12 EXACT)
+
+    if ("arm64" IN_LIST ARCHITECTURE)
+        find_dependency(oaknut 2.0.1)
+    endif()
+
+    if ("riscv" IN_LIST ARCHITECTURE)
+        find_dependency(biscuit 0.9.1)
+    endif()
+
+    if ("x86_64" IN_LIST ARCHITECTURE)
+        find_dependency(xbyak 7)
+    endif()
+
+    if (@DYNARMIC_USE_LLVM@)
+        find_dependency(LLVM)
+    endif()
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
+
+check_required_components(@PROJECT_NAME@)

src/dynarmic/CMakeModules/impl/TargetArchitectureSpecificSourcesWrapFile.cmake

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+string(TOUPPER "${arch}" arch)
+file(READ "${input_file}" f_contents)
+file(WRITE "${output_file}" "#if defined(ARCHITECTURE_${arch})\n${f_contents}\n#endif\n")

src/dynarmic/src/dynarmic/CMakeLists.txt

@@ -1,5 +1,7 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
+include(TargetArchitectureSpecificSources)
+
 add_library(dynarmic STATIC
     mcl/bit.hpp
     mcl/function_info.hpp
@@ -133,7 +135,7 @@ add_library(dynarmic STATIC
     interface/A64/config.h
 )
 
-if (ARCHITECTURE_x86_64)
+if ("x86_64" IN_LIST ARCHITECTURE)
     # Newer versions of xbyak (>= 7.25.0) have stricter checks that currently
     # fail in dynarmic
     target_compile_definitions(dynarmic PRIVATE XBYAK_STRICT_CHECK_MEM_REG_SIZE=0)
@@ -141,7 +143,7 @@ if (ARCHITECTURE_x86_64)
     target_compile_definitions(dynarmic PRIVATE XBYAK_OLD_DISP_CHECK=1)
     target_link_libraries(dynarmic PRIVATE xbyak::xbyak)
 
-    target_sources(dynarmic PRIVATE
+    target_architecture_specific_sources(dynarmic "x86_64"
         backend/x64/abi.cpp
         backend/x64/abi.h
         backend/x64/block_of_code.cpp
@@ -199,10 +201,10 @@ if (ARCHITECTURE_x86_64)
     )
 endif()
 
-if (ARCHITECTURE_arm64)
+if ("arm64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic PRIVATE merry::oaknut)
 
-    target_sources(dynarmic PRIVATE
+    target_architecture_specific_sources(dynarmic "arm64"
         backend/arm64/a32_jitstate.cpp
         backend/arm64/a32_jitstate.h
         backend/arm64/a64_jitstate.h
@@ -253,7 +255,7 @@ if (ARCHITECTURE_arm64)
     )
 endif()
 
-if (ARCHITECTURE_riscv64)
+if ("riscv64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic PRIVATE biscuit::biscuit)
 
     target_sources(dynarmic PRIVATE
@@ -293,7 +295,7 @@ if (ARCHITECTURE_riscv64)
     message(WARNING "TODO: Incomplete frontend for this host architecture")
 endif()
 
-if (ARCHITECTURE_loongarch64)
+if ("loongarch64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic PRIVATE lagoon::lagoon)
 
     target_sources(dynarmic PRIVATE
@@ -398,9 +400,15 @@ if (DYNARMIC_USE_LLVM)
     target_compile_definitions(dynarmic PRIVATE DYNARMIC_USE_LLVM=1 ${LLVM_DEFINITIONS})
     llvm_config(dynarmic USE_SHARED armdesc armdisassembler aarch64desc aarch64disassembler x86desc x86disassembler)
 endif()
+if (DYNARMIC_ENABLE_CPU_FEATURE_DETECTION)
+    target_compile_definitions(dynarmic PRIVATE DYNARMIC_ENABLE_CPU_FEATURE_DETECTION=1)
+endif()
 if (DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT)
     target_compile_definitions(dynarmic PRIVATE DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT=1)
 endif()
+if (DYNARMIC_IGNORE_ASSERTS)
+    target_compile_definitions(dynarmic PRIVATE MCL_IGNORE_ASSERTS=1)
+endif()
 if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
     target_compile_definitions(dynarmic PRIVATE FMT_USE_WINDOWS_H=0)
 endif()

src/dynarmic/src/dynarmic/backend/x64/block_of_code.cpp

@@ -78,6 +78,7 @@ void ProtectMemory(const void* base, size_t size, bool is_executable) {
 
 static const HostFeature features = []() {
     HostFeature f{};
+#ifdef DYNARMIC_ENABLE_CPU_FEATURE_DETECTION
     using Cpu = Xbyak::util::Cpu;
     Xbyak::util::Cpu cpu_info{};
     if (cpu_info.has(Cpu::tSSSE3)) f |= HostFeature::SSSE3;
@@ -120,6 +121,7 @@ static const HostFeature features = []() {
         }
     }
     return f;
+#endif
 }();
 HostFeature GetHostFeatures() {
     return features;

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.h

@@ -235,7 +235,6 @@ const void* EmitReadMemoryMov(BlockOfCode& code, int value_idx, const Xbyak::Reg
             code.xadd(qword[addr], Xbyak::Reg64(value_idx));
             break;
         case 128:
-            ASSERT(Xbyak::Xmm(value_idx) != xmm0);
             code.lock();
             code.cmpxchg16b(xword[addr]);
             if (code.HasHostFeature(HostFeature::SSE41)) {

src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector.cpp

@@ -6226,7 +6226,9 @@ void EmitX64::EmitVectorZeroExtend64(EmitContext& ctx, IR::Inst* inst) {
 void EmitX64::EmitVectorZeroUpper(EmitContext& ctx, IR::Inst* inst) {
     auto args = ctx.reg_alloc.GetArgumentInfo(inst);
     auto const a = ctx.reg_alloc.UseScratchXmm(code, args[0]);
+
     code.movq(a, a);  // TODO: !IsLastUse
+
     ctx.reg_alloc.DefineValue(code, inst, a);
 }
 

src/dynarmic/src/dynarmic/common/spin_lock_x64.cpp

@@ -14,6 +14,12 @@
 #include "dynarmic/backend/x64/hostloc.h"
 #include "dynarmic/common/spin_lock.h"
 
+#ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
+static const auto default_cg_mode = Xbyak::DontSetProtectRWE;
+#else
+static const auto default_cg_mode = nullptr; //Allow RWE
+#endif
+
 namespace Dynarmic {
 
 void EmitSpinLockLock(Xbyak::CodeGenerator& code, Xbyak::Reg64 ptr, Xbyak::Reg32 tmp, bool waitpkg) {
@@ -72,13 +78,7 @@ namespace {
 struct SpinLockImpl {
     void Initialize() noexcept;
     static void GlobalInitialize() noexcept;
-    Xbyak::CodeGenerator code = Xbyak::CodeGenerator(4096
-#ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
-        , Xbyak::DontSetProtectRWE
-#else
-        , nullptr //Allow RWE
-#endif
-    );
+    Xbyak::CodeGenerator code = Xbyak::CodeGenerator(4096, default_cg_mode);
     void (*lock)(volatile int*) = nullptr;
     void (*unlock)(volatile int*) = nullptr;
 };

src/dynarmic/src/dynarmic/frontend/decoder/decoder_detail.h

@@ -91,7 +91,7 @@ struct detail {
                 shifts[arg_index] = bit_position;
             }
         }
-#if !defined(__ANDROID__)
+#if !defined(DYNARMIC_IGNORE_ASSERTS) && !defined(__ANDROID__)
         // Avoids a MSVC ICE, and avoids Android NDK issue.
         DEBUG_ASSERT(std::all_of(masks.begin(), masks.end(), [](auto m) { return m != 0; }));
 #endif

src/dynarmic/tests/CMakeLists.txt

@@ -1,5 +1,7 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
+include(TargetArchitectureSpecificSources)
+
 add_executable(dynarmic_tests
     fp/FPToFixed.cpp
     fp/FPValue.cpp
@@ -42,13 +44,13 @@ if (DYNARMIC_TESTS_USE_UNICORN)
     )
 endif()
 
-if (ARCHITECTURE_riscv64)
+if ("riscv" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic_tests PRIVATE biscuit::biscuit)
 endif()
 
-if (ARCHITECTURE_x86_64)
+if ("x86_64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic_tests PRIVATE xbyak::xbyak)
-    target_sources(dynarmic_tests PRIVATE
+    target_architecture_specific_sources(dynarmic_tests "x86_64"
         x64_cpu_info.cpp
         native/preserve_xmm.cpp
     )

src/input_common/drivers/mouse.cpp

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

src/input_common/drivers/mouse.h

@@ -7,7 +7,9 @@
 #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"
@@ -101,17 +103,18 @@ public:
     Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
 
 private:
-    void UpdateStickInput();
-    void UpdateMotionInput();
+    void UpdateStickInput(Common::SteadyClock::time_point timestamp);
+    void UpdateMotionInput(Common::SteadyClock::time_point timestamp);
     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::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{};
     bool button_pressed = false;
 };
 

src/yuzu/bootmanager.cpp

@@ -538,6 +538,7 @@ 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;
@@ -552,15 +553,12 @@ 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}));
-        return;
+    } else {
+        const int center_x = width() / 2;
+        const int center_y = height() / 2;
+        QCursor::setPos(mapToGlobal(QPoint{center_x, center_y}));
     }
-
-    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,10 +37,16 @@ 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,6 +84,9 @@ 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;