more pointer implementation logic

Author: domportera

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

@@ -13,87 +13,38 @@ internal class SdlMouse : SdlPointerDevice, IMouse, ISdlDevice<SdlMouse>
 
     private readonly MouseState _state;
 
-    private SdlMouse(uint sdlDeviceId, nint uniqueId, SdlInputBackend backend, IPointerTarget unboundedPointerTarget, ICursorConfiguration cursor)
-        : base(backend, uniqueId, sdlDeviceId)
+    private SdlMouse(uint sdlDeviceId, nint uniqueId, SdlInputBackend backend, IPointerTarget unboundedPointerTarget,
+        ICursorConfiguration cursor)
+        : base(backend, uniqueId, sdlDeviceId, unboundedPointerTarget)
     {
-        _state = new MouseState(new ButtonReadOnlyList<PointerButton>(_buttons),
-            new InputReadOnlyList<TargetPoint>(_points), Vector2.Zero);
+        _state = new MouseState(Buttons, Points, Vector2.Zero);
         Cursor = cursor;
         float x = 0, y = 0;
-        var buttonMask = NativeBackend.GetMouseState(x.AsRef(), y.AsRef());
-        var pos = new Vector2(x, y);
-
-        for (var i = 0; i < EnumInfo<PointerButton>.UniqueValues.Count; i++)
-        {
-            var button = EnumInfo<PointerButton>.UniqueValues[i];
-            var pressed = IsPointerButtonPressedSdl(button, buttonMask);
-            _buttons.Add(new Button<PointerButton>(button, pressed, pressed ? 1.0f : 0.0f));
-        }
+        _ = NativeBackend.GetMouseState(x.AsRef(), y.AsRef());
 
         var window = NativeBackend.GetMouseFocus();
-        var pressure = _state.Buttons[PointerButton.Primary].Pressure;
-        AddTargetPoint(window, pos, pressure);
-
-        // add unbounded target
-        // var point = _unboundedPointerTarget.GetPoint(this, 0);
-        _targetListNoWindow = [unboundedPointerTarget];
-        _targetListWithWindow = [null!, unboundedPointerTarget];
-    }
-
-    private void AddTargetPoint(WindowHandle window, Vector2 pos, float pressure)
-    {
-        if (!Backend.TryGetPointerTargetForWindow(window, out var windowTarget))
+        uint windowId;
+        if (window == nullptr)
         {
-            AddUnboundedPoint(pos, pressure);
+            windowId = 0;
         }
         else
         {
-            AddWindowPoint(pos, pressure, windowTarget);
+            windowId = NativeBackend.GetWindowID(window);
+            if (windowId == 0)
+            {
+                SdlLog.Error("Mouse has no window");
+            }
         }
-    }
 
-    private void AddTargetPoint(uint windowId, Vector2 pos, float pressure)
-    {
-        if (Backend.TryGetPointerTargetForWindow(windowId, out var windowTarget))
-        {
-            AddWindowPoint(pos, pressure, windowTarget);
-        }
-        else
-        {
-            AddUnboundedPoint(pos, pressure);
-        }
+        _mouseWindowId = windowId;
+        var pressure = _state.Buttons[PointerButton.Primary].Pressure;
+        SetTargetPoint(windowId, new Vector3(x, y, 0), pressure);
+        // var point = _unboundedPointerTarget.GetPoint(this, 0);
     }
 
-    private void AddUnboundedPoint(Vector2 pos, float pressure) =>
-        // add raw position (likely just 0, but that's ok for now)
-        _points.Add(
-            new TargetPoint(0, // todo: use a unique id
-                Flags: TargetPointFlags.NotPointingAtTarget,
-                Position: new Vector3(pos, 0),
-                NormalizedPosition: default,
-                Pointer: default,
-                Pressure: pressure,
-                Target: null
-            )
-        );
-
-    private void AddWindowPoint(Vector2 pos, float pressure, IPointerTarget windowTarget)
-    {
-        var bounds = windowTarget.Bounds;
-        var min = new Vector2(bounds.Min.X, bounds.Min.Y);
-        var max = new Vector2(bounds.Max.X, bounds.Max.Y);
-
-        _points.Add(
-            new TargetPoint(
-                Id: 0, // todo - use a unique id
-                Flags: TargetPointFlags.PointingAtTarget,
-                Position: new Vector3(pos, 0),
-                NormalizedPosition: new Vector3((pos - min) / (max - min), 0),
-                Pointer: default,
-                Pressure: pressure,
-                Target: windowTarget
-            ));
-    }
+    protected override uint GetButtonMaskSdl() => NativeBackend.GetMouseState(nullptr, nullptr);
+
 
     public static unsafe SdlMouse CreateDevice(uint sdlDeviceId, SdlInputBackend backend)
     {
@@ -105,7 +56,8 @@ public static unsafe SdlMouse CreateDevice(uint sdlDeviceId, SdlInputBackend bac
         }
 
         backend.Sdl.Free(deviceName);
-        return new SdlMouse(sdlDeviceId, uniqueId, backend, backend.UnboundedPointerTarget, backend.CursorConfiguration);
+        return new SdlMouse(sdlDeviceId, uniqueId, backend, backend.UnboundedPointerTarget,
+            backend.CursorConfiguration);
     }
 
     public override string Name => NativeBackend.GetMouseNameForID(SdlDeviceId).ReadToString();
@@ -116,64 +68,65 @@ protected override void Release()
 
     MouseState IMouse.State => _state;
 
