wip

osu.Framework/Input/Handlers/Pen/PenHandler.cs

@@ -0,0 +1,75 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Input.StateChanges;
+using osu.Framework.Platform;
+using osu.Framework.Statistics;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Framework.Input.Handlers.Pen
+{
+    /// <summary>
+    /// Handles pen events from an <see cref="ISDLWindow"/>.
+    /// This outputs simple mouse input with <see cref="ISourcedFromPen"/> markers embedded.
+    /// </summary>
+    public class PenHandler : InputHandler
+    {
+        private static readonly GlobalStatistic<ulong> statistic_total_events = GlobalStatistics.Get<ulong>(StatisticGroupFor<PenHandler>(), "Total events");
+
+        public override string Description => "Pen";
+
+        public override bool IsActive => true;
+
+        public override bool Initialize(GameHost host)
+        {
+            if (!base.Initialize(host))
+                return false;
+
+            if (!(host.Window is ISDLWindow sdlWindow))
+                return false;
+
+            Enabled.BindValueChanged(enabled =>
+            {
+                if (enabled.NewValue)
+                {
+                    sdlWindow.PenIn += handlePenIn;
+                    sdlWindow.PenOut += handlePenOut;
+                    sdlWindow.PenMove += handlePenMove;
+                    sdlWindow.PenDown += handlePenDown;
+                    sdlWindow.PenUp += handlePenUp;
+                }
+                else
+                {
+                    sdlWindow.PenIn -= handlePenIn;
+                    sdlWindow.PenOut -= handlePenOut;
+                    sdlWindow.PenMove -= handlePenMove;
+                    sdlWindow.PenDown -= handlePenDown;
+                    sdlWindow.PenUp -= handlePenUp;
+                }
+            }, true);
+
+            return true;
+        }
+
+        private void handlePenIn()
+        {
+            // The first pen motion will validate the mouse position, we don't have to do anything here.
+        }
+
+        private void handlePenOut() => enqueueInput(new MouseInvalidatePositionInputFromPen());
+
+        private void handlePenMove(Vector2 position) => enqueueInput(new MousePositionAbsoluteInputFromPen { Position = position });
+
+        private void handlePenDown(MouseButton button) => enqueueInput(new MouseButtonInputFromPen(button, true));
+
+        private void handlePenUp(MouseButton button) => enqueueInput(new MouseButtonInputFromPen(button, false));
+
+        private void enqueueInput(IInput input)
+        {
+            PendingInputs.Enqueue(input);
+            FrameStatistics.Increment(StatisticsCounterType.MouseEvents);
+            statistic_total_events.Value++;
+        }
+    }
+}

osu.Framework/Input/PassThroughInputManager.cs

