continue iterating on pointers, continue populating events as they occur

Author: domportera

sources/Input/Input/Implementations/EnumInfo.cs

@@ -26,7 +26,6 @@ internal static class EnumInfo<T> where T : unmanaged, Enum
     /// </summary>
     public static readonly IReadOnlyList<T> UniqueValues;
 
-
     /// <summary>
     /// The value with the highest numerical value
     /// </summary>

sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlMouse.cs

@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using Silk.NET.Maths;
 using Silk.NET.SDL;
 
 namespace Silk.NET.Input.SDL3.Devices.Pointers;
@@ -15,14 +14,17 @@ internal sealed class SdlMouse : SdlPointerDevice, IMouse, ISdlDevice<SdlMouse>
 
     private readonly MouseState _state;
 
+    // the mouse is always considered "down" - there is no up/down state for the mouse pointer itself - only its buttons.
+    private const bool DownState = true;
+
     private SdlMouse(ulong sdlDeviceId, nint uniqueId, SdlInputBackend backend, IPointerTarget unboundedPointerTarget,
         ICursorConfiguration cursor)
         : base(backend, uniqueId, sdlDeviceId, unboundedPointerTarget)
     {
         _state = new MouseState(Buttons, Points, Vector2.Zero);
         Cursor = cursor;
         float x = 0, y = 0;
-        var mouseInputFlags = GetButtonMaskSdl(ref x, ref y);
+        var mouseInputFlags = GetMouseState(ref x, ref y);
         ApplyMouseButtonState(mouseInputFlags);
 
         var window = NativeBackend.GetMouseFocus();
@@ -40,28 +42,30 @@ private SdlMouse(ulong sdlDeviceId, nint uniqueId, SdlInputBackend backend, IPoi
             }
         }
 
-        var pressure = _state.Buttons[PointerButton.Primary].Pressure;
-        SetTargetPoint(windowId, new Vector3(x, y, 0), pressure);
+        // var pressure = _state.Buttons[PointerButton.Primary].Pressure;
+        AddOrUpdatePoint(0, windowId, new Vector3(x, y, 0), null, DownState, null, true);
         // var point = _unboundedPointerTarget.GetPoint(this, 0);
     }
 
+
     private void ApplyMouseButtonState(SdlMouseInputFlags mouseState)
     {
         foreach (var pointerButtonName in EnumInfo<PointerButton>.UniqueValues)
         {
-            ref var button = ref GetButtonRef(pointerButtonName);
-            var isDown = mouseState.Has(pointerButtonName);
-            button = button with { IsDown = isDown, Pressure = isDown ? 1 : 0 };
+            if (mouseState.Has(pointerButtonName))
+            {
+                AddButtonEvent(pointerButtonName, 0, true);
+            }
         }
     }
 
     public override void Initialize()
     {
-
     }
 
-    private unsafe SdlMouseInputFlags GetButtonMaskSdl(ref float x, ref float y) =>
-        (SdlMouseInputFlags)NativeBackend.GetMouseState((float*)Unsafe.AsPointer(ref x), (float*)Unsafe.AsPointer(ref y));
+    private unsafe SdlMouseInputFlags GetMouseState(ref float x, ref float y) =>
+        (SdlMouseInputFlags)NativeBackend.GetMouseState((float*)Unsafe.AsPointer(ref x),
+            (float*)Unsafe.AsPointer(ref y));
 
     public static SdlMouse CreateDevice(ulong sdlDeviceId, SdlInputBackend backend)
     {
@@ -113,66 +117,81 @@ private bool IsMouseRelative
     }
 
     protected override bool OnePointOnly => true;
