FIX: Input in editor leaking into play mode (case 1191342, #978).

Author: Rene Damm

Assets/Tests/InputSystem/CoreTests_Editor.cs

@@ -2150,6 +2150,36 @@ public IEnumerator TODO_Editor_PlayerActionDoesNotTriggerWhenGameViewIsNotFocuse
         throw new NotImplementedException();
     }
 
+    // While going into play mode, the editor will be unresponsive. So what will happen is that when the user clicks the
+    // play mode button and then moves the mouse around while Unity is busy going into play mode, the game will receive
+    // a huge pointer motion delta in one of its first frames. If pointer motion is tied to camera motion, for example,
+    // this will usually lead to the camera looking down at the ground because after clicking the play mode button at the
+    // top of the UI, the user will likely move the pointer down towards the game view area thus generating a large down
+    // motion delta.
+    //
+    // What we do to counter this is to record the time of when we enter play mode and then record the time again when
+    // we have fully entered play mode. All the events in-between we discard.
+    [Test]
+    [Category("Editor")]
+    public void Editor_InputEventsOccurringWhileGoingIntoPlayMode_AreDiscarded()
+    {
+        var mouse = InputSystem.AddDevice<Mouse>();
+
+        // We need to actually pass time and have a non-zero start time for this to work.
+        currentTime = 1;
+        InputSystem.OnPlayModeChange(PlayModeStateChange.ExitingEditMode);
+        InputSystem.QueueStateEvent(mouse, new MouseState { position = new Vector2(234, 345) });
+        currentTime = 2;
+        InputSystem.OnPlayModeChange(PlayModeStateChange.EnteredPlayMode);
+
+        InputSystem.Update();
+
+        Assert.That(mouse.position.ReadValue(), Is.EqualTo(default(Vector2)));
+
+        // Make sure the event was not left in the buffer.
+        Assert.That(runtime.m_EventCount, Is.EqualTo(0));
+    }
+
     ////TODO: tests for InputAssetImporter; for this we need C# mocks to be able to cut us off from the actual asset DB
 }
 #endif // UNITY_EDITOR

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -34,6 +34,8 @@ however, it has to be formatted properly to pass verification tests.
 
 - `InputUser` in combination with touchscreens no longer throws `InvalidOperationException` complaining about incorrect state format.
  * In a related change, `InputControlExtensions.GetStatePtrFromStateEvent` now works with touch events, too.
+- Input that occurs in-between pressing the play button and the game starting no longer leaks into the game (case 1191342).
+  * This usually manifested itself as large accumulated mouse deltas leading to such effects as the camera immediately jerking around on game start.
 - Removing a device no longer has the potential of corrupting state change monitors (and thus actions getting triggered) from other devices.
   * This bug led to input being missed on a device once another device had been removed.
 

Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/MultiTapInteraction.cs

@@ -3,6 +3,8 @@
 using UnityEngine.InputSystem.Editor;
 #endif
 
