start of adding touch input

examples/CSharp/OpenGL Demos/AndroidInputDemo/AndroidManifest.xml

@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
-          android:versionCode="1" 
-          android:versionName="1.0" 
-          package="com.companyname.AndroidInputDemo">
-  <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true">
-  </application>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1" android:versionName="1.0" package="com.companyname.AndroidInputDemo">
+	<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+	<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
+	<application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:supportsRtl="true"></application>
+	<uses-sdk />
 </manifest>

examples/CSharp/OpenGL Demos/AndroidInputDemo/MainActivity.cs

@@ -34,6 +34,10 @@ public class MainActivity : SilkActivity
         private static int counter = 0;
 
         private static IInputContext input;
+        private static ITouchDevice currentTouchDevice;
+        private static Gesture trackedGestures = Gesture.All;
+        private static DoubleTapBehavior doubleTapBehavior = DoubleTapBehavior.EmitFirstSingleTap;
+        private static MultiGestureHandling multiGestureHandling = MultiGestureHandling.RecognizeBothGestures;
 
         /// <summary>
         /// This is where the application starts.
@@ -69,6 +73,15 @@ private unsafe static void OnLoad()
 
             input.Keyboards[0].KeyChar += KeyChar;
 
+            if (input.PrimaryTouchDevice != null)
+                SetupTouchDevice(input.PrimaryTouchDevice);
+
+            input.ConnectionChanged += (device, connected) =>
+            {
+                if (connected && device is ITouchDevice touchDevice)
+                    SetupTouchDevice(touchDevice);
+            };
+
             Vbo = new BufferObject<float>(Gl, Vertices, BufferTargetARB.ArrayBuffer);
             Vao = new VertexArrayObject<float, uint>(Gl, Vbo, null);
 
@@ -82,12 +95,96 @@ private unsafe static void OnLoad()
                 1.0f, 2.0f);
         }
 
+        private static void GestureRecognizer_Rotate(Vector2 position, float angle)
+        {
+            DebugLog($"Rotate gesture at {position} with rotation {angle} degree");
+        }
+
+        private static void GestureRecognizer_Zoom(Vector2 position, Vector2 zoom)
+        {
+            DebugLog($"Zoom gesture at {position} with zoom {zoom}");
+        }
+
+        private static void GestureRecognizer_Hold(Vector2 position)
+        {
+            Gl.ClearColor(1.0f, 0.0f, 0.0f, 1.0f);
+            DebugLog($"Hold gesture at {position}");
+        }
+
+        private static void GestureRecognizer_Swipe(Vector2 direction)
+        {
+            DebugLog($"Swipe gesture with direction {direction}");
+        }
+
+        private static void GestureRecognizer_DoubleTap(Vector2 position)
+        {
+            Gl.ClearColor(0.0f, 0.0f, 1.0f, 1.0f);
+            DebugLog($"Double Tap gesture at {position}");
+        }
+
+        private static void GestureRecognizer_Tap(Vector2 position)
+        {
+            Gl.ClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+            DebugLog($"Tap gesture at {position}");
+        }
+
         private static void KeyChar(IKeyboard arg1, char arg2)
         {
             if (arg2 == 'c')
                 Array.Clear(Vertices);
             if (arg2 == 'k')
                 input.Keyboards[0].EndInput();
+            if (arg2 == 't')
+                ToggleGesture(Gesture.Tap);
+            if (arg2 == 'd')
+                ToggleGesture(Gesture.DoubleTap);
+            if (arg2 == 's')
+                ToggleGesture(Gesture.Swipe);
+            if (arg2 == 'h')
+                ToggleGesture(Gesture.Hold);
+            if (arg2 == 'z')
+                ToggleGesture(Gesture.Zoom);
+            if (arg2 == 'r')
+                ToggleGesture(Gesture.Rotate);
+            if (arg2 == '0')
+                SetDoubleTapBehavior(DoubleTapBehavior.WaitForDoubleTapTimeElapse);
+            if (arg2 == '1')
+                SetDoubleTapBehavior(DoubleTapBehavior.EmitFirstSingleTap);
+            if (arg2 == '2')
+                SetDoubleTapBehavior(DoubleTapBehavior.EmitBothSingleTaps);
+            if (arg2 == '7')
+                SetMultiGestureHandling(MultiGestureHandling.RecognizeBothGestures);
+            if (arg2 == '8')
+                SetMultiGestureHandling(MultiGestureHandling.PrioritizeZoomGesture);
+            if (arg2 == '9')
+                SetMultiGestureHandling(MultiGestureHandling.PrioritizeRotateGesture);
+        }
+
+        private static void ToggleGesture(Gesture gesture)
+        {
+            if (trackedGestures.HasFlag(gesture))
+                trackedGestures &= ~gesture;
+            else
+                trackedGestures |= gesture;
+
+            if (currentTouchDevice?.GestureRecognizer != null)
+                currentTouchDevice.GestureRecognizer.TrackedGestures = trackedGestures;
+        }
+
+        private static void SetDoubleTapBehavior(DoubleTapBehavior doubleTapBehavior)
+        {
+            MainActivity.doubleTapBehavior = doubleTapBehavior;
+
+            if (currentTouchDevice?.GestureRecognizer != null)
+                currentTouchDevice.GestureRecognizer.DoubleTapBehavior = doubleTapBehavior;
+        }
+
+        private static void SetMultiGestureHandling(MultiGestureHandling multiGestureHandling)
+        {
+            MainActivity.multiGestureHandling = multiGestureHandling;
+
+            if (currentTouchDevice?.GestureRecognizer != null)
+                currentTouchDevice.GestureRecognizer.MultiGestureHandling = multiGestureHandling;
         }
 
         private static void MouseDown(IMouse arg1, MouseButton arg2)