-
+    private bool _hintsAsEvents = false;
+
+
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    /// <param name="position">The window-relative position of the mouse</param>
+    /// <returns>True if success, but see the below remarks</returns>
+    /// <remarks>
+    /// todo: this is the most straightforward way to do window-relative movement,
+    /// but we don't actually get any information about whether or not
+    /// it succeeds. The SDL documentation seems to suggest that it "just works" as opposed to their global mouse warp
+    /// method, which provides a success result. instead of translating this "global" position to a window-specific one,
+    /// we're gonna use SDL's implementation of window-relative movement to keep things simple.<br/><br/>
+    /// As a result, we always return true, though the documentation suggests that it does not work specifically for
+    /// Microsoft Remote Desktop. not sure how to detect that at the moment.<br/><br/>
+    /// Another consequence of doing it this way is that we need to wait for SDL to push these events through the event
+    /// queue, so while this may return 'true', this mouse object will not necessarily be in the correct position until
+    /// the next time pumped events are processed.<br/><br/>
+    /// We could just create a mouse motion event and push it through our internal event queues, bypassing SDL's event
+    /// queue, but that could result in a situation where we set our internal state to represent the
+    /// movement, even though SDL did not meaningfully succeed.<br/><br/>
+    /// The best way around this would probably be to try global mouse warping with translated coordinates,
+    /// and if that fails, fall back to window-relative movement.
+    /// </remarks>
     public bool TrySetPosition(Vector2 position)
     {
-        if (NativeBackend.WarpMouseGlobal(position.X, position.Y))
+        // make sure we get pumped mouse events for setting the position this way
+        if (!_hintsAsEvents)
         {
-            SetTargetPoint(null, new Vector3(position.X, position.Y, 0), 0);
-            return true;
+            var currentHintVal = NativeBackend.GetHintBoolean(Sdl.HintMouseRelativeWarpMotion, new MaybeBool<byte>(0));
+            if (currentHintVal == 0)
+            {
+                sbyte hintVal = 1;
+                if(NativeBackend.SetHint(Sdl.HintMouseRelativeWarpMotion, new Ref<sbyte>(ref hintVal)))
+                {
+                    _hintsAsEvents = true;
+                }
+            }
+            else
+            {
+                _hintsAsEvents = true;
+            }
         }
 
-        SdlLog.Error("Failed to set mouse position");
-        return false;
+        // providing a null window handle means that SDL will use the latest position
+        NativeBackend.WarpMouseInWindow(default, position.X, position.Y);
+        NeedsPump = true; // we should "pump" events immediately, but this isn't a good place to do it.
+        return true;
     }
 
-    public void AddMotion(in MouseMotionEvent evtMotion)
-    {
-        var mouseWindowId = evtMotion.WindowID;
-        var movementRelative = new Vector3(evtMotion.Xrel, evtMotion.Yrel, 0);
-        _accumulatedMotion += movementRelative;
-        // todo - test against evtMotion state values
-
-        //SetTargetPoint(mouseWindowId, _accumulatedMotion, 0, 0);
-        SetTargetPoint(mouseWindowId, new Vector3(evtMotion.X, evtMotion.Y, 0), 0);
-    }
+    /// <summary>
+    /// A user has attempted to modify the hardware mouse position - we need a pump to process these events.
+    /// </summary>
+    public bool NeedsPump { get; private set; }
 
+    public void AddMotion(in MouseMotionEvent evtMotion) =>
+        AddOrUpdatePoint(null, evtMotion.WindowID, new Vector3(evtMotion.X, evtMotion.Y, 0), 1, null, null,
+            evtMotion.WindowID != 0);
 
 
     public void AddButtonEvent(in MouseButtonEvent evtButton)
     {
         var button = PointerButton.Primary + evtButton.Button;
         const float mult = 1 / 255f;
-        AddButtonEvent(button, evtButton.Down > 0, evtButton.Down * mult);
+        AddButtonEvent(button, evtButton.Timestamp, evtButton.Down > 0, evtButton.Down * mult);
     }
 
     public void AddWheelEvent(in MouseWheelEvent evtWheel)
     {
-        ref var x = ref _mouseScroll.X;
-        ref var y = ref _mouseScroll.Y;
-        x += evtWheel.X;
-        y += evtWheel.Y;
-
-        // todo - evt.Which?
-        var hMagnitude = MathF.Abs(x);
-        var vMagnitude = MathF.Abs(y);
-
-        if (hMagnitude >= 1)
-        {
-            // horizontal scroll "tick"
-            _mouseScroll.X = 0;
-        }
-
-        if (vMagnitude >= 1)
-        {
-            // vertical scroll "tick"
-            _mouseScroll.Y = 0;
-        }
-
-        _state.WheelPosition = _mouseScroll;
+        var wheelState = _state.WheelPosition = new Vector2(evtWheel.X, evtWheel.Y);
+        AddMouseScrollEvent(
+            scrollWheelPosition: wheelState,
+            windowId: evtWheel.WindowID,
+            position: new Vector3(evtWheel.MouseX, evtWheel.MouseY, 0),
+            isMouseRelative: evtWheel.WindowID != 0);
     }
-
-
-    private Vector2 _mouseScroll;
-    private Vector3 _accumulatedMotion;
 }

sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlPen.cs