@@ -102,16 +102,28 @@ protected override bool Handle(UIEvent e)
             switch (e)
             {
                 case MouseDownEvent mouseDown:
-                    new MouseButtonInput(mouseDown.Button, true).Apply(CurrentState, this);
+                    if (e.CurrentState.Mouse.LastSource is ISourcedFromPen)
+                        new MouseButtonInputFromPen(mouseDown.Button, true).Apply(CurrentState, this);
+                    else
+                        new MouseButtonInput(mouseDown.Button, true).Apply(CurrentState, this);
                     break;
 
                 case MouseUpEvent mouseUp:
-                    new MouseButtonInput(mouseUp.Button, false).Apply(CurrentState, this);
+                    if (e.CurrentState.Mouse.LastSource is ISourcedFromPen)
+                        new MouseButtonInputFromPen(mouseUp.Button, false).Apply(CurrentState, this);
+                    else
+                        new MouseButtonInput(mouseUp.Button, false).Apply(CurrentState, this);
                     break;
 
                 case MouseMoveEvent mouseMove:
                     if (mouseMove.ScreenSpaceMousePosition != CurrentState.Mouse.Position)
-                        new MousePositionAbsoluteInput { Position = mouseMove.ScreenSpaceMousePosition }.Apply(CurrentState, this);
+                    {
+                        if (e.CurrentState.Mouse.LastSource is ISourcedFromPen)
+                            new MousePositionAbsoluteInputFromPen { Position = mouseMove.ScreenSpaceMousePosition }.Apply(CurrentState, this);
+                        else
+                            new MousePositionAbsoluteInput { Position = mouseMove.ScreenSpaceMousePosition }.Apply(CurrentState, this);
+                    }
+
                     break;
 
                 case ScrollEvent scroll:

osu.Framework/Input/StateChanges/ISourcedFromPen.cs

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Input.StateChanges
+{
+    /// <summary>
+    /// Denotes mouse input which was sourced from a pen.
+    /// </summary>
+    public interface ISourcedFromPen : IInput
+    {
+    }
+}

osu.Framework/Input/StateChanges/MouseButtonInputFromPen.cs

@@ -0,0 +1,15 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osuTK.Input;
+
+namespace osu.Framework.Input.StateChanges
+{
+    public class MouseButtonInputFromPen : MouseButtonInput, ISourcedFromPen
+    {
+        public MouseButtonInputFromPen(MouseButton button, bool isPressed)
+            : base(button, isPressed)
+        {
+        }
+    }
+}

osu.Framework/Input/StateChanges/MouseInvalidatePositionInputFromPen.cs

@@ -0,0 +1,9 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Input.StateChanges
+{
+    public class MouseInvalidatePositionInputFromPen : MouseInvalidatePositionInput, ISourcedFromPen
+    {
+    }
+}

osu.Framework/Input/StateChanges/MousePositionAbsoluteInputFromPen.cs

@@ -0,0 +1,9 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Input.StateChanges
+{
+    public class MousePositionAbsoluteInputFromPen : MousePositionAbsoluteInput, ISourcedFromPen
+    {
+    }
+}

osu.Framework/Platform/ISDLWindow.cs

@@ -22,6 +22,11 @@ internal interface ISDLWindow : IWindow
         event Action<MouseButton> MouseDown;
         event Action<MouseButton> MouseUp;
         event Action<Vector2, bool> MouseWheel;
+        event Action PenIn;
+        event Action PenOut;
+        event Action<Vector2> PenMove;
+        event Action<MouseButton> PenDown;
+        event Action<MouseButton> PenUp;
         event Action<Key> KeyDown;
         event Action<Key> KeyUp;
         event Action<string> TextInput;

osu.Framework/Platform/SDL2/SDL2Window_Input.cs

@@ -598,6 +598,12 @@ private void updateConfineMode()
         /// </summary>
         public event Action<MouseButton>? MouseUp;
 
+        public event Action<MouseButton>? PenDown;
+        public event Action<MouseButton>? PenUp;
+        public event Action<Vector2>? PenMove;
+        public event Action? PenIn;
+        public event Action? PenOut;
+
         protected void TriggerMouseUp(MouseButton button) => MouseUp?.Invoke(button);
 
         /// <summary>

osu.Framework/Platform/SDL3/SDL3Window.cs

@@ -590,6 +590,11 @@ protected virtual void HandleEvent(SDL_Event e)
                 case SDL_EventType.SDL_EVENT_PEN_MOTION:
                     handlePenMotionEvent(e.pmotion);
                     break;
+
+                case SDL_EventType.SDL_EVENT_PEN_PROXIMITY_IN:
+                case SDL_EventType.SDL_EVENT_PEN_PROXIMITY_OUT:
+                    handlePenProximityEvent(e.pproximity);
+                    break;
             }
         }
 

osu.Framework/Platform/SDL3/SDL3Window_Input.cs

@@ -510,9 +510,23 @@ private void handleKeyboardEvent(SDL_KeyboardEvent evtKey)
 
         private void handleKeymapChangedEvent() => KeymapChanged?.Invoke();
 