@@ -131,5 +228,41 @@ private static void OnClose()
             Vao.Dispose();
             Shader.Dispose();
         }
+
+        private static void SetupTouchDevice(ITouchDevice touchDevice)
+        {
+            if (currentTouchDevice == touchDevice)
+                return;
+
+            TouchGestureRecognizer gestureRecognizer;
+
+            if (currentTouchDevice != null)
+            {
+                gestureRecognizer = currentTouchDevice.GestureRecognizer;
+                gestureRecognizer.Tap -= GestureRecognizer_Tap;
+                gestureRecognizer.DoubleTap -= GestureRecognizer_DoubleTap;
+                gestureRecognizer.Swipe -= GestureRecognizer_Swipe;
+                gestureRecognizer.Hold -= GestureRecognizer_Hold;
+                gestureRecognizer.Zoom -= GestureRecognizer_Zoom;
+                gestureRecognizer.Rotate -= GestureRecognizer_Rotate;
+            }
+
+            currentTouchDevice = touchDevice;
+            gestureRecognizer = currentTouchDevice.GestureRecognizer;
+            gestureRecognizer.TrackedGestures = trackedGestures;
+            gestureRecognizer.DoubleTapBehavior = doubleTapBehavior;
+            gestureRecognizer.MultiGestureHandling = multiGestureHandling;
+            gestureRecognizer.Tap += GestureRecognizer_Tap;
+            gestureRecognizer.DoubleTap += GestureRecognizer_DoubleTap;
+            gestureRecognizer.Swipe += GestureRecognizer_Swipe;
+            gestureRecognizer.Hold += GestureRecognizer_Hold;
+            gestureRecognizer.Zoom += GestureRecognizer_Zoom;
+            gestureRecognizer.Rotate += GestureRecognizer_Rotate;
+        }
+
+        private static void DebugLog(string message)
+        {
+            Android.Util.Log.Debug(nameof(AndroidInputDemo), message);
+        }
     }
-}
+}

src/Input/Silk.NET.Input.Common/Enums/DoubleTapBehavior.cs

@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Silk.NET.Input
+{
+    /// <summary>
+    /// Controls the behavior of the double tap gesture tracking.
+    /// </summary>
+    public enum DoubleTapBehavior
+    {
+        /// <summary>
+        /// Always emit the first tap as a single tap.
+        /// </summary>
+        EmitFirstSingleTap,
+
+        /// <summary>
+        /// Always emit the first and second tap as single taps.
+        /// </summary>
+        EmitBothSingleTaps,
+
+        /// <summary>
+        /// Do not emit single taps and wait for the double tap time to elapse.
+        /// The first single tap is only emitted after the time has elapsed.
+        /// </summary>
+        WaitForDoubleTapTimeElapse
+    }
+}

src/Input/Silk.NET.Input.Common/Enums/Gesture.cs