@@ -48,17 +48,6 @@ public static SdlPen CreateDevice(ulong sdlDeviceId, SdlInputBackend backend)
         SdlPen Create() => new(backend, uniqueId, sdlDeviceId, name.ReadToString(), backend.UnboundedPointerTarget);
     }
 
-    private void ApplyPenInputState(SdlPenInputFlags penState)
-    {
-        foreach (var pointerButtonName in EnumInfo<PointerButton>.UniqueValues)
-        {
-            ref var button = ref GetButtonRef(pointerButtonName);
-            var isDown = penState.Has(pointerButtonName);
-            button = button with { IsDown = isDown, Pressure = isDown ? 1 : 0 };
-        }
-    }
-
-
     public override void Initialize()
     {
     }
@@ -77,64 +66,83 @@ public void UpDownEvent(in PenTouchEvent evt)
     {
         MotionEvent(evt.WindowID, evt.X, evt.Y);
 
-        var previousPressure = GetPointPressure(0);
-        const float divisor = 1f / 255f;
-        var downPressure = evt.Down * divisor;
-        if (downPressure > 0)
+        if (evt.Down > 0)
         {
-            AddButtonEvent(PointerButton.Primary, true, Math.Max(previousPressure, downPressure));
+            const float divisor = 1f / 255f;
+            var downPressure = evt.Down * divisor;
+            AddButtonEvent(PointerButton.Primary, evt.Timestamp, true, downPressure);
         }
         else
         {
-            AddButtonEvent(PointerButton.Primary, false, 0);
+            AddButtonEvent(PointerButton.Primary, evt.Timestamp, false, 0);
         }
     }
 
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void MotionEvent(in PenMotionEvent evt) => MotionEvent(evt.WindowID, evt.X, evt.Y);
 
-    private void MotionEvent(in uint windowId, float x, float y)
+    private void MotionEvent(in uint windowId, float x, float y) =>
+        AddOrUpdatePoint(
+            touchId: null,
+            windowId: windowId == 0 ? null : windowId,
+            pos: new Vector3(x, y, 0),
+            pressure: null,
+            isDown: null,
+            ray: null,
+            isPositionInWindowSpace: true);
+
+    public void ButtonEvent(in PenButtonEvent evt)
     {
-        if (!Backend.TryGetPointerTargetForWindow(windowId, out var target))
-        {
-            return;
-        }
-
-        SetTargetPoint(windowId, new Vector3(x, y, 0), GetPointPressure(0),0);
+        var button = (SdlPenButton)evt.Button;
+        var pointerButton = button switch {
+            SdlPenButton.Button1 => PointerButton.Primary,
+            SdlPenButton.Button2 => PointerButton.Secondary,
+            SdlPenButton.Button3 => PointerButton.MiddleButton,
+            SdlPenButton.Button4 => PointerButton.Button4,
+            SdlPenButton.Button5 => PointerButton.Button5,
+            _ => throw new ArgumentOutOfRangeException(nameof(button), button, null)
+        };
+
+        AddButtonEvent(pointerButton, evt.Timestamp, evt.Down > 0, evt.Down / 255f);
     }
 
-
-    public void ButtonEvent(in PenButtonEvent evt) => ApplyPenInputState((SdlPenInputFlags)evt.PenState);
+    private enum SdlPenButton : byte
+    {
+        Button1 = 1,
+        Button2,
+        Button3,
+        Button4,
+        Button5,
+    }
 
     public void AxisEvent(in PenAxisEvent evt)
     {
         switch (evt.Axis)
         {
             case PenAxis.Pressure:
             {
-                SetPointPressure(0, evt.Value);
+                AddOrUpdatePoint(null, null, new Vector3(evt.X, evt.Y, 0), evt.Value, null, null, true);
                 break;
-                ;
             }
             case PenAxis.Xtilt:
             {
-                SetPointXTilt(0, evt.Value);
+                UpdatePointRay(null, evt.Value, null, null, distance: null);
                 break;
             }
             case PenAxis.Ytilt:
             {
-                SetPointYTilt(0, evt.Value);
+                UpdatePointRay(null, null, evt.Value, null, distance: null);
                 break;
             }
             case PenAxis.Distance:
             {
-                SetPointDistance(0, evt.Value);
+                UpdatePointRay(null, null, null, null, distance: evt.Value);
                 break;
             }
             case PenAxis.Rotation: // barrel rotation
             {
-                SetPointTwist(0, evt.Value);
+                UpdatePointRay(null, null, null, evt.Value, distance: null);
                 break;
             }
             case PenAxis.Slider: