FIX: EnhancedTouch getting out of sync when disabled and reenabled (case 1286865, #1250).

jimon · web-flow · commit a0b21ba893bc · 2021-01-15T17:50:20.000+01:00
diff --git a/Assets/Tests/InputSystem/Plugins/EnhancedTouchTests.cs b/Assets/Tests/InputSystem/Plugins/EnhancedTouchTests.cs
@@ -798,6 +798,42 @@ public void EnhancedTouch_CanReceiveCallbacksOnFingerActivity()
         }));
     }
 
+    // https://fogbugz.unity3d.com/f/cases/1286865/
+    [Test]
+    [Category("EnhancedTouch")]
+    public void EnhancedTouch_CanBeDisabledAndReenabled()
+    {
+        BeginTouch(1, new Vector2(0.123f, 0.234f), queueEventOnly: true);
+        InputSystem.Update();
+        Assert.That(Touch.activeTouches.Count, Is.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Began));
+
+        MoveTouch(1, new Vector2(0.234f, 0.345f), queueEventOnly: true);
+        InputSystem.Update();
+        Assert.That(Touch.activeTouches.Count, Is.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Moved));
+
+        InputSystem.Update();
+        Assert.That(Touch.activeTouches.Count, Is.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Stationary));
+
+        EnhancedTouchSupport.Disable();
+        EnhancedTouchSupport.Enable();
+
+        InputSystem.Update();
+        Assert.That(Touch.activeTouches.Count, Is.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Stationary));
+
+        MoveTouch(1, new Vector2(0.123f, 0.234f), queueEventOnly: true);
+        InputSystem.Update();
+        Assert.That(Touch.activeTouches.Count, Is.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Moved));
+
+        InputSystem.Update();
+        Assert.That(Touch.activeTouches.Count, Is.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Stationary));
+    }
+
     [Test]
     [Category("EnhancedTouch")]
     [Property("EnhancedTouchDisabled", 1)]
