MERGE: develop => stable.

Author: Rene Damm

Assets/Samples/EditorWindowDemo.meta

@@ -0,0 +1,4 @@
+{
+  "displayName": "EditorWindow Demo",
+  "description": "A simple example of how to use the input system from within EditorWindow code."
+} 

Assets/Samples/EditorWindowDemo/.sample.json

@@ -0,0 +1,45 @@
+using UnityEditor;
+using UnityEngine.InputSystem;
+
+public class EditorWindowDemo : EditorWindow
+{
+    [MenuItem("Window/Input System Editor Window Demo")]
+    public static void Open()
+    {
+        GetWindow<EditorWindowDemo>();
+    }
+
+    protected void OnGUI()
+    {
+        // Grab the current pointer device (mouse, pen, touchscreen).
+        var pointer = Pointer.current;
+        if (pointer == null)
+            return;
+
+        // Pointer positions should automatically be converted to EditorWindow space of
+        // the current window. Unlike player window coordinates, this uses UI window space,
+        // i.e. Y goes top down rather than bottom up.
+        var position = pointer.position.ReadValue();
+        var pressure = pointer.pressure.ReadValue();
+        var contact = pointer.press.isPressed;
+
+        EditorGUILayout.LabelField($"Device: {pointer}");
+        EditorGUILayout.LabelField($"Position: {position}");
+        EditorGUILayout.LabelField($"Pressure: {pressure}");
+        EditorGUILayout.LabelField($"Contact?: {contact}");
+
+        // Just for kicks, also read out some data from the currently used gamepad (if any).
+        var gamepad = Gamepad.current;
+        if (gamepad != null)
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField($"Gamepad Left Stick: {gamepad.leftStick.ReadValue()}");
+            EditorGUILayout.LabelField($"Gamepad Right Stick: {gamepad.leftStick.ReadValue()}");
+        }
+
+        // We want to constantly refresh to show the current values so trigger
+        // another refresh right away. Otherwise, the values we show will only
+        // update periodically.
+        Repaint();
+    }
+}

Assets/Samples/EditorWindowDemo/Editor.meta

