public static BindingSyntax ChangeBinding(this InputAction action, int index) { if (action == null) { throw new ArgumentNullException(nameof(action)); } var indexOnMap = action.BindingIndexOnActionToBindingIndexOnMap(index); return(new BindingSyntax(action.GetOrCreateActionMap(), action, indexOnMap)); }
public static void ApplyBindingOverride(this InputAction action, int bindingIndex, InputBinding bindingOverride) { if (action == null) { throw new ArgumentNullException(nameof(action)); } var indexOnMap = action.BindingIndexOnActionToBindingIndexOnMap(bindingIndex); bindingOverride.action = action.name; ApplyBindingOverride(action.GetOrCreateActionMap(), indexOnMap, bindingOverride); }
/// <summary> /// /// </summary> /// <param name="action"></param> /// <param name="bindingOverride"></param> /// <remarks> /// Binding overrides are non-destructive. They do not change the bindings set up for an action /// but rather apply non-destructive modifications that change the paths of existing bindings. /// However, this also means that for overrides to work, there have to be existing bindings that /// can be modified. /// </remarks> public static void ApplyBindingOverride(this InputAction action, InputBinding bindingOverride) { if (action == null) { throw new ArgumentNullException(nameof(action)); } bindingOverride.action = action.name; var actionMap = action.GetOrCreateActionMap(); ApplyBindingOverride(actionMap, bindingOverride); }
/// <summary> /// Add a new binding to the action. /// </summary> /// <param name="action">An action to add the binding to.</param> /// <param name="binding">Binding to add to the action or default. Binding can be further configured via /// the struct returned by the method.</param> /// <returns> /// Returns a fluent-style syntax structure that allows performing additional modifications /// based on the new binding. /// </returns> /// <remarks> /// This works both with actions that are part of an action set as well as with actions that aren't. /// /// Note that actions must be disabled while altering their binding sets. Also, if the action belongs /// to a set, all actions in the set must be disabled. /// /// <example> /// <code> /// fireAction.AddBinding() /// .WithPath("<Gamepad>/buttonSouth") /// .WithGroup("Gamepad"); /// </code> /// </example> /// </remarks> public static BindingSyntax AddBinding(this InputAction action, InputBinding binding = default) { if (action == null) { throw new ArgumentNullException(nameof(action)); } ////REVIEW: should this reference actions by ID? Debug.Assert(action.m_Name != null || action.isSingletonAction); binding.action = action.name; var actionMap = action.GetOrCreateActionMap(); var bindingIndex = AddBindingInternal(actionMap, binding); return(new BindingSyntax(actionMap, action, bindingIndex)); }
public static BindingSyntax ChangeBinding(this InputAction action, InputBinding match) { if (action == null) { throw new ArgumentNullException(nameof(action)); } var actionMap = action.GetOrCreateActionMap(); var bindingIndex = actionMap.FindBinding(match); if (bindingIndex == -1) { throw new ArgumentException($"Cannot find binding matching '{match}' in '{action}'", nameof(match)); } return(new BindingSyntax(actionMap, action, bindingIndex)); }
////TODO: update binding mask if necessary /// <summary> /// Rename an existing action. /// </summary> /// <param name="action">Action to assign a new name to. Can be singleton action or action that /// is part of a map.</param> /// <param name="newName">New name to assign to action. Cannot be empty.</param> /// <exception cref="ArgumentNullException"><paramref name="action"/> is null or <paramref name="newName"/> is /// null or empty.</exception> /// <exception cref="InvalidOperationException"><see cref="InputAction.actionMap"/> of <paramref name="action"/> /// already contains an action called <paramref name="newName"/>.</exception> /// <remarks> /// Renaming an action will also update the bindings that refer to the action. /// </remarks> public static void Rename(this InputAction action, string newName) { if (action == null) { throw new ArgumentNullException(nameof(action)); } if (string.IsNullOrEmpty(newName)) { throw new ArgumentNullException(nameof(newName)); } if (action.name == newName) { return; } // Make sure name isn't already taken in map. var actionMap = action.actionMap; if (actionMap?.FindAction(newName) != null) { throw new InvalidOperationException( $"Cannot rename '{action}' to '{newName}' in map '{actionMap}' as the map already contains an action with that name"); } var oldName = action.m_Name; action.m_Name = newName; // Update bindings. var bindings = action.GetOrCreateActionMap().m_Bindings; var bindingCount = bindings.LengthSafe(); for (var i = 0; i < bindingCount; ++i) { if (string.Compare(bindings[i].action, oldName, StringComparison.InvariantCultureIgnoreCase) == 0) { bindings[i].action = newName; } } }
public static CompositeSyntax AddCompositeBinding(this InputAction action, string composite, string interactions = null) { if (action == null) { throw new ArgumentNullException(nameof(action)); } if (string.IsNullOrEmpty(composite)) { throw new ArgumentException("Composite name cannot be null or empty", nameof(composite)); } var actionMap = action.GetOrCreateActionMap(); ////REVIEW: use 'name' instead of 'path' field here? var binding = new InputBinding { path = composite, interactions = interactions, isComposite = true, action = action.name }; var bindingIndex = AddBindingInternal(actionMap, binding); return(new CompositeSyntax(actionMap, action, bindingIndex)); }
/// <summary> /// Add a new binding to the action. /// </summary> /// <param name="action">A disabled action to add the binding to.</param> /// <param name="binding"></param> /// <returns> /// Returns a fluent-style syntax structure that allows performing additional modifications /// based on the new binding. /// </returns> /// <remarks> /// This works both with actions that are part of an action set as well as with actions that aren't. /// /// Note that actions must be disabled while altering their binding sets. Also, if the action belongs /// to a set, all actions in the set must be disabled. /// </remarks> public static BindingSyntax AddBinding(this InputAction action, InputBinding binding) { if (action == null) { throw new ArgumentNullException(nameof(action)); } if (binding.path == null) { throw new ArgumentException("Binding path cannot be null", nameof(binding)); } action.ThrowIfModifyingBindingsIsNotAllowed(); ////REVIEW: should this reference actions by ID? Debug.Assert(action.m_Name != null || action.isSingletonAction); binding.action = action.name; var actionMap = action.GetOrCreateActionMap(); actionMap.ThrowIfModifyingBindingsIsNotAllowed(); var bindingIndex = AddBindingInternal(actionMap, binding); return(new BindingSyntax(actionMap, action, bindingIndex)); }