-    public override unsafe IReadOnlyList<IPointerTarget> Targets
+    private bool IsMouseRelative
     {
         get
         {
-            if (_mouseWindowId == 0)
+            //var focus = NativeBackend.GetMouseFocus();
+            if (!Backend.TryGetWindowHandles(out var windows))
             {
-                return _targetListNoWindow;
+                return false;
             }
 
-            if (!Backend.TryGetPointerTargetForWindow(_mouseWindowId, out var target))
+            var isRelative = false;
+
+            for (var i = 0; i < windows.Count; i++)
             {
-                return _targetListNoWindow;
+                isRelative |= NativeBackend.GetWindowRelativeMouseMode(windows[i]);
             }
 
-            _targetListWithWindow[0] = target;
-            return _targetListWithWindow;
+            windows.Dispose();
+            return isRelative;
         }
     }
 
-    protected override bool IsBounded { get; }
-
+    protected override bool OnePointOnly => true;
 
     public bool TrySetPosition(Vector2 position)
     {
         if (NativeBackend.WarpMouseGlobal(position.X, position.Y))
         {
+            SetTargetPoint(_mouseWindowId, new Vector3(position.X, position.Y, 0), 0);
             return true;
         }
 
-        NativeBackend.ClearError();
+        SdlLog.Error("Failed to set mouse position");
         return false;
     }
 
-
     public void AddMotion(in MouseMotionEvent evtMotion)
     {
-        _mouseWindowId = evtMotion.WindowID;
-        var movementRelative = new Vector2(evtMotion.Xrel, evtMotion.Yrel);
+        var mouseWindowId = evtMotion.WindowID;
+        var movementRelative = new Vector3(evtMotion.Xrel, evtMotion.Yrel, 0);
         _accumulatedMotion += movementRelative;
+        // todo - test against evtMotion state values
 
-        // add clear old point, add new point
-        _points.Clear();
-        AddTargetPoint(_mouseWindowId, _accumulatedMotion, 0);
+        SetTargetPoint(mouseWindowId, _accumulatedMotion, 0);
     }
 
     public void AddButtonEvent(in MouseButtonEvent evtButton)
     {
         var button = PointerButton.Primary + evtButton.Button;
-        var idx = EnumInfo<PointerButton>.ValueIndexOfUnnamed(button);
         const float mult = 1 / 255f;
-        _buttons[idx] = new Button<PointerButton>(button, evtButton.Down > 0, evtButton.Down * mult);
+        AddButtonEvent(button, evtButton.Down > 0, evtButton.Down * mult);
     }
 
     public void AddWheelEvent(in MouseWheelEvent evtWheel)
     {
         _mouseScroll[0] += evtWheel.X;
         _mouseScroll[1] += evtWheel.Y;
 
+        // todo - evt.Which?
         var hMagnitude = MathF.Abs(_mouseScroll[0]);
         var vMagnitude = MathF.Abs(_mouseScroll[1]);
 
@@ -189,26 +142,35 @@ public void AddWheelEvent(in MouseWheelEvent evtWheel)
             _mouseScroll.Y = 0;
         }
 
-        // todo - actually do stuff
-        throw new NotImplementedException();
+        _state.WheelPosition = _mouseScroll;
     }
 
-    private static bool IsPointerButtonPressedSdl(PointerButton button, uint state)
+
+    private void SetTargetPoint(uint windowId, in Vector3 pos, float pressure)
     {
-        var index = EnumInfo<PointerButton>.ValueIndexOf(button);
-        if (index is < 0 or >= 32)
+        _ = Backend.TryGetPointerTargetForWindow(windowId, out var windowTarget);
+
+        if (TryGetPointIndexForTarget(windowTarget, out var index))
+        {
+            UpdatePoint(ToTargetPoint(pos, pressure, windowTarget), index);
+        }
+        else
         {
-            return false;
+            AddPoint(ToTargetPoint(pos, pressure, windowTarget));
         }
 
-        return (state & (1 << index)) != 0;
+#if DEBUG
+        if (_mouseWindowId != windowId)
+        {
+            InputLog.Warn($"Mouse window changed from {_mouseWindowId} to {windowId}");
+        }
+#endif
+
+        _mouseWindowId = windowId;
     }
 
+
     private uint _mouseWindowId;
     private Vector2 _mouseScroll;
-    private Vector2 _accumulatedMotion;
-    private readonly List<Button<PointerButton>> _buttons = [];
-    private readonly List<TargetPoint> _points = new();
-    private readonly IPointerTarget[] _targetListNoWindow;
-    private readonly IPointerTarget[] _targetListWithWindow;
+    private Vector3 _accumulatedMotion;
 }

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

@@ -5,9 +5,8 @@ namespace Silk.NET.Input.SDL3.Devices.Pointers;
 
 internal class SdlPen : SdlPointerDevice, ISdlDevice<SdlPen>
 {
-    public SdlPen(SdlInputBackend backend, nint silkId, uint sdlDeviceId, IReadOnlyList<IPointerTarget> targets, string name) : base(backend, silkId, sdlDeviceId)
+    public SdlPen(SdlInputBackend backend, nint silkId, uint sdlDeviceId, string name, IPointerTarget unbounded) : base(backend, silkId, sdlDeviceId, unbounded)
     {
-        Targets = targets;
         Name = name;
     }
 
@@ -16,9 +15,14 @@ public static SdlPen CreateDevice(uint sdlDeviceId, SdlInputBackend backend)
         throw new NotImplementedException();
     }
 
+    protected override uint GetButtonMaskSdl()
+    {
+        throw new NotImplementedException();
+    }
+
     public override PointerState State => throw new NotImplementedException();
-    public override IReadOnlyList<IPointerTarget> Targets { get; }
-    protected override bool IsBounded => true; // should this always be bounded?
+
+    protected override bool OnePointOnly => true;
 
 
     public override string Name { get; }