@@ -0,0 +1,3 @@
+This is a simple example of how to use the input system in EditorWindow code.
+
+For more details see the [documentation](https://docs.unity3d.com/Packages/com.unity.inputsystem@latest/index.html?subfolder=/manual/UseInEditor.html).

Assets/Samples/EditorWindowDemo/Editor/EditorWindowDemo.cs

@@ -6,10 +6,10 @@
 using UnityEngine.InputSystem;
 using UnityEngine.InputSystem.Utilities;
 
-public class SimpleControls : IInputActionCollection, IDisposable
+public class @SimpleControls: IInputActionCollection, IDisposable
 {
     private InputActionAsset asset;
-    public SimpleControls()
+    public @SimpleControls()
     {
         asset = InputActionAsset.FromJson(@"{
     ""name"": ""SimpleControls"",
@@ -207,8 +207,8 @@ public void Disable()
     private readonly InputAction m_gameplay_look;
     public struct GameplayActions
     {
-        private SimpleControls m_Wrapper;
-        public GameplayActions(SimpleControls wrapper) { m_Wrapper = wrapper; }
+        private @SimpleControls m_Wrapper;
+        public GameplayActions(@SimpleControls wrapper) { m_Wrapper = wrapper; }
         public InputAction @fire => m_Wrapper.m_gameplay_fire;
         public InputAction @move => m_Wrapper.m_gameplay_move;
         public InputAction @look => m_Wrapper.m_gameplay_look;
@@ -221,28 +221,28 @@ public void SetCallbacks(IGameplayActions instance)
         {
             if (m_Wrapper.m_GameplayActionsCallbackInterface != null)
             {
-                fire.started -= m_Wrapper.m_GameplayActionsCallbackInterface.OnFire;
-                fire.performed -= m_Wrapper.m_GameplayActionsCallbackInterface.OnFire;
-                fire.canceled -= m_Wrapper.m_GameplayActionsCallbackInterface.OnFire;
-                move.started -= m_Wrapper.m_GameplayActionsCallbackInterface.OnMove;
-                move.performed -= m_Wrapper.m_GameplayActionsCallbackInterface.OnMove;
-                move.canceled -= m_Wrapper.m_GameplayActionsCallbackInterface.OnMove;
-                look.started -= m_Wrapper.m_GameplayActionsCallbackInterface.OnLook;
-                look.performed -= m_Wrapper.m_GameplayActionsCallbackInterface.OnLook;
-                look.canceled -= m_Wrapper.m_GameplayActionsCallbackInterface.OnLook;
+                @fire.started -= m_Wrapper.m_GameplayActionsCallbackInterface.OnFire;
+                @fire.performed -= m_Wrapper.m_GameplayActionsCallbackInterface.OnFire;
+                @fire.canceled -= m_Wrapper.m_GameplayActionsCallbackInterface.OnFire;
+                @move.started -= m_Wrapper.m_GameplayActionsCallbackInterface.OnMove;
+                @move.performed -= m_Wrapper.m_GameplayActionsCallbackInterface.OnMove;
+                @move.canceled -= m_Wrapper.m_GameplayActionsCallbackInterface.OnMove;
+                @look.started -= m_Wrapper.m_GameplayActionsCallbackInterface.OnLook;
+                @look.performed -= m_Wrapper.m_GameplayActionsCallbackInterface.OnLook;
+                @look.canceled -= m_Wrapper.m_GameplayActionsCallbackInterface.OnLook;
             }
             m_Wrapper.m_GameplayActionsCallbackInterface = instance;
             if (instance != null)
             {
-                fire.started += instance.OnFire;
-                fire.performed += instance.OnFire;
-                fire.canceled += instance.OnFire;
-                move.started += instance.OnMove;
-                move.performed += instance.OnMove;
-                move.canceled += instance.OnMove;
-                look.started += instance.OnLook;
-                look.performed += instance.OnLook;
-                look.canceled += instance.OnLook;
+                @fire.started += instance.OnFire;
+                @fire.performed += instance.OnFire;
+                @fire.canceled += instance.OnFire;
+                @move.started += instance.OnMove;
+                @move.performed += instance.OnMove;
+                @move.canceled += instance.OnMove;
+                @look.started += instance.OnLook;
+                @look.performed += instance.OnLook;
+                @look.canceled += instance.OnLook;
             }
         }
     }

Assets/Samples/EditorWindowDemo/Editor/EditorWindowDemo.cs.meta

@@ -3723,6 +3723,36 @@ public void Actions_CanLookUpActionInAssetByName()
         }, Is.Not.AllocatingGCMemory());
     }
 
+    [Test]
+    [Category("Actions")]
+    public void Actions_CanRemoveActionFromMap()
+    {
+        var asset = ScriptableObject.CreateInstance<InputActionAsset>();
+
+        var map = new InputActionMap("test");
+        asset.AddActionMap(map);
+
+        var action1 = map.AddAction("action1", binding: "<Gamepad>/buttonSouth");
+        var action2 = map.AddAction("action2", binding: "<Gamepad>/buttonNorth");
+        var action3 = map.AddAction("action3", binding: "<Gamepad>/buttonWest");
+
+        asset.RemoveAction("action2");
+
+        Assert.That(action2.actionMap, Is.Null);
+        Assert.That(asset.FindAction("action2"), Is.Null);
+        Assert.That(map.actions, Has.Count.EqualTo(2));
+        Assert.That(map.actions, Has.Exactly(1).SameAs(action1));
+        Assert.That(map.actions, Has.Exactly(1).SameAs(action3));
+        Assert.That(action1.bindings, Is.EquivalentTo(new[] {new InputBinding("<Gamepad>/buttonSouth", action: "action1")}));
+        Assert.That(action2.bindings, Is.EquivalentTo(new[] {new InputBinding("<Gamepad>/buttonNorth", action: "action2")}));
+        Assert.That(action3.bindings, Is.EquivalentTo(new[] {new InputBinding("<Gamepad>/buttonWest", action: "action3")}));
+        Assert.That(map.bindings, Is.EquivalentTo(new[]
+        {
+            new InputBinding("<Gamepad>/buttonSouth", action: "action1"),
+            new InputBinding("<Gamepad>/buttonWest", action: "action3")
+        }));
+    }
+
     [Test]
     [Category("Actions")]
     public void Actions_CanRemoveActionMapFromAsset()
@@ -4132,8 +4162,9 @@ public void Actions_CanMaskOutBindingsByBindingGroup_OnAction()
 
         action.bindingMask = new InputBinding {groups = "gamepad"};
 
-        Assert.That(action.controls, Has.Count.EqualTo(1));
+        Assert.That(action.controls, Has.Count.EqualTo(2));
         Assert.That(action.controls, Has.Exactly(1).SameAs(gamepad.buttonSouth));
+        Assert.That(action.controls, Has.Exactly(1).SameAs(mouse.leftButton));
         Assert.That(action.bindingMask, Is.EqualTo(new InputBinding {groups = "gamepad"}));
 
         action.bindingMask = null;
@@ -4206,8 +4237,9 @@ public void Actions_CanMaskOutBindingsByBindingGroup_OnActionMap()
         map.bindingMask = new InputBinding {groups = "gamepad"};
 
         Assert.That(action1.controls, Has.Count.EqualTo(1));
-        Assert.That(action2.controls, Has.Count.Zero);
         Assert.That(action1.controls, Has.Exactly(1).SameAs(gamepad.buttonSouth));
+        Assert.That(action2.controls, Has.Count.EqualTo(1));
+        Assert.That(action2.controls, Has.Exactly(1).SameAs(mouse.leftButton));
     }
 
     [Test]
@@ -4254,6 +4286,26 @@ public void Actions_CanMaskOutBindingsByBindingGroup_OnAsset()
         Assert.That(action2.controls, Has.Exactly(1).SameAs(keyboard.bKey));
     }
 
