monolith

public

Star0

Fork 0

Watch0

247 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `9529672263b7`

tarball

atagen <boss@atagen.co>2026-10-19 09:47 UTC

5 files changed+89-18

input: send relative pointer motion with unaccelerated deltas

Games that read raw mouse movement had only absolute positions to go on, so camera look broke at screen edges. pointer_motion now takes a Motion that says how the pointer moved. libinput deltas pass through as Relative, absolute devices and the nested host derive a delta from their last position, and warps send none so mouse-follows-focus never reads as a flick.

Modified file: crates/monolith/src/drm.rs+5 additions−3 deletions@@ -4,6 +4,7 @@
 
 use crate::backend::{Backend, logical_area};
 use crate::devices::Devices;
+use crate::input::Motion;
 use crate::scene::Draw;
 use crate::state::Services;
 use crate::state::{State, now_ns};
@@ -1148,8 +1149,9 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             state.key(event.key_code(), event.state(), time);
         }
         InputEvent::PointerMotion { event } => {
-            let pos = clamp(state, state.input.pointer_pos + event.delta());
-            state.pointer_to(pos, event.time());
+            let (delta, unaccel) = (event.delta(), event.delta_unaccel());
+            let pos = clamp(state, state.input.pointer_pos + delta);
+            state.pointer_motion(pos, Motion::Relative { delta, unaccel }, event.time());
             state.pointer_frame();
             state.dirty.cursor = true;
         }
@@ -1166,7 +1168,7 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             };
             let p = event.position_transformed((area.w as i32, area.h as i32).into());
             let pos = clamp(state, Point::from((area.x + p.x, area.y + p.y)));
-            state.pointer_to(pos, event.time());
+            state.pointer_motion(pos, Motion::Absolute, event.time());
             state.pointer_frame();
             state.dirty.cursor = true;
         }

Modified file: crates/monolith/src/globals.rs+3 additions@@ -22,6 +22,7 @@ use smithay::wayland::image_capture_source::{
 use smithay::wayland::image_copy_capture::ImageCopyCaptureState;
 use smithay::wayland::output::OutputManagerState;
 use smithay::wayland::presentation::PresentationState;
+use smithay::wayland::relative_pointer::RelativePointerManagerState;
 use smithay::wayland::selection::data_device::DataDeviceState;
 use smithay::wayland::selection::ext_data_control::DataControlState as ExtDataControlState;
 use smithay::wayland::selection::primary_selection::PrimarySelectionState;
@@ -70,6 +71,7 @@ pub struct Protocols {
     _single_pixel_buffer: SinglePixelBufferState,
     _fractional_scale: FractionalScaleManagerState,
     _presentation: PresentationState,
+    _relative_pointer: RelativePointerManagerState,
 }
 
 impl Protocols {
@@ -134,6 +136,7 @@ impl Protocols {
             _single_pixel_buffer: SinglePixelBufferState::new::<State>(dh),
             _fractional_scale: FractionalScaleManagerState::new::<State>(dh),
             _presentation: PresentationState::new::<State>(dh, Monotonic::ID as u32),
+            _relative_pointer: RelativePointerManagerState::new::<State>(dh),
         }
     }
 }