+        private void handlePenProximityEvent(SDL_PenProximityEvent evtPenProximity)
+        {
+            switch (evtPenProximity.type)
+            {
+                case SDL_EventType.SDL_EVENT_PEN_PROXIMITY_IN:
+                    PenIn?.Invoke();
+                    break;
+
+                case SDL_EventType.SDL_EVENT_PEN_PROXIMITY_OUT:
+                    PenOut?.Invoke();
+                    break;
+            }
+        }
+
         private void handlePenMotionEvent(SDL_PenMotionEvent evtPenMotion)
         {
-            MouseMove?.Invoke(new Vector2(evtPenMotion.x * Scale, evtPenMotion.y * Scale));
+            PenMove?.Invoke(new Vector2(evtPenMotion.x * Scale, evtPenMotion.y * Scale));
         }
 
         private void handlePenTouchEvent(SDL_PenTouchEvent evtPenTouch)
@@ -544,7 +558,7 @@ private void handlePenPressEvent(byte penButton, bool pressed)
                 }
 
                 penPressedButtons |= mask;
-                MouseDown?.Invoke(button);
+                PenDown?.Invoke(button);
             }
             else
             {
@@ -555,7 +569,7 @@ private void handlePenPressEvent(byte penButton, bool pressed)
                 }
 
                 penPressedButtons &= ~mask;
-                MouseUp?.Invoke(button);
+                PenUp?.Invoke(button);
             }
         }
 
@@ -672,6 +686,13 @@ private void updateConfineMode()
 
         protected void TriggerMouseWheel(Vector2 delta, bool precise) => MouseWheel?.Invoke(delta, precise);
 
+        /// <summary>
+        /// Invoked when the current position of the mouse cursor is no longer valid to read.
+        /// </summary>
+        public event Action? MouseInvalidatePosition;
+
+        protected void TriggerMouseInvalidatePosition() => MouseInvalidatePosition?.Invoke();
+
         /// <summary>
         /// Invoked when the user moves the mouse cursor within the window.
         /// </summary>
@@ -698,6 +719,41 @@ private void updateConfineMode()
 
         protected void TriggerMouseUp(MouseButton button) => MouseUp?.Invoke(button);
 
+        /// <summary>
+        /// Invoked when the pen is close to the screen and its motion became tracked.
+        /// </summary>
+        public event Action? PenIn;
+
+        protected void TriggerPenIn() => PenIn?.Invoke();
+
+        /// <summary>
+        /// Invoked when the pen became far from the screen and motion will no longer be tracked.
+        /// </summary>
+        public event Action? PenOut;
+
+        protected void TriggerPenOut() => PenOut?.Invoke();
+
+        /// <summary>
+        /// Invoked when the user moves their pen.
+        /// </summary>
+        public event Action<Vector2>? PenMove;
+
+        protected void TriggerPenMove(float x, float y) => PenMove?.Invoke(new Vector2(x, y));
+
+        /// <summary>
+        /// Invoked when the pen produced a button press, as a result of pressing the pen down or by pressing an auxiliary button.
+        /// </summary>
+        public event Action<MouseButton>? PenDown;
+
+        protected void TriggerPenDown(MouseButton button) => PenDown?.Invoke(button);
+
+        /// <summary>
+        /// Invoked when the button press signaled by <see cref="PenDown"/> has been released.
+        /// </summary>
+        public event Action<MouseButton>? PenUp;
+
+        protected void TriggerPenUp(MouseButton button) => PenUp?.Invoke(button);
+
         /// <summary>
         /// Invoked when the user presses a key.
         /// </summary>

osu.Framework/Platform/SDLGameHost.cs

@@ -8,6 +8,7 @@
 using osu.Framework.Input.Handlers.Keyboard;
 using osu.Framework.Input.Handlers.Midi;
 using osu.Framework.Input.Handlers.Mouse;
+using osu.Framework.Input.Handlers.Pen;
 using osu.Framework.Input.Handlers.Tablet;
 using osu.Framework.Input.Handlers.Touch;
 using osu.Framework.Platform.SDL2;
@@ -47,6 +48,7 @@ protected override IEnumerable<InputHandler> CreateAvailableInputHandlers() =>
                 // tablet should get priority over mouse to correctly handle cases where tablet drivers report as mice as well.
                 new OpenTabletDriverHandler(),
                 new MouseHandler(),
+                new PenHandler(),
                 new TouchHandler(),
                 new JoystickHandler(),
                 new MidiHandler(),