+    [Test]
+    [Category("Actions")]
+    public void Actions_WhenMaskingByGroup_BindingsNotInAnyGroupWillBeActive()
+    {
+        var gamepad = InputSystem.AddDevice<Gamepad>();
+        var mouse = InputSystem.AddDevice<Mouse>();
+        InputSystem.AddDevice<Keyboard>();
+
+        var action = new InputAction();
+        action.AddBinding("<Gamepad>/buttonSouth", groups: "Gamepad");
+        action.AddBinding("<Keyboard>/space", groups: "Keyboard&Mouse");
+        action.AddBinding("<Pointer>/press");
+
+        action.bindingMask = InputBinding.MaskByGroup("Gamepad");
+
+        Assert.That(action.controls, Has.Count.EqualTo(2));
+        Assert.That(action.controls, Has.Exactly(1).SameAs(gamepad.buttonSouth));
+        Assert.That(action.controls, Has.Exactly(1).SameAs(mouse.press));
+    }
+
     // When we have an .inputactions asset, at runtime we should end up with a single array of resolved
     // controls, single array of trigger states, and so on. The expectation is that users won't generally
     // go and configure each map in an asset in a wildly different way. Rather, the maps will usually perform
@@ -4387,6 +4439,54 @@ public void Actions_CanHaveParametersOnComposites()
             Is.EqualTo(CompositeWithParameters.EnumParameter.B));
     }
 
+    [Test]
+    [Category("Actions")]
+    [TestCase("", "<Gamepad>/buttonSouth", "<Gamepad>/buttonWest", "<Gamepad>/buttonEast")]
+    [TestCase("<Gamepad>/buttonNorth", "", "<Gamepad>/buttonWest", "<Gamepad>/buttonEast")]
+    [TestCase("<Gamepad>/buttonNorth", "<Gamepad>/buttonSouth", "", "<Gamepad>/buttonEast")]
+    [TestCase("<Gamepad>/buttonNorth", "<Gamepad>/buttonSouth", "<Gamepad>/buttonWest", "")]
+    public void Actions_CanHaveCompositesWithPartsThatAreNotBound(string up, string down, string left, string right)
+    {
+        var gamepad = InputSystem.AddDevice<Gamepad>();
+
+        var action = new InputAction();
+        action.AddCompositeBinding("2DVector")
+            .With("Up", up)
+            .With("Down", down)
+            .With("Left", left)
+            .With("Right", right);
+
+        action.Enable();
+
+        if (!string.IsNullOrEmpty(up))
+        {
+            Press(gamepad.buttonNorth);
+            Assert.That(action.ReadValue<Vector2>(), Is.EqualTo(Vector2.up).Using(Vector2EqualityComparer.Instance));
+            Release(gamepad.buttonNorth);
+        }
+
+        if (!string.IsNullOrEmpty(down))
+        {
+            Press(gamepad.buttonSouth);
+            Assert.That(action.ReadValue<Vector2>(), Is.EqualTo(Vector2.down).Using(Vector2EqualityComparer.Instance));
+            Release(gamepad.buttonSouth);
+        }
+
+        if (!string.IsNullOrEmpty(left))
+        {
+            Press(gamepad.buttonWest);
+            Assert.That(action.ReadValue<Vector2>(), Is.EqualTo(Vector2.left).Using(Vector2EqualityComparer.Instance));
+            Release(gamepad.buttonWest);
+        }
+
+        if (!string.IsNullOrEmpty(right))
+        {
+            Press(gamepad.buttonEast);
+            Assert.That(action.ReadValue<Vector2>(), Is.EqualTo(Vector2.right).Using(Vector2EqualityComparer.Instance));
+            Release(gamepad.buttonEast);
+        }
+    }
+
     [Test]
     [Category("Actions")]
     [Ignore("TODO")]
@@ -5497,9 +5597,9 @@ public void Actions_ApplyingNullOverride_IsSameAsRemovingOverride()
     public void Actions_ApplyingEmptyStringOverride_IsSameAsDisablingBinding()
     {
         var gamepad = InputSystem.AddDevice<Gamepad>();
-        var action = new InputAction(binding: "/gamepad/leftTrigger");
+        var action = new InputAction(binding: "<Gamepad>/leftTrigger");
 
-        bool performed = false;
+        var performed = false;
         action.performed += _ => performed = true;
 
         action.Enable();
@@ -5516,6 +5616,11 @@ public void Actions_ApplyingEmptyStringOverride_IsSameAsDisablingBinding()
         Press(gamepad.leftTrigger);
 
         Assert.That(performed, Is.False);
+
+        // We had a bug (case 1187163) where InputActionState would cause an exception by not
+        // respecting the empty path when checking if a newly added device is affecting the state.
+        // Just add a device here to make sure that's handled correctly.
+        Assert.That(() => InputSystem.AddDevice<Gamepad>(), Throws.Nothing);
     }
 
     [Test]