MERGE: develop => stable.

Author: Rene Damm

.gitignore

@@ -25,7 +25,6 @@ Packages/com.unity.inputsystem/Documentation~/ApiDocs/**
 Packages/com.unity.inputsystem/.DS_Store
 Packages/com.unity.inputsystem/.npmrc
 
-Packages/com.unity.package-manager-doctools/
 Packages/com.unity.package-manager-ui/
 
 .Editor

Assets/Samples/EditorWindowDemo/.sample.json

@@ -2,6 +2,8 @@
 using UnityEngine.InputSystem.LowLevel;
 using UnityEngine.UI;
 
+////TODO: respect cursor lock mode
+
 ////TODO: investigate how driving the HW cursor behaves when FPS drops low
 ////      (also, maybe we can add support where we turn the gamepad mouse on and off automatically based on whether the system mouse is used)
 
@@ -11,6 +13,8 @@
 
 ////TODO: make it work with PlayerInput such that it will automatically look up actions in the actual PlayerInput instance it is used with (based on the action IDs it has)
 
+////REVIEW: should we default the SW cursor position to the center of the screen?
+
 ////REVIEW: consider this for inclusion directly in the input system
 
 namespace UnityEngine.InputSystem.UI
@@ -439,7 +443,9 @@ private void UpdateMotion()
                 InputState.Change(m_VirtualMouse.delta, delta);
 
                 // Update software cursor transform, if any.
-                if (m_CursorTransform != null && m_CursorMode == CursorMode.SoftwareCursor)
+                if (m_CursorTransform != null &&
+                    (m_CursorMode == CursorMode.SoftwareCursor ||
+                     (m_CursorMode == CursorMode.HardwareCursorIfAvailable && m_SystemMouse == null)))
                     m_CursorTransform.anchoredPosition = newPosition;
 
                 m_LastStickValue = stickValue;

Assets/Samples/EditorWindowDemo/Editor.meta

@@ -2435,6 +2435,27 @@ public void Actions_CanAddBindingsToActions()
         Assert.That(action.controls, Has.Exactly(1).SameAs(gamepad.rightStick));
     }
 
+    // Case 1218544
+    [Test]
+    [Category("Actions")]
+    public void Actions_CanAddBindingsToActions_AfterActionHasBeenEnabled()
+    {
+        var gamepad = InputSystem.AddDevice<Gamepad>();
+        var action = new InputAction(name: "test", binding: "<Gamepad>/leftStick");
+        action.Enable();
+
+        Assert.That(action.controls, Is.EquivalentTo(new[] { gamepad.leftStick }));
+        Assert.That(action.bindings, Has.Count.EqualTo(1));
+        Assert.That(action.bindings[0].effectivePath, Is.EqualTo("<Gamepad>/leftStick"));
+
+        action.AddBinding("<Gamepad>/rightStick");
+
+        Assert.That(action.controls, Is.EquivalentTo(new[] { gamepad.leftStick, gamepad.rightStick }));
+        Assert.That(action.bindings, Has.Count.EqualTo(2));
+        Assert.That(action.bindings[0].path, Is.EqualTo("<Gamepad>/leftStick"));
+        Assert.That(action.bindings[0].path, Is.EqualTo("<Gamepad>/leftStick"));
+    }
+
     [Test]
     [Category("Actions")]
     public void Actions_BindingsHaveUniqueIDs()

Assets/Samples/EditorWindowDemo/Editor/EditorWindowDemo.cs

@@ -407,17 +407,25 @@ public void Actions_InteractiveRebinding_IgnoresNoisyControls()
         InputSystem.RegisterLayout(layout);
         var device = InputSystem.AddDevice("TestLayout");
 
-        using (var rebind = action.PerformInteractiveRebinding().OnMatchWaitForAnother(0).Start())
+        using (var rebind = new InputActionRebindingExtensions.RebindingOperation()
+                   .WithAction(action)
+                   .OnMatchWaitForAnother(0)
+                   .Start())
         {
             Set((ButtonControl)device["noisyButton"], 0.678f);
 
             Assert.That(rebind.completed, Is.False);
             Assert.That(action.bindings[0].overridePath, Is.Null);
 
+            Set((ButtonControl)device["noisyButton"], 0f);
+
             // Can disable the behavior. This is most useful in combination with a custom
             // OnPotentialMatch() callback or when the selection-by-magnitude logic will do
             // a good enough job.
-            rebind.WithoutIgnoringNoisyControls();
+            rebind.Cancel();
+            rebind
+                .WithoutIgnoringNoisyControls()
+                .Start();
 
             Set((ButtonControl)device["noisyButton"], 0.789f);
 
@@ -449,25 +457,23 @@ public void Actions_InteractiveRebinding_UsesSyntheticControlsOnlyWhenBestMatch(
             // a candidate as well as leftStick/x. However, leftStick/right is synthetic so X axis should
             // win. Note that if we set expectedControlType to "Button", leftStick/x will get ignored
             // and leftStick/left will get picked.
-            InputSystem.QueueStateEvent(gamepad, new GamepadState { leftStick = new Vector2(1, 0)});
-            InputSystem.Update();
+            Set(gamepad.leftStick, Vector2.right);
 
             Assert.That(rebind.completed, Is.False);
             Assert.That(rebind.candidates, Is.EquivalentTo(new[] {gamepad.leftStick.x, gamepad.leftStick.right}));
             Assert.That(rebind.scores, Has.Count.EqualTo(2));
             Assert.That(rebind.scores[0], Is.GreaterThan(rebind.scores[1]));
 
             // Reset.
-            InputSystem.QueueStateEvent(gamepad, new GamepadState());
-            InputSystem.Update();
-            rebind.RemoveCandidate(gamepad.leftStick.x);
-            rebind.RemoveCandidate(gamepad.leftStick.right);
+            Set(gamepad.leftStick, Vector2.zero);
 
             // Switch to looking only for buttons. leftStick/x will no longer be a suitable pick.
-            rebind.WithExpectedControlType("Button");
+            rebind.Cancel();
+            rebind
+                .WithExpectedControlType("Button")
+                .Start();
 
-            InputSystem.QueueStateEvent(gamepad, new GamepadState { leftStick = new Vector2(1, 0)});
-            InputSystem.Update();
+            Set(gamepad.leftStick, Vector2.right);
 
             Assert.That(rebind.completed, Is.True);
             Assert.That(action.bindings[0].overridePath, Is.EqualTo("<Gamepad>/leftStick/right"));
@@ -572,33 +578,71 @@ public void Actions_InteractiveRebinding_RespectsExpectedControlLayoutIfSet()
         }
     }
 
-    // If a control is already actuated when we initiate a rebind, we first require it to go
-    // back to its default value.
+    // We want to be able to deal with controls that are already actuated when the rebinding starts and
+    // also with controls that don't usually go back to default values at all.
+    //
+    // What we require is that when we detect sufficient actuation on a control in an event, we compare
+    // it to the control's current actuation level when we first considered it. This is expected to work
+    // regardless of whether we are suppressing events or not.
+    //
+    // https://fogbugz.unity3d.com/f/cases/1215784/
     [Test]
     [Category("Actions")]
-    public void Actions_InteractiveRebinding_RequiresControlToBeActuatedStartingWithDefaultValue()
+    public void Actions_InteractiveRebinding_WhenControlAlreadyActuated_HasToCrossMagnitudeThresholdFromCurrentActuation()
     {
         var action = new InputAction(binding: "<Gamepad>/buttonSouth");
         var gamepad = InputSystem.AddDevice<Gamepad>();
 
-        // Put buttonNorth in pressed state.
-        InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.North));
-        InputSystem.Update();
+        // Actuate some controls.
+        Press(gamepad.buttonNorth);
+        Set(gamepad.leftTrigger, 0.75f);
 
-        using (var rebind = new InputActionRebindingExtensions.RebindingOperation().WithAction(action).Start())
+        using (var rebind = new InputActionRebindingExtensions.RebindingOperation()
+                   .WithAction(action)
+                   .WithMagnitudeHavingToBeGreaterThan(0.25f)
+                   .Start())
         {
-            // Reset buttonNorth to unpressed state.
-            InputSystem.QueueStateEvent(gamepad, new GamepadState());
-            InputSystem.Update();
+            Release(gamepad.buttonNorth);
 
             Assert.That(rebind.completed, Is.False);
+            Assert.That(rebind.candidates, Is.Empty);
 
-            // Now press it again.
-            InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.North));
-            InputSystem.Update();
+            Set(gamepad.leftTrigger, 0.9f);
+
+            Assert.That(rebind.completed, Is.False);
+            Assert.That(rebind.candidates, Is.Empty);
+
+            Set(gamepad.leftTrigger, 0f);
+
+            Assert.That(rebind.completed, Is.False);
+            Assert.That(rebind.candidates, Is.Empty);
+
+            Set(gamepad.leftTrigger, 0.7f);
 
             Assert.That(rebind.completed, Is.True);
-            Assert.That(action.bindings[0].overridePath, Is.EqualTo("<Gamepad>/buttonNorth"));
+            Assert.That(action.bindings[0].overridePath, Is.EqualTo("<Gamepad>/leftTrigger"));
+        }
+    }
+
+    [Test]
+    [Category("Actions")]
+    public void Actions_InteractiveRebinding_CanGetActuationMagnitudeOfCandidateControls()
+    {
+        var action = new InputAction(binding: "<Gamepad>/buttonSouth");
+        var gamepad = InputSystem.AddDevice<Gamepad>();
+
+        using (var rebind = new InputActionRebindingExtensions.RebindingOperation()
+                   .WithAction(action)
+                   .WithMagnitudeHavingToBeGreaterThan(0.25f)
+                   .OnMatchWaitForAnother(1)
+                   .Start())
+        {
+            Set(gamepad.leftTrigger, 0.75f);
+
+            Assert.That(rebind.candidates, Has.Count.EqualTo(1));
+            Assert.That(rebind.magnitudes, Has.Count.EqualTo(rebind.candidates.Count));
+            Assert.That(rebind.candidates[0], Is.SameAs(gamepad.leftTrigger));
+            Assert.That(rebind.magnitudes[0], Is.EqualTo(0.75).Within(0.00001));
         }
     }
 
@@ -801,14 +845,12 @@ public void Actions_InteractiveRebinding_CanSpecifyMagnitudeThreshold()
                        .WithMagnitudeHavingToBeGreaterThan(0.5f)
                        .Start())
         {
-            InputSystem.QueueStateEvent(gamepad, new GamepadState {leftTrigger = 0.4f});
-            InputSystem.Update();
+            Set(gamepad.leftTrigger, 0.4f);
 
             Assert.That(rebind.completed, Is.False);
             Assert.That(rebind.candidates, Is.Empty);
 
-            InputSystem.QueueStateEvent(gamepad, new GamepadState {leftTrigger = 0.6f});
-            InputSystem.Update();
+            Set(gamepad.leftTrigger, 0.6f);
 
             Assert.That(rebind.completed, Is.True);
             Assert.That(action.bindings[0].overridePath, Is.EqualTo("<Gamepad>/leftTrigger"));

Assets/Samples/EditorWindowDemo/README.md

@@ -40,13 +40,10 @@ public void Devices_CanGetAllDevices()
         var mouse = InputSystem.AddDevice<Mouse>();
 
         Assert.That(InputSystem.devices, Is.EquivalentTo(new InputDevice[] { gamepad1, gamepad2, keyboard, mouse }));
-        // Alternate getter.
-        Assert.That(InputDevice.all, Is.EquivalentTo(new InputDevice[] { gamepad1, gamepad2, keyboard, mouse }));
 
         InputSystem.RemoveDevice(keyboard);
 
         Assert.That(InputSystem.devices, Is.EquivalentTo(new InputDevice[] { gamepad1, gamepad2, mouse }));
-        Assert.That(InputDevice.all, Is.EquivalentTo(new InputDevice[] { gamepad1, gamepad2, mouse }));
     }
 
     [Test]
@@ -1841,6 +1838,29 @@ public void Devices_CanQueryAllGamepadsWithSimpleGetter()
         Assert.That(Gamepad.all, Has.None.SameAs(gamepad2));
     }
 
+    [Test]
+    [Category("Devices")]
+    public void Devices_CanQueryAllJoysticksWithSimpleGetter()
+    {
+        var joystick1 = InputSystem.AddDevice<Joystick>();
+        var joystick2 = InputSystem.AddDevice<Joystick>();
+        InputSystem.AddDevice<Keyboard>();
+
+        Assert.That(Joystick.all, Has.Count.EqualTo(2));
+        Assert.That(Joystick.all, Has.Exactly(1).SameAs(joystick1));
+        Assert.That(Joystick.all, Has.Exactly(1).SameAs(joystick2));
+
+        var joystick3 = InputSystem.AddDevice<Joystick>();
+
+        Assert.That(Joystick.all, Has.Count.EqualTo(3));
+        Assert.That(Joystick.all, Has.Exactly(1).SameAs(joystick3));
+
+        InputSystem.RemoveDevice(joystick2);
+
+        Assert.That(Joystick.all, Has.Count.EqualTo(2));
+        Assert.That(Joystick.all, Has.None.SameAs(joystick2));
+    }
+
     [Test]
     [Category("Devices")]
     public void Devices_CanGetButtonOnGamepadUsingEnum()
@@ -3265,6 +3285,7 @@ private struct TestDeviceCapabilities
         public string stringCap;
         public int intCap;
         public float floatCap;
+        public float floatCapWithExponent;
         public bool boolCap;
         public NestedCaps nestedCap;
         public string[] arrayCap;
@@ -3315,6 +3336,8 @@ public void Devices_CanMatchDeviceDescriptions_WithCapabilities()
             .WithCapability("intCap", "1234");
         var matchFloatCapWithString = new InputDeviceMatcher()
             .WithCapability("floatCap", "1.234");
+        var matchFloatWithExponentCapWithString = new InputDeviceMatcher()
+            .WithCapability("floatCapWithExponent", "1.234e-10");
         var matchBoolCapWithString = new InputDeviceMatcher()
             .WithCapability("boolCap", "true");
         var matchNone = new InputDeviceMatcher()
@@ -3328,6 +3351,7 @@ public void Devices_CanMatchDeviceDescriptions_WithCapabilities()
                 stringCap = "string",
                 intCap = 1234,
                 floatCap = 1.234f,
+                floatCapWithExponent = 1.234e-10f,
                 boolCap = true,
                 nestedCap = new TestDeviceCapabilities.NestedCaps
                 {
@@ -3348,6 +3372,7 @@ public void Devices_CanMatchDeviceDescriptions_WithCapabilities()
         Assert.That(matchIntCapWithRegex.MatchPercentage(description), Is.EqualTo(1 / 2.0).Within(0.0001));
         Assert.That(matchIntCapWithString.MatchPercentage(description), Is.EqualTo(1 / 2.0).Within(0.0001));
         Assert.That(matchFloatCapWithString.MatchPercentage(description), Is.EqualTo(1 / 2.0).Within(0.0001));
+        Assert.That(matchFloatWithExponentCapWithString.MatchPercentage(description), Is.EqualTo(1 / 2.0).Within(0.0001));
         Assert.That(matchBoolCapWithString.MatchPercentage(description), Is.EqualTo(1 / 2.0).Within(0.0001));
         Assert.That(matchNone.MatchPercentage(description), Is.EqualTo(0).Within(0.0001));
     }