Numeric drag: pin and hide the pointer, as the Chili version does

Dragging a value now behaves like a content-creation tool: the pointer is
swapped for the empty cursor and warped back to where the drag began after every
move, so the value can be pushed as far as the user likes and the cursor never
runs off the field, the panel, or the screen. It is restored to the anchor when
the drag ends.

This is what NumericField:__StartDragging/__StopDragging already did in Lua
(SB.SetMouseCursor("empty") + Spring.WarpMouse), and the bindings for it were
already there -- so no engine change was needed after all. The cursor has to be
re-asserted every tick: the engine syncs the cursor to whatever RmlUi is
hovering on each frame, so setting it once at dragstart is undone immediately.

The harness grew `move_relative`, because a pinned pointer consumes *relative*
motion; absolute `mousemove` fights the warp (the pointer is put back on its
anchor, and the next absolute move re-applies the whole offset from it).

Objects -> Collision gets its own scenario, split out of props so both stay
quick and focused. It checks the thing the editor is for: with the debug volume
shown, scaling an axis and changing the volume type must visibly redraw the
shape on the object -- asserted by pixel diff, not just by the command.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: gajop

native/src/sbc/panels/drag_cursor.rs

@@ -0,0 +1,71 @@
+//! The pointer while a numeric field is being dragged.
+//!
+//! A port of what `NumericField:__StartDragging` / `__StopDragging` do in Lua:
+//! swap the cursor for an empty one and pin the pointer to where the drag began,
+//! warping it back after every move. The value then follows the mouse for as far
+//! as the user cares to push it, and the pointer never runs off the field, off
+//! the panel, or off the screen -- the way every content-creation tool behaves.
+//!
+//! The pointer is restored to the anchor when the drag ends, so the cursor is
+//! exactly where the user left it.
+
+use spring_native::prelude::NativeInterfaceRef;
+
+/// Lua assigns a cursor named "empty" and selects it; the name is the asset.
+const EMPTY_CURSOR: &str = "empty";
+
+#[derive(Default)]
+pub(crate) struct DragCursor {
+    /// Where the drag began, in engine mouse coordinates. The pointer is warped
+    /// back here every tick, so it never actually moves.
+    anchor: Option<(i32, i32)>,
+    assigned: bool,
+}
+
+impl DragCursor {
+    /// Where the pointer is pinned. The drag's delta is measured from here,
+    /// because the pointer is put back on it after every move.
+    pub(crate) fn anchor_x(&self) -> Option<f32> {
+        self.anchor.map(|(x, _)| x as f32)
+    }
+
+    pub(crate) fn begin(&mut self, interface: &NativeInterfaceRef) {
+        let Ok(mouse) = interface.input().get_mouse_state() else {
+            return;
+        };
+        self.anchor = Some((mouse.x as i32, mouse.y as i32));
+
+        let ctrl = interface.unsynced_ctrl();
+        if !self.assigned {
+            // Lua does the same on first use: the cursor has to exist before it
+            // can be selected.
+            let _ = ctrl.assign_mouse_cursor(EMPTY_CURSOR, EMPTY_CURSOR, true, true);
+            self.assigned = true;
+        }
+        let _ = ctrl.set_mouse_cursor(EMPTY_CURSOR, 1.0);
+    }
+
+    /// Pin the pointer back to the anchor. Called after the value has taken the
+    /// movement, so the motion is consumed rather than lost.
+    pub(crate) fn hold(&self, interface: &NativeInterfaceRef) {
+        let Some((x, y)) = self.anchor else {
+            return;
+        };
+        let ctrl = interface.unsynced_ctrl();
+        let _ = ctrl.warp_mouse(x, y);
+        // Re-assert it every tick: the engine syncs the cursor to whatever RmlUi
+        // is hovering on each update, so setting it once at dragstart is undone
+        // on the very next frame.
+        let _ = ctrl.set_mouse_cursor(EMPTY_CURSOR, 1.0);
+    }
+
+    pub(crate) fn end(&mut self, interface: &NativeInterfaceRef) {
+        let ctrl = interface.unsynced_ctrl();
+        if let Some((x, y)) = self.anchor.take() {
+            let _ = ctrl.warp_mouse(x, y);
+        }
+        // An empty name restores the engine's own cursor, as Lua's bare
+        // `SB.SetMouseCursor()` does.
+        let _ = ctrl.set_mouse_cursor("", 1.0);
+    }
+}

