FIX: Pasting binding with invalid control schemes (case 1276106, #1445).

Author: Rene Damm

Assets/Tests/InputSystem/CoreTests_Editor.cs

@@ -1259,6 +1259,87 @@ public void Editor_ActionTree_CanCopyPasteBinding_IntoDifferentAction()
         }
     }
 
+    [Test]
+    [Category("Editor")]
+    public void Editor_ActionTree_CanCopyPasteBinding_IntoDifferentAsset()
+    {
+        var asset1 = ScriptableObject.CreateInstance<InputActionAsset>();
+        asset1.AddControlScheme("Gamepad").WithRequiredDevice<Gamepad>();
+        asset1.AddControlScheme("Keyboard").WithRequiredDevice<Keyboard>();
+
+        var map1 = asset1.AddActionMap("map");
+        var action1 = map1.AddAction("actionOnlyInFirstAsset");
+        var action2 = map1.AddAction("actionInBothAssets");
+        action1.AddBinding("<Gamepad>/leftStick", groups: "Gamepad");
+        action1.AddBinding("<Keyboard>/a", groups: "Keyboard");
+        action2.AddBinding("*/{Back}", groups: "Gamepad;Keyboard");
+
+        var asset2 = ScriptableObject.CreateInstance<InputActionAsset>();
+        asset2.AddControlScheme("Gamepad").WithRequiredDevice<Gamepad>();
+        asset2.AddControlScheme("Mouse").WithRequiredDevice<Mouse>();
+
+        var map2 = asset2.AddActionMap("map");
+        map2.AddAction("actionOnlyInSecondAsset");
+        map2.AddAction("actionInBothAssets");
+
+        var serializedObject1 = new SerializedObject(asset1);
+        var tree1 = new InputActionTreeView(serializedObject1)
+        {
+            onBuildTree = () => InputActionTreeView.BuildFullTree(serializedObject1),
+        };
+        tree1.Reload();
+
+        var serializedObject2 = new SerializedObject(asset2);
+        var tree2 = new InputActionTreeView(serializedObject2)
+        {
+            onBuildTree = () => InputActionTreeView.BuildFullTree(serializedObject2),
+            onBindingAdded = prop => InputActionSerializationHelpers.RemoveUnusedBindingGroups(prop, asset2.controlSchemes)
+        };
+        tree2.Reload();
+
+        using (new EditorHelpers.FakeSystemCopyBuffer())
+        {
+            // Copy <Gamepad>/leftStick binging from first asset.
+            tree1.SelectItem(tree1.FindItemByPropertyPath("m_ActionMaps.Array.data[0].m_Bindings.Array.data[0]"));
+            tree1.CopySelectedItemsToClipboard();
+
+            // Paste it onto actionOnlyInSecondAsset.
+            tree2.SelectItem("map/actionOnlyInSecondAsset");
+            tree2.PasteDataFromClipboard();
+
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children, Has.Count.EqualTo(1));
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children[0].As<BindingTreeItem>().path, Is.EqualTo("<Gamepad>/leftStick"));
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children[0].As<BindingTreeItem>().groups, Is.EqualTo("Gamepad"));
+
+            // Copy <Keyboard>/a binging from first asset.
+            tree1.SelectItem(tree1.FindItemByPropertyPath("m_ActionMaps.Array.data[0].m_Bindings.Array.data[1]"));
+            tree1.CopySelectedItemsToClipboard();
+
+            // Paste it onto actionOnlyInSecondAsset in second asset.
+            tree2.SelectItem("map/actionOnlyInSecondAsset");
+            tree2.PasteDataFromClipboard();
+
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children, Has.Count.EqualTo(2));
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children[0].As<BindingTreeItem>().path, Is.EqualTo("<Gamepad>/leftStick"));
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children[0].As<BindingTreeItem>().groups, Is.EqualTo("Gamepad"));
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children[1].As<BindingTreeItem>().path, Is.EqualTo("<Keyboard>/a"));
+            Assert.That(tree2["map/actionOnlyInSecondAsset"].children[1].As<BindingTreeItem>().groups, Is.EqualTo(""));
+
+            // Copy */{Back} binging from first asset.
+            tree1.SelectItem(tree1.FindItemByPropertyPath("m_ActionMaps.Array.data[0].m_Bindings.Array.data[2]"));
+            tree1.CopySelectedItemsToClipboard();
+
+            // Paste it onto actionInBothAssets in second asset.
+            // NOTE: Apparently, we don't currently support just pasting it straight onto the map.
+            tree2.SelectItem("map/actionInBothAssets");
+            tree2.PasteDataFromClipboard();
+
+            Assert.That(tree2["map/actionInBothAssets"].children, Has.Count.EqualTo(1));
+            Assert.That(tree2["map/actionInBothAssets"].children[0].As<BindingTreeItem>().path, Is.EqualTo("*/{Back}"));
+            Assert.That(tree2["map/actionInBothAssets"].children[0].As<BindingTreeItem>().groups, Is.EqualTo("Gamepad"));
+        }
+    }
+
     [Test]
     [Category("Editor")]
     public void Editor_ActionTree_CannotCopyPasteBinding_IntoActionMap()

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -42,6 +42,9 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed `InputAction.IsPressed`/`WasPressed`/`WasReleased` returning incorrect results when binding multiple buttons on the same action and pressing/releasing them simultaneously.
 - Fixed interactions involving timeouts (such as `HoldInteraction`) performing erroneous delayed triggers on actions when input is composed of multiple controls ([1251231](https://issuetracker.unity3d.com/issues/input-system-composites-hold-interaction-can-be-performed-when-no-keys-are-hold)).
   * For example, if you bind `Shift+B` using a `OneModifierComposite` and put a `HoldInteraction` on the binding, then depending on the order in which the keys are pressed, you would sometimes see the action spuriously getting triggered when in fact no input was received.
+- Fixed control schemes of bindings not getting updates when being pasted from one `.inputactions` asset into another ([case 1276106](https://issuetracker.unity3d.com/issues/input-system-control-schemes-are-not-resolved-when-copying-bindings-between-inputactionassets)).
+  * For example, if you copied a binding from an asset that had a "Gamepad" control scheme into an asset that had none, the resulting binding would be unusable.
+  * All associations with control schemes that do not exist in the target asset are now removed from bindings upon pasting.
 
 ## [1.2.0] - 2021-10-22
 

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

@@ -435,7 +435,7 @@ public static InputBinding MaskByGroups(params string[] groups)
         [SerializeField] private string m_Path;
         [SerializeField] private string m_Interactions;
         [SerializeField] private string m_Processors;
-        [SerializeField] private string m_Groups;
+        [SerializeField] internal string m_Groups;
         [SerializeField] private string m_Action;
         [SerializeField] internal Flags m_Flags;
 

Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/InputActionEditorWindow.cs

@@ -377,6 +377,7 @@ private void InitializeTrees()
             {
                 onSelectionChanged = OnActionTreeSelectionChanged,
                 onSerializedObjectModified = ApplyAndReloadTrees,
+                onBindingAdded = p => InputActionSerializationHelpers.RemoveUnusedBindingGroups(p, m_Toolbar.controlSchemes),
                 drawMinusButton = false,
                 title = ("Actions", "A list of InputActions in the InputActionMap selected in the left pane. Also, for each InputAction, the list "
                     + "of bindings that determine the controls that can trigger the action.\n\nThe name of each action must be unique within its InputActionMap."),

Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/InputActionTreeView.cs

@@ -888,8 +888,12 @@ private SerializedProperty PasteBlock(string tag, string data, SerializedPropert
                 // If we have a binding group to set for new bindings, overwrite the binding's
                 // group with it.
                 if (!string.IsNullOrEmpty(bindingGroupForNewBindings))
+                {
                     InputActionSerializationHelpers.ChangeBinding(property,
                         groups: bindingGroupForNewBindings);
+                }
+
+                onBindingAdded?.Invoke(property);
             }
 
             return property;
@@ -1108,6 +1112,7 @@ public void AddNewBinding(SerializedProperty actionProperty, SerializedProperty
         {
             var bindingProperty = InputActionSerializationHelpers.AddBinding(actionProperty, actionMapProperty,
                 groups: bindingGroupForNewBindings);
+            onBindingAdded?.Invoke(bindingProperty);
             OnNewItemAdded(bindingProperty);
         }
 
@@ -1125,6 +1130,7 @@ public void AddNewComposite(SerializedProperty actionProperty, SerializedPropert
                     nameof(compositeName));
             var compositeProperty = InputActionSerializationHelpers.AddCompositeBinding(actionProperty,
                 actionMapProperty, compositeName, compositeType, groups: bindingGroupForNewBindings);
+            onBindingAdded?.Invoke(compositeProperty);
             OnNewItemAdded(compositeProperty);
         }
 
@@ -1410,6 +1416,7 @@ private bool ReloadIfSerializedObjectHasBeenChanged()
         public Action<ActionTreeItemBase> onDoubleClick { get; set; }
         public Action<ActionTreeItemBase> onBeginRename { get; set; }
         public Func<TreeViewItem> onBuildTree { get; set; }
+        public Action<SerializedProperty> onBindingAdded { get; set; }
 
         public bool drawHeader { get; set; }
         public bool drawPlusButton { get; set; }

Packages/com.unity.inputsystem/InputSystem/Editor/Internal/InputActionSerializationHelpers.cs

@@ -624,6 +624,15 @@ public static void ReplaceBindingGroup(SerializedObject asset, string oldBinding
                 }
             }
         }
+
+        public static void RemoveUnusedBindingGroups(SerializedProperty binding, ReadOnlyArray<InputControlScheme> controlSchemes)
+        {
+            var groupsProperty = binding.FindPropertyRelative(nameof(InputBinding.m_Groups));
+            groupsProperty.stringValue = string.Join(InputBinding.kSeparatorString,
+                groupsProperty.stringValue
+                    .Split(InputBinding.Separator)
+                    .Where(g => controlSchemes.Any(c => c.bindingGroup.Equals(g, StringComparison.InvariantCultureIgnoreCase))));
+        }
     }
 }
 #endif // UNITY_EDITOR