From 2ade269be3f0a57bae86c23745df51c373664bd7 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sat, 7 Nov 2026 21:30:21 -0500 Subject: [PATCH] fix(gamescope): direct-touch drags work again in games that confine a hidden cursor (#2220) * gamescope: a confine is relative only while it holds the X pointer Patch 0128 made every hidden-cursor confine relative. Games that hide the system cursor, draw their own and confine the pointer to their window then took the host lock, and a direct touch drag became camera motion with no button held, so cards and items could not be dragged. A confine now goes relative once the X pointer stays away from the seat position while input moves, as when a game recentres it or clips it to a small rectangle, and returns to absolute when the pointer follows again or the confine ends. Locks and the warp follow rule are unchanged. * gamescope: a constraint without a hint is relative only while the game holds the X pointer Xwayland turns a hidden-cursor grab into a lock with no cursor position hint, so the confine-only rule never applied to games that draw their own cursor (Stardew Valley, Balatro). A hinted constraint is relative at once, as upstream. An unhinted lock or confine goes relative once the X pointer stops following the seat's motion, which a recentring or clipping game does and a drawn-cursor game does not. * gamescope: a pointer constraint is relative only while the game holds the X pointer Stardew Valley's grab with a hidden cursor becomes an Xwayland lock with a cursor position hint, which upstream made relative at once. Without relative mode that lock still follows gamescope's relative motion and touches still place the pointer, so the hold rule now decides for every constraint, hinted or not. * gamescope: a hinted lock starts relative and is released once the X pointer follows Releasing a hinted lock only through the hold rule let a recentring game's first touch swipe press the button. A hinted lock now starts relative as upstream and is released after 30 moving frames on which the X pointer follows the motion gamescope sends, counted from the relative motion while the seat is locked. * gamescope: count away frames within one half-second window * gamescope: a hint that arrives with the game's first warp starts the lock relative * fix(input): end the touch press when a program locks the pointer mid-swipe A game that only shows its pointer lock after its first warp took the first swipe as an absolute drag, with the button held until the finger lifted. The first locked move now ends the forwarded touch before sending deltas. * gamescope: a new focus window or constraint starts its own pointer hold A held state from one constrained window carried over to the next one when focus moved before a reset frame. Track the input focus window and the constraint, and restart the hold when either changes. * gamescope: read the pointer constraint under the wlserver lock GetCursorConstraint asserts the lock is held, so the hold tracker aborted as soon as a program constrained the pointer. * fix(input): a mid-swipe pointer lock ends the touch but keeps a held button The first locked move cancelled the whole direct-touch hold, releasing a right button held by a long press. It now cancels only the forwarded touch; the held button is released when the finger lifts, as before. * fix(input): extra fingers during a locked swipe stay out of the cancelled touch Once a locked swipe has ended the forwarded touch, a second finger restarted it with a new touch-down while the swipe carried on as relative motion. Extra fingers are now ignored until the swipe ends; the final lift still releases a held button. * fix(input): a swipe that ended its touch stays closed until the finger lifts --- .../com/droiddeck/launcher/SessionActivity.kt | 3 +- .../launcher/input/DirectTouchHold.kt | 8 + .../launcher/input/DirectTouchHoldTest.kt | 20 ++ tools/gamescope/PATCHES.md | 13 ++ .../0133-constraint-relative-when-held.patch | 173 ++++++++++++++++++ tools/tests/test_gamescope_pointer_hold.py | 147 +++++++++++++++ 6 files changed, 363 insertions(+), 1 deletion(-) create mode 100644 tools/gamescope/patches/0133-constraint-relative-when-held.patch create mode 100644 tools/tests/test_gamescope_pointer_hold.py diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 9ef3c92515..378e554d4a 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -4082,9 +4082,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { return true } if (event.actionMasked == MotionEvent.ACTION_DOWN) lockedSwipeUsed = false + if (lockedSwipeUsed && (event.actionMasked != MotionEvent.ACTION_MOVE || !programLocksPointer())) return true if (programLocksPointer() && event.actionMasked == MotionEvent.ACTION_MOVE) { + if (lockedSwipeUsed) directTouchHold.cancelPendingHold() else directTouchHold.cancelTouch() lockedSwipeUsed = true - directTouchHold.cancelPendingHold() val scale = sceneScale(rect) sendSceneDelta((event.x - swipeX) * scale, (event.y - swipeY) * scale) return true diff --git a/app/src/main/java/com/droiddeck/launcher/input/DirectTouchHold.kt b/app/src/main/java/com/droiddeck/launcher/input/DirectTouchHold.kt index ee8d68ef05..7a64caaac6 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/DirectTouchHold.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/DirectTouchHold.kt @@ -70,6 +70,14 @@ class DirectTouchHold( handler.removeCallbacks(hold) } + fun cancelTouch() { + handler.removeCallbacks(hold) + handler.removeCallbacks(lift) + liftPending = false + if (forwarded) touch.cancel() + forwarded = false + } + fun onTouch(event: MotionEvent): Boolean { if (event.actionMasked == MotionEvent.ACTION_DOWN) { if (liftPending) { diff --git a/app/src/test/java/com/droiddeck/launcher/input/DirectTouchHoldTest.kt b/app/src/test/java/com/droiddeck/launcher/input/DirectTouchHoldTest.kt index 9ef44f3607..20c7fe451f 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/DirectTouchHoldTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/DirectTouchHoldTest.kt @@ -141,6 +141,26 @@ class DirectTouchHoldTest { assertEquals(listOf("true at 40.0,30.0", "false at 40.0,30.0"), buttons) } + @Test fun cancelTouchEndsALiveTouchAndKeepsAHeldButton() { + touch(MotionEvent.ACTION_DOWN) + touch(MotionEvent.ACTION_MOVE, 60f) + hold.cancelTouch() + assertEquals(listOf("down 0 at 40.0,30.0", "move 0 at 60.0,30.0", "cancel"), touches) + assertTrue(buttons.isEmpty()) + + touches.clear() + hold.configure(TouchGestureConfig(longPressDelay = 500, + directHoldBehavior = TouchGestureConfig.MOUSE_BEHAVIOR_HOLD)) + touch(MotionEvent.ACTION_DOWN) + advance(500) + hold.cancelTouch() + advance(1000) + assertEquals(listOf("true at 40.0,30.0"), buttons) + assertTrue(touches.isEmpty()) + touch(MotionEvent.ACTION_UP) + assertEquals(listOf("true at 40.0,30.0", "false at 40.0,30.0"), buttons) + } + @Test fun cancelForwardsACancelWhenTheTouchIsLive() { touch(MotionEvent.ACTION_DOWN) touch(MotionEvent.ACTION_MOVE, 60f) diff --git a/tools/gamescope/PATCHES.md b/tools/gamescope/PATCHES.md index 4736d32320..813325477b 100644 --- a/tools/gamescope/PATCHES.md +++ b/tools/gamescope/PATCHES.md @@ -302,6 +302,7 @@ For games that confine a visible cursor and warp it, which the automatic rule ca The rule only counted a lock with a cursor position hint. A game that hides the cursor and confines the pointer through a grab (Wine's ClipCursor) has a constraint with no hint, so the nested pointer stayed absolute, the constraint held the X pointer still and no raw motion was produced: the camera froze. +0133 narrows this, and the upstream hint rule, to games that hold the X pointer. ## 0129 steamcompmgr, wayland: release a pointer lock at the game's pointer @@ -331,3 +332,15 @@ With `--follow-game-window-mode`, the outer window of a nested SDL gamescope fol asking for `_NET_WM_STATE_FULLSCREEN`, or a Steam game covering the X screen without minimise or maximise functions or decorations in `_MOTIF_WM_HINTS`, makes the outer window fullscreen on the desktop. Anything else makes it a normal window of the game window's size, or a maximised one when that size does not fit the desktop with its title bar and panel. A change is applied only when the wanted mode changes, so a manual resize or Super+F stays. + +## 0133 steamcompmgr, wlserver: a pointer constraint is relative only while the game holds the X pointer + +A game that hides the system cursor, draws its own and grabs the pointer to its window (Stardew Valley, Balatro) gets a lock +from Xwayland, which emulates the game's warps with a cursor position hint. Upstream kept any hinted lock relative and 0128 +added every other constraint, so gamescope held the host's pointer lock and DroidDeck turned every direct touch swipe into +camera motion: dragging in those games only moved their cursor. Without relative mode such a lock still follows gamescope's +relative motion and touches still place the pointer. gamescope now compares the motion it sends (seat movement, or relative +motion while the seat is locked) with how the X pointer moves. A hinted constraint starts relative, as upstream, also when its hint arrives with the game's first warp, and is released +after 30 moving frames on which the X pointer follows. Any constraint goes relative once the X pointer moves less than a quarter +of that motion on three frames within half a second, as it does when the game recentres it or clips it to a small rectangle +(PEAK). `tools/tests/test_gamescope_pointer_hold.py` compiles the rule from this patch. diff --git a/tools/gamescope/patches/0133-constraint-relative-when-held.patch b/tools/gamescope/patches/0133-constraint-relative-when-held.patch new file mode 100644 index 0000000000..91fa1b1ac6 --- /dev/null +++ b/tools/gamescope/patches/0133-constraint-relative-when-held.patch @@ -0,0 +1,173 @@ +diff --git a/src/steamcompmgr.cpp b/src/steamcompmgr.cpp +--- a/src/steamcompmgr.cpp ++++ b/src/steamcompmgr.cpp +@@ -3165,6 +3165,128 @@ + wlserver_unlock(); + } + ++struct PointerHold ++{ ++ int nAwayFrames = 0; ++ int nFreeFrames = 0; ++ uint64_t ulFirstAway = 0; ++ bool bHeld = false; ++}; ++ ++static bool pointer_hold_step( PointerHold &state, bool bConstrained, double flSeatDX, double flSeatDY, double flPointerDX, double flPointerDY, uint64_t ulNow ) ++{ ++ if ( !bConstrained ) ++ { ++ state = PointerHold{}; ++ return false; ++ } ++ ++ const double flSeat = std::max( std::abs( flSeatDX ), std::abs( flSeatDY ) ); ++ if ( flSeat < 4.0 ) ++ return state.bHeld; ++ ++ const double flMiss = std::max( std::abs( flSeatDX - flPointerDX ), std::abs( flSeatDY - flPointerDY ) ); ++ if ( flMiss > flSeat * 0.75 ) ++ { ++ if ( state.nAwayFrames == 0 || ulNow - state.ulFirstAway > 500'000'000ul ) ++ { ++ state.nAwayFrames = 0; ++ state.ulFirstAway = ulNow; ++ } ++ state.nFreeFrames = 0; ++ if ( ++state.nAwayFrames >= 3 ) ++ state.bHeld = true; ++ } ++ else if ( state.bHeld && ++state.nFreeFrames >= 30 ) ++ { ++ state = PointerHold{}; ++ } ++ ++ return state.bHeld; ++} ++ ++static bool s_bPointerHeld = false; ++ ++static void update_pointer_hold( global_focus_t *pFocus, bool bConstrained, bool bHinted ) ++{ ++ static PointerHold s_Hold; ++ static bool s_bTracking = false; ++ static double s_flSeatX = 0.0; ++ static double s_flSeatY = 0.0; ++ static int s_nRootX = 0; ++ static int s_nRootY = 0; ++ static bool s_bHinted = false; ++ static const steamcompmgr_win_t *s_pWindow = nullptr; ++ static const struct wlr_pointer_constraint_v1 *s_pConstraint = nullptr; ++ ++ wlserver_lock(); ++ const double flX = wlserver.mouse_surface_cursorx; ++ const double flY = wlserver.mouse_surface_cursory; ++ const double flSentX = wlserver.flSentDX; ++ const double flSentY = wlserver.flSentDY; ++ const struct wlr_pointer_constraint_v1 *pConstraint = wlserver.GetCursorConstraint(); ++ wlserver.flSentDX = 0.0; ++ wlserver.flSentDY = 0.0; ++ wlserver_unlock(); ++ ++ if ( !bConstrained || !pFocus->cursor ) ++ { ++ s_bTracking = false; ++ s_bHinted = false; ++ s_bPointerHeld = pointer_hold_step( s_Hold, false, 0.0, 0.0, 0.0, 0.0, 0 ); ++ return; ++ } ++ ++ const steamcompmgr_win_t *pWindow = pFocus->inputFocusWindow; ++ if ( pWindow != s_pWindow || pConstraint != s_pConstraint ) ++ { ++ s_bTracking = false; ++ s_bHinted = false; ++ } ++ s_pWindow = pWindow; ++ s_pConstraint = pConstraint; ++ ++ if ( s_bTracking && bHinted && !s_bHinted ) ++ { ++ s_Hold = PointerHold{}; ++ s_Hold.bHeld = true; ++ s_bPointerHeld = true; ++ } ++ s_bHinted = bHinted; ++ ++ double flDX = flX - s_flSeatX; ++ double flDY = flY - s_flSeatY; ++ if ( flDX == 0.0 && flDY == 0.0 ) ++ { ++ flDX = flSentX; ++ flDY = flSentY; ++ } ++ ++ if ( s_bTracking && flDX == 0.0 && flDY == 0.0 ) ++ return; ++ ++ int nRootX = 0; ++ int nRootY = 0; ++ pFocus->cursor->QueryRootPosition( &nRootX, &nRootY ); ++ ++ if ( s_bTracking ) ++ { ++ s_bPointerHeld = pointer_hold_step( s_Hold, true, flDX, flDY, nRootX - s_nRootX, nRootY - s_nRootY, get_time_in_nanos() ); ++ } ++ else ++ { ++ s_Hold = PointerHold{}; ++ s_Hold.bHeld = bHinted; ++ s_bPointerHeld = bHinted; ++ } ++ ++ s_bTracking = true; ++ s_flSeatX = flX; ++ s_flSeatY = flY; ++ s_nRootX = nRootX; ++ s_nRootY = nRootY; ++} ++ + bool ShouldDrawCursor() + { + if ( relative_mouse_forced() ) +@@ -11029,9 +11151,15 @@ + nRelativeMouse != 2 && !bExcludedAppId && !bHasPointerConstraint && !window_is_steam( pPaintFocus->inputFocusWindow ) ); + } + ++ if ( vblank ) ++ update_pointer_hold( pPaintFocus, bHasPointerConstraint && bImageEmpty && nRelativeMouse != 2 && !bExcludedAppId, ++ pPaintFocus->cursor && pPaintFocus->cursor->IsConstrained() ); ++ ++ const bool bGameHoldsPointer = bHasPointerConstraint && s_bPointerHeld; ++ + const bool bRelativeMouseMode = nRelativeMouse == 2 + ? false +- : ( bForcedRelativeMouse || s_bFollowClientPointer || ( bImageEmpty && bHasPointerConstraint && !bExcludedAppId ) ); ++ : ( bForcedRelativeMouse || s_bFollowClientPointer || ( bImageEmpty && bGameHoldsPointer && !bExcludedAppId ) ); + + static bool s_bRelativeMouseMode = false; + if ( s_bRelativeMouseMode && !bRelativeMouseMode && pPaintFocus->cursor && +diff --git a/src/wlserver.cpp b/src/wlserver.cpp +--- a/src/wlserver.cpp ++++ b/src/wlserver.cpp +@@ -346,6 +346,8 @@ + { + assert( wlserver_is_lock_held() ); + ++ wlserver.flSentDX += unaccel_dx; ++ wlserver.flSentDY += unaccel_dy; + wlr_relative_pointer_manager_v1_send_relative_motion( wlserver.relative_pointer_manager, wlserver.wlr.seat, 0, unaccel_dx, unaccel_dy, unaccel_dx, unaccel_dy ); + } + +diff --git a/src/wlserver.hpp b/src/wlserver.hpp +--- a/src/wlserver.hpp ++++ b/src/wlserver.hpp +@@ -171,6 +171,8 @@ + bool bFollowClientPointer = false; + double flFollowDX = 0.0; + double flFollowDY = 0.0; ++ double flSentDX = 0.0; ++ double flSentDY = 0.0; + + bool button_held[ WLSERVER_BUTTON_COUNT ]; + std::set touch_down_ids; diff --git a/tools/tests/test_gamescope_pointer_hold.py b/tools/tests/test_gamescope_pointer_hold.py new file mode 100644 index 0000000000..6c8d93ee4c --- /dev/null +++ b/tools/tests/test_gamescope_pointer_hold.py @@ -0,0 +1,147 @@ +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +PATCH = ROOT / "tools/gamescope/patches/0133-constraint-relative-when-held.patch" + + +def added_source(): + return "\n".join(line[1:] for line in PATCH.read_text().splitlines() if line.startswith("+") and not line.startswith("+++")) + + +def block(text, start): + begin = text.index(start) + return text[begin:text.index("\n}", begin) + 3] + + +def rules(): + text = added_source() + return "\n".join([ + block(text, "struct PointerHold"), + block(text, "static bool pointer_hold_step"), + ]) + + +PREAMBLE = r''' +#include +#include +#include +#include +#include +''' + +MAIN = r''' +static const uint64_t FRAME = 16'666'667ul; + +static bool run(PointerHold &state, int frames, double seatDX, double seatDY, double pointerDX, double pointerDY, uint64_t &now, bool constrained = true) { + bool held = state.bHeld; + for (int i = 0; i < frames; i++) { + now += FRAME; + held = pointer_hold_step(state, constrained, seatDX, seatDY, pointerDX, pointerDY, now); + } + return held; +} + +int main() { + uint64_t now = 1'000'000'000ul; + + PointerHold cursorGame; + assert(!run(cursorGame, 600, 12.0, -9.0, 12.0, -9.0, now)); + assert(!run(cursorGame, 600, 40.0, 3.0, 39.0, 3.0, now)); + assert(!run(cursorGame, 1, 30.0, 0.0, 0.0, 0.0, now)); + assert(!run(cursorGame, 1, 30.0, 0.0, 30.0, 0.0, now)); + assert(!run(cursorGame, 1, 30.0, 0.0, 0.0, 0.0, now)); + assert(!run(cursorGame, 120, 2.0, 1.0, 0.0, 0.0, now)); + + PointerHold offset; + assert(!run(offset, 600, 25.0, 25.0, 25.0, 25.0, now)); + + PointerHold recentring; + assert(!run(recentring, 2, -40.0, 12.0, 0.0, 0.0, now)); + assert(run(recentring, 1, -40.0, 12.0, 1.0, 0.0, now)); + assert(run(recentring, 600, 0.0, 0.0, 0.0, 0.0, now)); + assert(run(recentring, 29, 10.0, 4.0, 10.0, 4.0, now)); + assert(run(recentring, 1, 20.0, 0.0, 0.0, 0.0, now)); + assert(run(recentring, 29, 10.0, 4.0, 10.0, 4.0, now)); + assert(!run(recentring, 1, 10.0, 4.0, 10.0, 4.0, now)); + + PointerHold clipped; + assert(run(clipped, 3, 0.0, 30.0, 0.0, 2.0, now)); + + PointerHold spaced; + for (int i = 0; i < 10; i++) { + assert(!run(spaced, 1, 50.0, 0.0, 0.0, 0.0, now)); + now += 600'000'000ul; + } + + PointerHold hinted; + hinted.bHeld = true; + assert(run(hinted, 29, 0.0, 15.0, 0.0, 15.0, now)); + assert(!run(hinted, 1, 0.0, 15.0, 0.0, 15.0, now)); + + PointerHold hintedCamera; + hintedCamera.bHeld = true; + assert(run(hintedCamera, 600, 30.0, -8.0, 0.0, 0.0, now)); + + PointerHold chained; + for (int i = 0; i < 6; i++) { + assert(!run(chained, 1, 50.0, 0.0, 0.0, 0.0, now)); + now += 400'000'000ul; + } + + PointerHold released; + assert(run(released, 3, 0.0, -25.0, 0.0, 0.0, now)); + assert(!run(released, 1, 0.0, -25.0, 0.0, 0.0, now, false)); + assert(!run(released, 2, 0.0, -25.0, 0.0, 0.0, now)); + + puts("ok"); + return 0; +} +''' + + +@unittest.skipUnless(shutil.which("c++"), "needs a C++ compiler") +class PointerHoldTest(unittest.TestCase): + def test_only_a_game_that_holds_the_x_pointer_goes_relative(self): + with tempfile.TemporaryDirectory() as tmp: + source = Path(tmp) / "hold.cpp" + binary = Path(tmp) / "hold" + source.write_text(PREAMBLE + rules() + MAIN) + subprocess.run(["c++", "-std=c++17", "-Wall", "-Wextra", "-Werror", str(source), "-o", str(binary)], check=True) + self.assertEqual(subprocess.run([str(binary)], capture_output=True, text=True, check=True).stdout.strip(), "ok") + + def test_a_hinted_constraint_starts_relative_and_others_wait_for_the_hold(self): + added = [line.strip() for line in added_source().splitlines()] + self.assertIn("update_pointer_hold( pPaintFocus, bHasPointerConstraint && bImageEmpty && nRelativeMouse != 2 && !bExcludedAppId,", added) + self.assertIn("pPaintFocus->cursor && pPaintFocus->cursor->IsConstrained() );", added) + self.assertIn("s_Hold.bHeld = bHinted;", added) + self.assertIn("if ( s_bTracking && bHinted && !s_bHinted )", added) + self.assertIn("const bool bGameHoldsPointer = bHasPointerConstraint && s_bPointerHeld;", added) + self.assertIn(": ( bForcedRelativeMouse || s_bFollowClientPointer || ( bImageEmpty && bGameHoldsPointer && !bExcludedAppId ) );", added) + + def test_a_new_window_or_constraint_starts_its_own_hold(self): + tracker = block(added_source(), "static void update_pointer_hold") + reset = tracker.index("if ( pWindow != s_pWindow || pConstraint != s_pConstraint )") + self.assertIn("const steamcompmgr_win_t *pWindow = pFocus->inputFocusWindow;", tracker) + constraint = tracker.index("wlserver.GetCursorConstraint();") + self.assertLess(tracker.index("wlserver_lock();"), constraint) + self.assertLess(constraint, tracker.index("wlserver_unlock();")) + self.assertLess(reset, tracker.index("if ( s_bTracking && bHinted && !s_bHinted )")) + self.assertIn("s_bTracking = false;", tracker[reset:reset + 120]) + + def test_the_motion_sent_to_clients_is_counted(self): + added = [line.strip() for line in added_source().splitlines()] + self.assertIn("wlserver.flSentDX += unaccel_dx;", added) + self.assertIn("wlserver.flSentDY += unaccel_dy;", added) + + def test_the_forced_and_follow_rules_are_unchanged(self): + removed = [line[1:].strip() for line in PATCH.read_text().splitlines() if line.startswith("-") and not line.startswith("---")] + self.assertEqual(removed, [": ( bForcedRelativeMouse || s_bFollowClientPointer || ( bImageEmpty && bHasPointerConstraint && !bExcludedAppId ) );"]) + + +if __name__ == "__main__": + unittest.main()