@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Silk.NET.Input
+{
+    /// <summary>
+    /// Recognizable touch gesture.
+    /// </summary>
+    [Flags]
+    public enum Gesture
+    {
+        /// <summary>
+        /// No gesture.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Tap gesture.
+        /// </summary>
+        Tap = 1,
+
+        /// <summary>
+        /// Double tap gesture.
+        /// </summary>
+        DoubleTap = 2,
+
+        /// <summary>
+        /// Swipe gesture.
+        /// </summary>
+        Swipe = 4,
+
+        /// <summary>
+        /// Long hold gesture.
+        /// </summary>
+        Hold = 8,
+
+        /// <summary>
+        /// Zoom gesture.
+        /// </summary>
+        Zoom = 16,
+
+        /// <summary>
+        /// Rotate gesture.
+        /// </summary>
+        Rotate = 32,
+
+        /// <summary>
+        /// All gestures.
+        /// </summary>
+        All = Tap | DoubleTap | Swipe | Hold | Zoom | Rotate
+    }
+}

src/Input/Silk.NET.Input.Common/Enums/MultiGestureHandling.cs

@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Silk.NET.Input
+{
+    /// <summary>
+    /// Controls the behavior of how multiple two-finger gestures are handled.
+    /// </summary>
+    public enum MultiGestureHandling
+    {
+        /// <summary>
+        /// Only recognize the zoom gesture if both the zoom and the rotate gesture are performed.
+        /// </summary>
+        PrioritizeZoomGesture,
+
+        /// <summary>
+        /// Only recognize the rotate gesture if both the zoom and the rotate gesture are performed.
+        /// </summary>
+        PrioritizeRotateGesture,
+
+        /// <summary>
+        /// Recognize both gestures if they are performed (zoom and rotate).
+        /// </summary>
+        RecognizeBothGestures
+    }
+}

src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs

@@ -44,6 +44,25 @@ public interface IInputContext : IDisposable
         /// </remarks>
         IReadOnlyList<IMouse> Mice { get; }
 
+        /// <summary>
+        /// A list of all available touch devices.
+        /// </summary>
+        /// <remarks>
+        /// On some backends, this list may only contain 1 item. This is most likely because the underlying API doesn't
+        /// support multiple touch devices.
+        /// On some backends, this list might be empty. This is most likely because the underlying API doesn't
+        /// support touch devices.
+        /// </remarks>
+        IReadOnlyList<ITouchDevice> TouchDevices { get; }
+
+        /// <summary>
+        /// The primary touch device if any.
+        /// </summary>
+        /// <remarks>
+        /// On some backends this might just be an educated guess. Or might be null even though there are touch devices.
+        /// </remarks>
+        ITouchDevice? PrimaryTouchDevice { get; }
+
         /// <summary>
         /// A list of all other available input devices.
         /// </summary>

src/Input/Silk.NET.Input.Common/Interfaces/ITouchDevice.cs

@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace Silk.NET.Input
+{
+    /// <summary>
+    /// An interface representing a touch device.
+    /// </summary>
+    public interface ITouchDevice : IInputDevice, IDisposable
+    {
+        /// <summary>
+        /// The known fingers this touch device has tracked.
+        /// </summary>
+        // ReSharper disable once ReturnTypeCanBeEnumerable.Global
+        IReadOnlyDictionary<long, TouchFinger> Fingers { get; }
+
+        /// <summary>
+        /// A recognizer for gestures.
+        /// </summary>
+        TouchGestureRecognizer GestureRecognizer { get; }
+
+        /// <summary>
+        /// Checks if a specific finger is currently down on the touch surface.
+        /// </summary>
+        /// <param name="index">The finger index to check.</param>
+        /// <returns>Whether or not the finger is pressed down.</returns>
+        bool IsFingerDown(long index);
+
+        /// <summary>
+        /// Called when a finger touches the surface.
+        /// </summary>
+        event Action<ITouchDevice, TouchFinger>? FingerDown;
+
+        /// <summary>
+        /// Called when a finger is lifted from the surface.
+        /// </summary>
+        event Action<ITouchDevice, TouchFinger>? FingerUp;
+
+        /// <summary>
+        /// Called when the finger is moved while on the surface.
+        /// </summary>
+        event Action<ITouchDevice, TouchFinger, Vector2>? FingerMove;
+    }
+}

src/Input/Silk.NET.Input.Common/Internals/InputContextImplementationBase.cs

@@ -46,6 +46,8 @@ public void Dispose()
     public abstract IReadOnlyList<IJoystick> Joysticks { get; }
     public abstract IReadOnlyList<IKeyboard> Keyboards { get; }
     public abstract IReadOnlyList<IMouse> Mice { get; }
+    public abstract IReadOnlyList<ITouchDevice> TouchDevices { get; }
+    public abstract ITouchDevice? PrimaryTouchDevice { get; }
     public abstract IReadOnlyList<IInputDevice> OtherDevices { get; }
     public abstract event Action<IInputDevice, bool>? ConnectionChanged;
 }