Added rough on screen control that do not depend on UI

Author: ekcoh

Assets/Samples/RebindingUI/Game/GameplayManager.cs

@@ -259,7 +259,7 @@ void SpawnEnemy()
             --m_EnemySpawnCount;
 
             // Rent an enemy from the enemy pool
-            var enemyComponent = m_EnemyPool.Get();
+            var enemyComponent = m_EnemyPool.Get(); // TODO Null reference here on domain reload
 
             // Make the enemy spawn on border of visible game area
             var orthoSize = gameCamera.orthographicSize;

Assets/Samples/RebindingUI/OnScreen.meta

@@ -0,0 +1,65 @@
+using UnityEngine.InputSystem.LowLevel;
+
+namespace UnityEngine.InputSystem.Samples.RebindUI
+{
+    class ActiveDetector : ITouchProcessor
+    {
+        private Vector2 m_InitialPosition = Vector2.zero;
+        private double m_InitialTime = 0;
+        private bool m_Valid = true;
+
+        public void OnTouchBegin(ChangeMonitor context, in TouchState[] touches, int count, int index)
+        {
+            if (count == 1)
+            {
+                m_InitialPosition = touches[index].position;
+                m_InitialTime = Time.realtimeSinceStartupAsDouble;
+                m_Valid = true;
+
+                GestureEvent @event = new GestureEvent(
+                    delta: Vector2.zero,
+                    duration: 0.0,
+                    flags: GestureFlags.Active | GestureFlags.PhaseStart,
+                    start: m_InitialPosition
+                );
+                context.FireEvent(in @event);
+            }
+            else
+            {
+                m_Valid = false;
+            }
+        }
+
+        public void OnTouchEnd(ChangeMonitor context, in TouchState[] touches, int count, int index)
+        {
+            if (m_Valid)
+            {
+                GestureEvent @event = new GestureEvent(
+                    delta: touches[index].position - m_InitialPosition,
+                    duration: Time.realtimeSinceStartupAsDouble - m_InitialTime,
+                    flags: GestureFlags.Active | GestureFlags.PhaseEnd, start: m_InitialPosition);
+                context.FireEvent(in @event);
+            }
+        }
+
+        public void OnTouchMoved(ChangeMonitor context, in TouchState[] touches, int count, int index)
+        {
+            // Ignored
+        }
+
+        public void OnTouchCanceled(ChangeMonitor context, in TouchState[] touches, int count, int index)
+        {
+            if (m_Valid)
+            {
+                m_Valid = false;
+
+                GestureEvent @event = new GestureEvent(
+                    delta: touches[index].position - m_InitialPosition,
+                    duration: Time.realtimeSinceStartupAsDouble - m_InitialTime,
+                    flags: GestureFlags.Active | GestureFlags.PhaseCancel,
+                    start: m_InitialPosition);
+                context.FireEvent(in @event);
+            }
+        }
+    }
+}

Assets/Samples/RebindingUI/OnScreen/ActiveDetector.cs

@@ -0,0 +1,13 @@
+namespace UnityEngine.InputSystem.Samples.RebindUI
+{
+    /// <summary>
+    /// Specifies the geometric shape of the touch clipping area.
+    /// </summary>
+    public enum AreaShape
+    {
+        /// <summary>
+        /// A rectangular clipping area is used (default).
+        /// </summary>
+        Rectangle = 0,
+    }
+}

Assets/Samples/RebindingUI/OnScreen/ActiveDetector.cs.meta