native/src/sbc/panels/input.rs

@@ -1,5 +1,6 @@
 use spring_native::prelude::{Error, NativeInterfaceRef};
 
+use crate::sbc::panels::drag_cursor::DragCursor;
 use crate::sbc::panels::editor::Editor;
 use crate::sbc::panels::field::{ChangeQueue, CommitRequest, InteractionEvent, InteractionQueue};
 use crate::sbc::panels::view::PanelView;
@@ -41,6 +42,8 @@ pub(crate) struct PanelInput {
     cursor_x: f32,
     changes: ChangeQueue,
     interactions: InteractionQueue,
+    /// Pins and hides the pointer while a field is being dragged.
+    cursor: DragCursor,
 }
 
 impl PanelInput {
@@ -53,6 +56,7 @@ impl PanelInput {
             cursor_x: 0.0,
             changes,
             interactions,
+            cursor: DragCursor::default(),
         }
     }
 
@@ -99,21 +103,30 @@ impl PanelInput {
         let DragState::Dragging { field } = &self.drag else {
             return DragTick::Idle;
         };
-        let dx = x - self.last_mouse_x;
-        if dx == 0.0 {
+        // The pointer is pinned to where the drag began and warped back after
+        // every move, so the movement to consume is its distance from that
+        // anchor -- not from wherever it was last tick.
+        let Some(anchor_x) = self.cursor.anchor_x() else {
             return DragTick::Idle;
-        }
-        self.last_mouse_x = x;
+        };
+        let dx = x - anchor_x;
+        let field = field.clone();
         let mult = if self.fine_drag_multiplier(interface) {
             FINE_DRAG_MULT
         } else {
             1.0
         };
-        let field = field.clone();
-        let Some(ed) = editor else {
-            return DragTick::Idle;
+
+        let moved = match editor {
+            Some(ed) if dx != 0.0 => ed.drag_field(&field, dx * mult, interface),
+            _ => false,
         };
-        if ed.drag_field(&field, dx * mult, interface) {
+        // Hold the pointer every tick of the drag, not only when it moved: the
+        // engine re-asserts its own cursor each frame, so a still mouse would
+        // get the arrow back.
+        self.cursor.hold(interface);
+
+        if moved {
             DragTick::Moved(field)
         } else {
             DragTick::Idle
@@ -134,7 +147,10 @@ impl PanelInput {
     /// RmlUi decides what is a drag: it captures the pointer on `dragstart` and
     /// delivers `dragend` wherever the button is released, even off the panel.
     /// A press that never became a drag is a click, and opens the inline editor.
-    pub(crate) fn process_interactions(&mut self) -> Vec<PendingAction> {
+    pub(crate) fn process_interactions(
+        &mut self,
+        interface: &NativeInterfaceRef,
+    ) -> Vec<PendingAction> {
         let events: Vec<InteractionEvent> = self.interactions.borrow_mut().drain(..).collect();
         let mut actions = Vec::new();
         for event in events {
@@ -144,7 +160,8 @@ impl PanelInput {
                     self.last_mouse_x = self.cursor_x;
                 }
                 InteractionEvent::DragStart { field } => {
-                    self.last_mouse_x = self.cursor_x;
+                    // Pin and hide the pointer for the length of the drag.
+                    self.cursor.begin(interface);
                     self.drag = DragState::Dragging {
                         field: field.clone(),
                     };
@@ -153,6 +170,7 @@ impl PanelInput {
                     actions.push(PendingAction::DragStart(field));
                 }
                 InteractionEvent::DragEnd { field } => {
+                    self.cursor.end(interface);
                     self.drag = DragState::Idle;
                     actions.push(PendingAction::DragEnd(field));
                 }

native/src/sbc/panels/manager.rs

@@ -152,7 +152,7 @@ impl PanelManager {
         self.input.set_cursor(&self.interface);
 
         // Pointer interactions: RmlUi's drag, or a click that opens the editor.
-        for action in self.input.process_interactions() {
+        for action in self.input.process_interactions(&self.interface) {
             match action {
                 PendingAction::DragStart(field) => {
                     // Remember what the drag began from, so undo returns to it.

native/src/sbc/panels/mod.rs

@@ -1,5 +1,6 @@
 mod asset_picker;
 mod color_picker;
+mod drag_cursor;
 mod editor;
 mod editor_base;
 mod editors;

tools/e2e/cases.py

@@ -15,6 +15,7 @@
     "info-panel",
     "settings-panel",
     "props-panel",
+    "collision",
     "selection",
     "cursortip",
     "notifications",
@@ -211,6 +212,14 @@ def target_cases(target: str, case: str) -> list[Case]:
             ),
         ]
         return cases
+    if target == "collision":
+        return [
+            Case(
+                name="collision-rust",
+                flags={"chonsole": "rust", "ui": "rust"},
+                scenario="collision",
+            ),
+        ]
     if target == "selection":
         return [
             Case(

tools/e2e/runner.py

@@ -275,6 +275,27 @@ def move(self, x: int, y: int, delay: float = 0.08) -> None:
         run("xdotool", "mousemove", "--window", self.window, str(x), str(y))
         time.sleep(delay)
 
+    def move_relative(self, dx: int, dy: int = 0, steps: int = 6, delay: float = 0.06) -> None:
+        """Move the mouse *by* an offset, the way a real mouse reports motion.
+
+        A field drag pins the pointer and warps it back after every move, so what
+        it consumes is relative motion. Absolute `mousemove` fights that: the
+        pointer is put back on its anchor and the next absolute move re-applies
+        the whole offset from it.
+        """
+        self.require_window()
+        self.event("move_relative", dx=dx, dy=dy, steps=steps)
+        for _ in range(steps):
+            run(
+                "xdotool",
+                "mousemove_relative",
+                "--sync",
+                "--",
+                str(round(dx / steps)),
+                str(round(dy / steps)),
+            )
+            time.sleep(delay)
+
     def wheel(self, x: int, y: int, clicks: int = 1, up: bool = True, delay: float = 0.25) -> None:
         """Scroll the wheel over a point. Over the map this zooms the camera,
         which is the only way to get close enough to *see* what a scenario placed

tools/e2e/scenarios/objects.py

@@ -157,29 +157,33 @@ def props_panel(run_state: E2ERun) -> None:
     run_state.assert_screenshot_pixels(before, after, min_changed=400)
 
     # Dragging a numeric field changes it without ever entering text mode, and
-    # commits once on release.
-    run_state.drag(left + 58, 223, left + 178, 223, steps=8)
+    # commits once on release. The drag pins the pointer and warps it back after
+    # every move (as content-creation tools do), so the motion has to be
+    # relative -- absolute moves would fight the warp.
+    run_state.press(left + 58, 223)
+    run_state.move_relative(120)
+    # Mid-drag: the pointer is pinned to where the drag began and drawn as the
+    # empty cursor, so nothing follows the mouse across the panel.
+    run_state.screenshot("props-pos-dragging")
+    run_state.release(left + 58, 223)
     run_state.screenshot("props-pos-dragged")
     run_state.assert_any_command(
         "SetObjectParamCommand",
         key="pos",
         value=lambda v: isinstance(v, dict) and v.get("x", 0) > 1500.5,
     )
 
-    # Releasing a drag *outside* the panel must still end it. RmlUi never sees
-    # that mouseup, so the drag can only be ended by the engine's release
-    # callback -- and if that never arrives the field stays latched to the mouse
-    # forever, which is the bug this pins down.
-    # This drag ends up left of where it started, so the value comes down; the
-    # previous one left it at ~1620, so only this drag's commit can be below.
+    # Releasing a drag with the pointer far outside the panel must still end it:
+    # RmlUi's drag capture delivers `dragend` wherever the button comes up, and
+    # nothing else can (the engine never hands the plugin a release for a press
+    # the panel's RmlUi consumed).
     run_state.press(left + 58, 223)
-    run_state.move(left + 150, 223, delay=0.15)
-    run_state.move(left - 300, 500, delay=0.2)        # out over the map
+    run_state.move_relative(-400, 260)               # out over the map
     run_state.release(left - 300, 500)
     dragged = run_state.assert_any_command(
         "SetObjectParamCommand",
         key="pos",
-        value=lambda v: isinstance(v, dict) and v.get("x", 9999) < 1400.0,
+        value=lambda v: isinstance(v, dict) and v.get("x", 9999) < 1500.0,
     )
     # Now moving the mouse must not keep changing it: the drag is over.
     run_state.move(left - 600, 500, delay=0.4)
@@ -196,29 +200,65 @@ def props_panel(run_state: E2ERun) -> None:
         value=lambda v: isinstance(v, dict),
     )
 
+    # Collision has its own scenario (`collision`), where the volume it edits can
+    # actually be seen.
+    #
+    # Last, because it deselects: clicking empty ground with an object editor
+    # open used to abort the engine -- the panel wrote through element handles
+    # RmlUi had already destroyed. It must survive, and clear the selection.
+    for dx, dy in ((-300, -150), (250, 120), (-120, 260), (380, -220)):
+        run_state.click(spot_x + dx, spot_y + dy, delay=0.4)
+    run_state.screenshot("props-after-map-clicks")
+    run_state.assert_running()
+
+
+def collision(run_state: E2ERun) -> None:
+    """Objects -> Collision, on its own so it is quick and focused.
+
+    The point of the editor is the *volume*, so the volume is what gets checked:
+    turn on the debug rendering and prove that each edit visibly changes the
+    shape drawn on the object. A command reaching the bridge would not tell us
+    the volume actually moved.
+    """
+    run_state.focus()
+    left = _open(run_state, 110)                      # Features
+    _arm_tree(run_state, left)
+
+    width, height = window_size(run_state)
+    spot_x, spot_y = width // 3, height // 2
+    run_state.wheel(spot_x, spot_y, clicks=8, up=True)
+    run_state.click(spot_x, spot_y, delay=0.8)        # place
+    run_state.click(left + 54, ACTION_Y, delay=0.6)   # leave Add mode
+    run_state.click(spot_x, spot_y, delay=0.8)        # select it
+
     run_state.click(left + 270, EDITOR_BUTTON_Y, delay=0.9)   # Collision
-    run_state.screenshot("collision-open")
+    hidden = run_state.screenshot_root("volume-hidden")
+
+    # Show volume: the collision shape is drawn over the object.
+    run_state.click(left + 110, 190, delay=0.8)
+    shown = run_state.screenshot_root("volume-shown")
+    run_state.assert_screenshot_pixels(hidden, shown, min_changed=300)
 
-    # The collision volume is its own sub-object: editing a scale axis must send
-    # the whole volume table, and the field must hold the new value after.
-    run_state.click(left + 60, 339, delay=0.4)                # Scale X
+    # Scaling the volume must redraw it bigger, not merely emit a command.
+    run_state.click(left + 60, 339, delay=0.4)        # Scale X
     run_state.key("ctrl+a", delay=0.15)
-    run_state.type_text("45")
-    run_state.key("Return", delay=0.8)
-    run_state.screenshot("collision-scale-edited")
+    run_state.type_text("120")
+    run_state.key("Return", delay=0.9)
+    scaled = run_state.screenshot_root("volume-scaled")
     run_state.assert_any_command(
         "SetObjectParamCommand",
         key="collision",
         value=lambda v: isinstance(v, dict),
     )
+    run_state.assert_screenshot_pixels(shown, scaled, min_changed=300)
 
-    # Last, because it deselects: clicking empty ground with an object editor
-    # open used to abort the engine -- the panel wrote through element handles
-    # RmlUi had already destroyed. It must survive, and clear the selection.
-    for dx, dy in ((-300, -150), (250, 120), (-120, 260), (380, -220)):
-        run_state.click(spot_x + dx, spot_y + dy, delay=0.4)
-    run_state.screenshot("props-after-map-clicks")
-    run_state.assert_running()
+    # A different volume type is a different shape on screen.
+    run_state.click(left + 200, 231, delay=0.4)       # Type
+    run_state.key("Down", delay=0.2)
+    run_state.key("Return", delay=0.9)
+    typed = run_state.screenshot_root("volume-type-changed")
+    run_state.assert_screenshot_pixels(scaled, typed, min_changed=200)
+    run_state.screenshot("collision-fields")
 
 
 def cursortip(run_state: E2ERun) -> None:
@@ -289,6 +329,7 @@ def selection(run_state: E2ERun) -> None:
 SCENARIOS = {
     "units_panel": units_panel,
     "props_panel": props_panel,
+    "collision": collision,
     "selection": selection,
     "cursortip": cursortip,
 }