Modified file: crates/monolith/src/input.rs+60 additions−7 deletions@@ -7,15 +7,41 @@ use monolith_layout::{Axis, Dir, Layout, MIN_FLOAT_SIZE, Rect, WindowId, clamp_f
 use smithay::backend::input::{ButtonState, InputTime, KeyState};
 use smithay::backend::session::Session;
 use smithay::input::keyboard::{FilterResult, Keycode, xkb};
-use smithay::input::pointer::{AxisFrame, ButtonEvent, CursorIcon, CursorImageStatus, MotionEvent};
+use smithay::input::pointer::{
+    AxisFrame, ButtonEvent, CursorIcon, CursorImageStatus, MotionEvent, RelativeMotionEvent,
+};
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::reexports::wayland_server::Resource;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{Logical, Point, SERIAL_COUNTER};
 use smithay::wayland::shell::wlr_layer::Layer;
 use smithay::xwayland::xwm::ResizeEdge;
 
+/// How the pointer got to where a motion wants it.
+pub enum Motion {
+    Relative {
+        delta: Point<f64, Logical>,
+        unaccel: Point<f64, Logical>,
+    },
+    Absolute,
+    Warp,
+}
+
 impl State {
-    pub fn pointer_to(&mut self, pos: Point<f64, Logical>, time: InputTime) {
+    pub fn pointer_motion(&mut self, wanted: Point<f64, Logical>, motion: Motion, time: InputTime) {
+        let (delta, unaccel) = match motion {
+            Motion::Relative { delta, unaccel } => {
+                self.input.absolute = None;
+                (delta, unaccel)
+            }
+            Motion::Absolute => {
+                let from = self.input.absolute.replace(wanted);
+                let delta = wanted - from.unwrap_or(self.input.pointer_pos);
+                (delta, delta)
+            }
+            Motion::Warp => Default::default(),
+        };
+        let pos = wanted;
         self.input.pointer_pos = pos;
         self.follow_pointer_scale();
         self.activity();
@@ -32,6 +58,7 @@ impl State {
         if std::mem::replace(&mut self.input.hover, hover) != hover {
             self.dirty.cursor = true;
         }
+        self.relative_motion(under.clone(), delta, unaccel, time);
         pointer.motion(
             self,
             under,
@@ -48,6 +75,36 @@ impl State {
         }
     }
 
+    fn relative_motion(
+        &mut self,
+        under: Option<(WlSurface, Point<f64, Logical>)>,
+        delta: Point<f64, Logical>,
+        unaccel: Point<f64, Logical>,
+        time: InputTime,
+    ) {
+        if delta == Point::default() && unaccel == Point::default() {
+            return;
+        }
+        if let Some(pointer) = self.input.seat.get_pointer() {
+            let event = RelativeMotionEvent {
+                delta,
+                delta_unaccel: unaccel,
+                time,
+            };
+            pointer.relative_motion(self, under, &event);
+        }
+    }
+
+    /// Puts the pointer somewhere without telling clients it moved, which a
+    /// relative motion would, and without letting focus follow it.
+    pub fn warp_pointer(&mut self, pos: Point<f64, Logical>, time: InputTime) {
+        self.input.warping = true;
+        self.pointer_motion(pos, Motion::Warp, time);
+        self.input.warping = false;
+        self.pointer_frame();
+        self.dirty.cursor = true;
+    }
+
     pub fn pointer_button(&mut self, button: u32, pressed: ButtonState, time: InputTime) {
         self.activity();
         if pressed == ButtonState::Released {
@@ -246,14 +303,10 @@ impl State {
         let Some((_, r, _)) = focused.and_then(|id| self.wm.get(id)?.placed) else {
             return;
         };
-        self.input.warping = true;
-        self.pointer_to(
+        self.warp_pointer(
             Point::from((r.x + r.w / 2.0, r.y + r.h / 2.0)),
             InputTime::now(),
         );
-        self.input.warping = false;
-        self.pointer_frame();
-        self.dirty.cursor = true;
     }
 }
 

Modified file: crates/monolith/src/nested/input.rs+17 additions−8 deletions@@ -1,13 +1,22 @@
 //! The host seat, forwarded into monolith's own.
 
+use crate::input::Motion;
 use crate::state::State;
 use smithay::backend::input::{Axis, ButtonState, InputTime, KeyState};
 use smithay::input::keyboard::Keycode;
 use smithay::input::pointer::AxisFrame;
-use smithay::utils::Point;
+use smithay::utils::{Logical, Point};
 use wayland_client::protocol::{wl_keyboard, wl_pointer, wl_seat};
 use wayland_client::{Connection, Dispatch, QueueHandle, WEnum};
 
+fn host_position(state: &State, x: f64, y: f64) -> Point<f64, Logical> {
+    let scale = state
+        .backend
+        .nested()
+        .map_or(1.0, |h| h.output.current_scale().fractional_scale());
+    Point::from((x / scale, y / scale))
+}
+
 impl Dispatch<wl_seat::WlSeat, ()> for State {
     fn event(
         _: &mut Self,
@@ -46,18 +55,18 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                 surface_x,
                 surface_y,
                 ..
+            } => {
+                let pos = host_position(state, surface_x, surface_y);
+                state.input.absolute = Some(pos);
+                state.pointer_motion(pos, Motion::Absolute, time);
             }
-            | wl_pointer::Event::Motion {
+            wl_pointer::Event::Motion {
                 surface_x,
                 surface_y,
                 ..
             } => {
-                let scale = state
-                    .backend
-                    .nested()
-                    .map_or(1.0, |h| h.output.current_scale().fractional_scale());
-                let pos = Point::from((surface_x / scale, surface_y / scale));
-                state.pointer_to(pos, time);
+                let pos = host_position(state, surface_x, surface_y);
+                state.pointer_motion(pos, Motion::Absolute, time);
             }
             wl_pointer::Event::Button {
                 button,

Modified file: crates/monolith/src/state.rs+4 additions@@ -65,6 +65,9 @@ pub struct Input {
     pub hover: Option<crate::input::Edges>,
     /// The output the pointer was last on, whose scale cursor and drag icon surfaces follow.
     pub pointer_output: Option<String>,
+    /// Where the last absolute device event put the pointer, so the next
+    /// one yields a relative delta even while the pointer is held in place.
+    pub absolute: Option<Point<f64, Logical>>,
 }
 
 /// What needs doing after this batch of events.
@@ -198,6 +201,7 @@ impl State {
                 dnd_icon: None,
                 hover: None,
                 pointer_output: None,
+                absolute: None,
             },
             dirty: Dirty {
                 redraw: true,

monolith

Commit 9529672263b7

Commit `9529672263b7`