@@ -0,0 +1,185 @@
+using System;
+using System.Text;
+using Unity.Properties;
+using UnityEngine.InputSystem.LowLevel;
+using UnityEngine.InputSystem.OnScreen;
+
+namespace UnityEngine.InputSystem.Samples.RebindUI
+{
+    abstract class ChangeMonitor : ITouchMonitor
+    {
+        public delegate void GestureEventHandler(in GestureEvent gestureEvent); // ref readonly not available until C# 12.0
+
+        protected ChangeMonitor(int maxTouches)
+        {
+            m_Touches = new TouchState[maxTouches];
+            Reset(Rect.zero, AreaShape.Rectangle, null);
+        }
+
+        public virtual void Reset(Rect bounds, AreaShape shape, ChangeMonitor.GestureEventHandler handler)
+        {
+            m_Handler = handler;
+            m_Bounds = bounds;
+            m_GestureFlags = GestureFlags.None;
+            m_Count = 0;
+        }
+
+        protected bool Contains(in TouchState touch)
+        {
+            switch (m_Shape)
+            {
+                case AreaShape.Rectangle:
+                {
+                    // TODO Caching opportunities here
+                    var display = Display.displays[touch.displayIndex];
+                    var width = display.renderingWidth;
+                    var height = display.renderingHeight;
+                    var absoluteBounds = new Rect(
+                        x: m_Bounds.xMin * width,
+                        y: m_Bounds.yMin * height,
+                        width: m_Bounds.width * width,
+                        height: m_Bounds.height * height);
+                    return absoluteBounds.Contains(touch.position);
+                }
+            }
+
+            return false;
+        }
+
+        protected int FindTouch(int touchId)
+        {
+            for (var i = 0; i < m_Count; ++i)
+                if (m_Touches[i].touchId == touchId)
+                    return i;
+            return -1;
+        }
+
+        public void FireEvent(in GestureEvent gestureEvent)
+        {
+            m_Handler.Invoke(in gestureEvent);
+        }
+
+        public ref readonly TouchState this[int index] => ref m_Touches[index]; // TODO Make sure no defensive copy is created
+
+        //set => SetValue(key, value);
+        protected Rect m_Bounds;
+        protected AreaShape m_Shape;
+        private GestureFlags m_GestureFlags;
+        private GestureEventHandler m_Handler;
+        protected readonly TouchState[] m_Touches;
+        protected int m_Count;
+
+        public abstract void NotifyControlStateChanged(InputControl control, double time, InputEventPtr eventPtr,
+            long monitorIndex);
+
+        public abstract void NotifyTimerExpired(InputControl control, double time, long monitorIndex,
+            int timerIndex);
+    }
+
+    // TODO This class is doing way too much error checking. Underlying implementation should be correct but
+    // there seem to be some kind of bug resulting in duplicate callbacks.
+    internal class ChangeMonitor<TProcessor> : ChangeMonitor, ITouchMonitor
+        where TProcessor : ITouchProcessor
+    {
+        private TProcessor m_Processor;
+
+        public ChangeMonitor(int maxTouches, TProcessor processor)
+            : base(maxTouches)
+        {
+            m_Processor = processor;
+        }
+
+        /*public static ChangeMonitor<TProcessor> Create(int maxTouches, TProcessor processor)
+        {
+            return new ChangeMonitor<TProcessor>(maxTouches, processor);
+        }*/
+
+        public override void Reset(Rect bounds, AreaShape shape, ChangeMonitor.GestureEventHandler handler)
+        {
+            // Make sure we cancel any pending touches. This way processor do not need a reset method.
+            for (var i = m_Count; i != 0; --i)
+                m_Processor.OnTouchCanceled(this, m_Touches, m_Count, m_Count - 1);
+
+            // Reset base
+            base.Reset(bounds, shape, handler);
+        }
+
+        public override void NotifyControlStateChanged(InputControl control, double time, InputEventPtr eventPtr, long monitorIndex)
+        {
+            // Ignore state change if it is not a touch state
+            if (!OnScreenUnsafeHelpers.TryGetStateCopy<TouchState>(eventPtr, TouchState.Format, out var state))
+                return;
+
+            // Intentionally left commented to aid debugging
+            //Debug.Log($"monitorIndex: {monitorIndex}, id: {state.touchId}, phase: {state.phase}, position: {state.position}");
+
+            // Delegate touch phase events
+            int index;
+            switch (state.phase)
+            {
+                case TouchPhase.Began:
+                    // Only add the point for tracking if we do not violate max point constraint.
+                    if (FindTouch(state.touchId) < 0 && m_Count < m_Touches.Length && Contains(state))
+                    {
+                        index = m_Count++;
+                        m_Touches[index] = state;
+
+                        m_Processor.OnTouchBegin(this, m_Touches, m_Count, index);
+                    }
+                    break;
+
+                case TouchPhase.Ended:
+                    index = FindTouch(state.touchId);
+                    if (index < 0)
+                        break;
+
+                    m_Processor.OnTouchEnd(this, m_Touches, m_Count, index);
+
+                    // Remove point
+                    if (index != m_Count - 1)
+                    {
+                        Array.Copy(m_Touches, index + 1,
+                            m_Touches, index, m_Count - index - 1);
+                    }
+                    --m_Count;
+                    break;
+
+                case TouchPhase.Canceled:
+                    index = FindTouch(state.touchId);
+                    if (index < 0)
+                        break;
+
+                    m_Processor.OnTouchCanceled(this, m_Touches, m_Count, index);
+
+                    // TODO Need to remove or will we get end?!
+                    break;
+
+                case TouchPhase.Moved:
+                    index = FindTouch(state.touchId);
+                    if (index < 0)
+                    {
+                        if (m_Count < m_Touches.Length && Contains(state))
+                        {
+                            // TODO Handle as an addition
+                        }
+
+                        break; // Unexpected or not tracked by this processor
+                    }
+
+                    m_Touches[index] = state;
+
+                    // TODO Handle capture
+
+                    m_Processor.OnTouchMoved(this, m_Touches, m_Count, index);
+                    break;
+
+                case TouchPhase.Stationary: // Not used by touchscreen
+                case TouchPhase.None:       // Default initialized (no meaning)
+                default:
+                    break;
+            }
+        }
+
+        public override void NotifyTimerExpired(InputControl control, double time, long monitorIndex, int timerIndex) {}
+    }
+}