+////TODO: change this so that the interaction stays performed when the tap count is reached until the button is released
+
 namespace UnityEngine.InputSystem.Interactions
 {
     /// <summary>

Packages/com.unity.inputsystem/InputSystem/InputManager.cs

@@ -2477,16 +2477,40 @@ private unsafe void OnUpdate(InputUpdateType updateType, ref InputEventBuffer ev
                 if (remainingEventCount == 0)
                     break;
 
+                var currentEventTimeInternal = currentEventReadPtr->internalTime;
+
+                // In the editor, we discard all input events that occur in-between exiting edit mode and having
+                // entered play mode as otherwise we'll spill a bunch of UI events that have occurred while the
+                // UI was sort of neither in this mode nor in that mode. This would usually lead to the game receiving
+                // an accumulation of spurious inputs right in one of its first updates.
+                //
+                // NOTE: There's a chance the solution here will prove inadequate on the long run. We may do things
+                //       here such as throwing partial touches away and then letting the rest of a touch go through.
+                //       Could be that ultimately we need to issue a full reset of all devices at the beginning of
+                //       play mode in the editor.
+                #if UNITY_EDITOR
+                if ((updateType & InputUpdateType.Editor) == 0 &&
+                    InputSystem.s_SystemObject.exitEditModeTime > 0 &&
+                    currentEventTimeInternal >= InputSystem.s_SystemObject.exitEditModeTime &&
+                    (currentEventTimeInternal < InputSystem.s_SystemObject.enterPlayModeTime ||
+                     InputSystem.s_SystemObject.enterPlayModeTime == 0))
+                {
+                    eventBuffer.AdvanceToNextEvent(ref currentEventReadPtr, ref currentEventWritePtr,
+                        ref numEventsRetainedInBuffer, ref remainingEventCount, leaveEventInBuffer: false);
+                    continue;
+                }
+                #endif
+
                 // If we're timeslicing, check if the event time is within limits.
-                if (timesliceEvents && currentEventReadPtr->internalTime >= currentTime)
+                if (timesliceEvents && currentEventTimeInternal >= currentTime)
                 {
                     eventBuffer.AdvanceToNextEvent(ref currentEventReadPtr, ref currentEventWritePtr,
                         ref numEventsRetainedInBuffer, ref remainingEventCount, leaveEventInBuffer: true);
                     continue;
                 }
 
-                if (currentEventReadPtr->internalTime <= currentTime)
-                    totalEventLag += currentTime - currentEventReadPtr->internalTime;
+                if (currentEventTimeInternal <= currentTime)
+                    totalEventLag += currentTime - currentEventTimeInternal;
 
                 // Grab device for event. In before-render updates, we already had to
                 // check the device.
@@ -2507,10 +2531,9 @@ private unsafe void OnUpdate(InputUpdateType updateType, ref InputEventBuffer ev
                 }
 
                 // Give listeners a shot at the event.
-                var listenerCount = m_EventListeners.length;
-                if (listenerCount > 0)
+                if (m_EventListeners.length > 0)
                 {
-                    for (var i = 0; i < listenerCount; ++i)
+                    for (var i = 0; i < m_EventListeners.length; ++i)
                         m_EventListeners[i](new InputEventPtr(currentEventReadPtr), device);
 
                     // If a listener marks the event as handled, we don't process it further.
@@ -2524,7 +2547,6 @@ private unsafe void OnUpdate(InputUpdateType updateType, ref InputEventBuffer ev
 
                 // Process.
                 var currentEventType = currentEventReadPtr->type;
-                var currentEventTimeInternal = currentEventReadPtr->internalTime;
                 switch (currentEventType)
                 {
                     case StateEvent.Type:

Packages/com.unity.inputsystem/InputSystem/InputSystem.cs

@@ -2801,12 +2801,18 @@ internal static void InitializeInEditor(IInputRuntime runtime = null)
             Profiling.Profiler.EndSample();
         }
 
-        private static void OnPlayModeChange(PlayModeStateChange change)
+        internal static void OnPlayModeChange(PlayModeStateChange change)
         {
             switch (change)
             {
                 case PlayModeStateChange.ExitingEditMode:
                     s_SystemObject.settings = JsonUtility.ToJson(settings);
+                    s_SystemObject.exitEditModeTime = InputRuntime.s_Instance.currentTime;
+                    s_SystemObject.enterPlayModeTime = 0;
+                    break;
+
+                case PlayModeStateChange.EnteredPlayMode:
+                    s_SystemObject.enterPlayModeTime = InputRuntime.s_Instance.currentTime;
                     break;
 
                 ////TODO: also nuke all callbacks installed on InputActions and InputActionMaps
@@ -3028,6 +3034,7 @@ internal struct State
             [SerializeField] public InputRemoting.SerializedState remotingState;
             #if UNITY_EDITOR
             [SerializeField] public InputEditorUserSettings.SerializedState userSettings;
+            [SerializeField] public string systemObject;
             #endif
             ////REVIEW: preserve InputUser state? (if even possible)
         }
@@ -3064,6 +3071,7 @@ internal static void SaveAndReset(bool enableRemoting = false, IInputRuntime run
                 remotingState = s_Remote?.SaveState() ?? new InputRemoting.SerializedState(),
                 #if UNITY_EDITOR
                 userSettings = InputEditorUserSettings.s_Settings,
+                systemObject = JsonUtility.ToJson(s_SystemObject),
                 #endif
             });
 
@@ -3094,6 +3102,7 @@ internal static void Restore()
 
             #if UNITY_EDITOR
             InputEditorUserSettings.s_Settings = state.userSettings;
+            JsonUtility.FromJsonOverwrite(state.systemObject, s_SystemObject);
             #endif
 
             // Get devices that keep global lists (like Gamepad) to re-initialize them

Packages/com.unity.inputsystem/InputSystem/InputSystemObject.cs

@@ -15,6 +15,8 @@ internal class InputSystemObject : ScriptableObject, ISerializationCallbackRecei
         [SerializeField] public InputSystem.State systemState;
         [SerializeField] public bool newInputBackendsCheckedAsEnabled;
         [SerializeField] public string settings;
+        [SerializeField] public double exitEditModeTime;
+        [SerializeField] public double enterPlayModeTime;
 
         public void OnBeforeSerialize()
         {

Packages/com.unity.inputsystem/InputSystem/Plugins/OnScreen/OnScreenControl.cs

@@ -8,6 +8,8 @@
 
 ////TODO: make this survive domain reloads
 
+////TODO: allow feeding into more than one control
+
 namespace UnityEngine.InputSystem.OnScreen
 {
     /// <summary>

Packages/com.unity.inputsystem/Tests/TestFixture/InputTestRuntime.cs

@@ -359,7 +359,7 @@ public double currentTimeOffsetToRealtimeSinceStartup
 
         private int m_NextDeviceId = 1;
         private int m_NextEventId = 1;
-        private int m_EventCount;
+        internal int m_EventCount;
         private int m_EventWritePosition;
         private NativeArray<byte> m_EventBuffer = new NativeArray<byte>(1024 * 1024, Allocator.Persistent);
         private List<PairedUser> m_UserPairings;