diff --git a/Packages/com.unity.inputsystem/CHANGELOG.md b/Packages/com.unity.inputsystem/CHANGELOG.md
@@ -26,6 +26,7 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed restart prompt after package installation not appearing on Unity 2020.2+ ([case 1292513](https://issuetracker.unity3d.com/issues/input-system-after-package-install-the-update-slash-switch-and-restart-prompt-does-not-appear)).
 - Fixed action with multiple bindings getting stuck in `Performed` state when two or more controls are pressed at the same time ([case 1295535](https://issuetracker.unity3d.com/issues/input-system-not-registering-multiple-inputs)).
   * Regression introduced in 1.1-preview.2.
+- Fixed `Touch.activeTouches` having incorrect touch phases after calling `EnhancedTouch.Disable()` and then `EnhancedTouch.Enable()` ([case 1286865](https://issuetracker.unity3d.com/issues/new-input-system-began-moved-and-ended-touch-phases-are-not-reported-when-a-second-scene-is-loaded)).
 
 #### Actions
 
diff --git a/Packages/com.unity.inputsystem/InputSystem/InputManager.cs b/Packages/com.unity.inputsystem/InputSystem/InputManager.cs
@@ -2257,14 +2257,7 @@ private void OnBeforeUpdate(InputUpdateType updateType)
 
             InputStateBuffers.SwitchTo(m_StateBuffers, updateType);
 
-            InputUpdate.s_LastUpdateType = updateType;
-            if (updateType == InputUpdateType.Dynamic || updateType == InputUpdateType.Manual || updateType == InputUpdateType.Fixed)
-            {
-                // We want to update step counts to be correct in OnNextUpdate() and onBeforeUpdate callbacks.
-                // We use a boolean flag to tell OnUpdate() that we've already incremented the count.
-                ++InputUpdate.s_UpdateStepCount;
-                InputUpdate.s_HaveUpdatedStepCount = true;
-            }
+            InputUpdate.OnBeforeUpdate(updateType);
 
             // For devices that have state callbacks, tell them we're carrying state over
             // into the next frame.
@@ -2586,20 +2579,9 @@ private unsafe void OnUpdate(InputUpdateType updateType, ref InputEventBuffer ev
             // Store current time offset.
             InputRuntime.s_CurrentTimeOffsetToRealtimeSinceStartup = m_Runtime.currentTimeOffsetToRealtimeSinceStartup;
 
-            InputUpdate.s_LastUpdateType = updateType;
             InputStateBuffers.SwitchTo(m_StateBuffers, updateType);
 
-            var isBeforeRenderUpdate = false;
-            if (updateType == InputUpdateType.Dynamic || updateType == InputUpdateType.Manual || updateType == InputUpdateType.Fixed)
-            {
-                if (!InputUpdate.s_HaveUpdatedStepCount)
-                    ++InputUpdate.s_UpdateStepCount;
-                InputUpdate.s_HaveUpdatedStepCount = false;
-            }
-            else if (updateType == InputUpdateType.BeforeRender)
-            {
-                isBeforeRenderUpdate = true;
-            }
+            InputUpdate.OnUpdate(updateType);
 
             // See if we're supposed to only take events up to a certain time.
             // NOTE: We do not require the events in the queue to be sorted. Instead, we will walk over
@@ -2650,7 +2632,7 @@ private unsafe void OnUpdate(InputUpdateType updateType, ref InputEventBuffer ev
 
                 // In before render updates, we only take state events and only those for devices
                 // that have before render updates enabled.
-                if (isBeforeRenderUpdate)
+                if (updateType == InputUpdateType.BeforeRender)
                 {
                     while (remainingEventCount > 0)
                     {
diff --git a/Packages/com.unity.inputsystem/InputSystem/InputUpdateType.cs b/Packages/com.unity.inputsystem/InputSystem/InputUpdateType.cs
@@ -71,27 +71,98 @@ public enum InputUpdateType
 
     internal static class InputUpdate
     {
-        public static bool s_HaveUpdatedStepCount;
+        public static uint s_UpdateStepCount; // read only, but kept as a variable for performance reasons
         public static InputUpdateType s_LastUpdateType;
-        public static uint s_UpdateStepCount;
+        public static UpdateStepCount s_PlayerUpdateStepCount;
+        #if UNITY_EDITOR
+        public static UpdateStepCount s_EditorUpdateStepCount;
+        #endif
         public static uint s_LastUpdateRetainedEventBytes;
         public static uint s_LastUpdateRetainedEventCount;
 
+        [Serializable]
+        public struct UpdateStepCount
+        {
+            private bool m_WasUpdated;
+
+            public uint value { get; private set; }
+
+            public void OnBeforeUpdate()
+            {
+                m_WasUpdated = true;
+                value++;
+            }
+
+            public void OnUpdate()
+            {
+                // only increment if OnBeforeUpdate was not called
+                if (!m_WasUpdated)
+                    value++;
+                m_WasUpdated = false;
+            }
+        };
+
         [Serializable]
         public struct SerializedState
         {
             public InputUpdateType lastUpdateType;
-            public uint updateStepCount;
+            public UpdateStepCount playerUpdateStepCount;
+            #if UNITY_EDITOR
+            public UpdateStepCount editorUpdateStepCount;
+            #endif
             public uint lastUpdateRetainedEventBytes;
             public uint lastUpdateRetainedEventCount;
         }
 
+        internal static void OnBeforeUpdate(InputUpdateType type)
+        {
+            s_LastUpdateType = type;
+            switch (type)
+            {
+                case InputUpdateType.Dynamic:
+                case InputUpdateType.Manual:
+                case InputUpdateType.Fixed:
+                    s_PlayerUpdateStepCount.OnBeforeUpdate();
+                    s_UpdateStepCount = s_PlayerUpdateStepCount.value;
+                    break;
+                #if UNITY_EDITOR
+                case InputUpdateType.Editor:
+                    s_EditorUpdateStepCount.OnBeforeUpdate();
+                    s_UpdateStepCount = s_EditorUpdateStepCount.value;
+                    break;
+                #endif
+            }
+        }
+
+        internal static void OnUpdate(InputUpdateType type)
+        {
+            s_LastUpdateType = type;
+            switch (type)
+            {
+                case InputUpdateType.Dynamic:
+                case InputUpdateType.Manual:
+                case InputUpdateType.Fixed:
+                    s_PlayerUpdateStepCount.OnUpdate();
+                    s_UpdateStepCount = s_PlayerUpdateStepCount.value;
+                    break;
+                #if UNITY_EDITOR
+                case InputUpdateType.Editor:
+                    s_EditorUpdateStepCount.OnUpdate();
+                    s_UpdateStepCount = s_EditorUpdateStepCount.value;
+                    break;
+                #endif
+            }
+        }
+
         public static SerializedState Save()
         {
             return new SerializedState
             {
                 lastUpdateType = s_LastUpdateType,
-                updateStepCount = s_UpdateStepCount,
+                playerUpdateStepCount = s_PlayerUpdateStepCount,
+                #if UNITY_EDITOR
+                editorUpdateStepCount = s_EditorUpdateStepCount,
+                #endif
                 lastUpdateRetainedEventBytes = s_LastUpdateRetainedEventBytes,
                 lastUpdateRetainedEventCount = s_LastUpdateRetainedEventCount,
             };
@@ -100,9 +171,30 @@ public static SerializedState Save()
         public static void Restore(SerializedState state)
         {
             s_LastUpdateType = state.lastUpdateType;
-            s_UpdateStepCount = state.updateStepCount;
+            s_PlayerUpdateStepCount = state.playerUpdateStepCount;
             s_LastUpdateRetainedEventBytes = state.lastUpdateRetainedEventBytes;
             s_LastUpdateRetainedEventCount = state.lastUpdateRetainedEventCount;
+            #if UNITY_EDITOR
+            s_EditorUpdateStepCount = state.editorUpdateStepCount;
+            #endif
+
+            switch (s_LastUpdateType)
+            {
+                case InputUpdateType.Dynamic:
+                case InputUpdateType.Manual:
+                case InputUpdateType.Fixed:
+                    s_UpdateStepCount = s_PlayerUpdateStepCount.value;
+                    break;
+                #if UNITY_EDITOR
+                case InputUpdateType.Editor:
+                    s_UpdateStepCount = s_EditorUpdateStepCount.value;
+                    break;
+                #endif
+                default:
+                    // if there was no previous update type, reset the counter
+                    s_UpdateStepCount = 0;
+                    break;
+            }
         }
     }
 }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Finger.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Finger.cs
@@ -91,7 +91,7 @@ public Touch currentTouch
                 if (touch.isInProgress)
                     return touch;
                 // Ended touches stay current in the frame they ended in.
-                if (touch.updateStepCount == Touch.s_PlayerState.updateStepCount)
+                if (touch.updateStepCount == InputUpdate.s_UpdateStepCount)
                     return touch;
                 return default;
             }
@@ -124,6 +124,10 @@ internal Finger(Touchscreen screen, int index, InputUpdateType updateMask)
                 updateMask = updateMask,
             };
             m_StateHistory.StartRecording();
+
+            // record the current state if touch is already in progress
+            if (screen.touches[index].isInProgress)
+                m_StateHistory.RecordStateChange(screen.touches[index], screen.touches[index].ReadValue());
         }
 
         private static unsafe bool ShouldRecordTouch(InputControl control, double time, InputEventPtr eventPtr)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Touch.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Touch.cs
@@ -565,8 +565,6 @@ internal static void BeginUpdate()
             }
             #endif
 
-            ++s_PlayerState.updateStepCount;
-
             // If we have any touches in activeTouches that are ended or canceled,
             // we need to clear them in the next frame.
             if (s_PlayerState.haveActiveTouchesNeedingRefreshNextUpdate)
@@ -598,7 +596,6 @@ internal static void BeginUpdate()
         internal struct FingerAndTouchState
         {
             public InputUpdateType updateMask;
-            public uint updateStepCount;
             public Finger[] fingers;
             public Finger[] activeFingers;
             public Touch[] activeTouches;
@@ -691,7 +688,7 @@ public unsafe void UpdateActiveTouches()
                 }
                 activeTouchCount = 0;
                 haveActiveTouchesNeedingRefreshNextUpdate = false;
-                var currentUpdateStepCount = s_PlayerState.updateStepCount;
+                var currentUpdateStepCount = InputUpdate.s_UpdateStepCount;
 
                 ////OPTIMIZE: Handle touchscreens that have no activity more efficiently
                 ////FIXME: This is sensitive to history size; we probably need to ensure that the Begans and Endeds/Canceleds of touches are always available to us