Assets/Samples/RebindingUI/OnScreen/AreaShape.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace UnityEngine.InputSystem.Samples.RebindUI
+{
+    public enum PredefinedCurve
+    {
+        Linear,
+        Quatratic,
+        Cubic,
+    }
+
+    public static class CurveExtensions
+    {
+        /// <summary>
+        /// Apply response curve shaping to vlaue <paramref name="v"/>.
+        /// </summary>
+        /// <param name="v">The normalized value to be transformed.</param>
+        /// <param name="curve">The response curve.</param>
+        /// <returns>Transformed normalized value.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="curve"/> is outside valid range.</exception>
+        public static float Transform(float x, PredefinedCurve curve)
+        {
+            switch (curve)
+            {
+                case PredefinedCurve.Linear:
+                    return x;
+                case PredefinedCurve.Quatratic:
+                    return x * x;
+                case PredefinedCurve.Cubic:
+                    return x * x * x;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(curve));
+            }
+        }
+
+        /// <summary>
+        /// Apply response curve shaping to vector <paramref name="v"/>.
+        /// </summary>
+        /// <remarks>The provided vector is first transformed to polar form, then the vector length is scaled
+        /// before it is finally converted back to euclidean space.</remarks>
+        /// <param name="v">A normalized Euclidean vector to be transformed.</param>
+        /// <param name="curve">The response curve.</param>
+        /// <returns>Transformed normalized Euclidean vector.</returns>
+        public static Vector2 Transform(Vector2 v, PredefinedCurve curve)
+        {
+            var r = Transform(v.magnitude, curve);
+            var theta = Mathf.Atan2(v.y, v.x);
+            return new Vector2(r * Mathf.Cos(theta), r * Mathf.Sin(theta));
+        }
+    }
+}