// Apply the given override to the action. // // NOTE: Ignores the action name in the override. // NOTE: Action must be disabled while applying overrides. // NOTE: If there's already an override on the respective binding, replaces the override. /// <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("action"); } bindingOverride.action = action.name; var actionMap = action.GetOrCreateActionMap(); ApplyBindingOverride(actionMap, bindingOverride); }
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); }
public static BindingSyntax ChangeBinding(this InputAction action, InputBinding match) { if (action == null) { throw new ArgumentNullException(nameof(action)); } var actionMap = action.GetOrCreateActionMap(); actionMap.ThrowIfModifyingBindingsIsNotAllowed(); 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)); }
public static CompositeSyntax AddCompositeBinding(this InputAction action, string composite, string interactions = null) { if (action == null) { throw new ArgumentNullException("action"); } if (string.IsNullOrEmpty(composite)) { throw new ArgumentException("Composite name cannot be null or empty", "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("action"); } if (string.IsNullOrEmpty(binding.path)) { throw new ArgumentException("Binding path cannot be null or empty", "binding"); } action.ThrowIfModifyingBindingsIsNotAllowed(); Debug.Assert(action.m_Name != null || action.isSingletonAction); binding.action = action.m_Name; var actionMap = action.GetOrCreateActionMap(); var bindingIndex = AddBindingInternal(actionMap, binding); return(new BindingSyntax(actionMap, action, bindingIndex)); }
public static void ApplyBindingOverride(this InputAction action, int bindingIndex, InputBinding bindingOverride) { if (action == null) { throw new ArgumentNullException("action"); } // We don't want to hit InputAction.bindings here as this requires setting up per-action // binding info which we then nuke as part of the override process. Calling ApplyBindingOverride // repeatedly with an index would thus cause the same data to be computed and thrown away // over and over. // Instead we manually search through the map's bindings to find the right binding index // in the map. var actionMap = action.GetOrCreateActionMap(); var bindingsInMap = actionMap.m_Bindings; var bindingCountInMap = bindingsInMap != null ? bindingsInMap.Length : 0; var actionName = action.name; var currentBindingIndexOnAction = -1; for (var i = 0; i < bindingCountInMap; ++i) { if (string.Compare(bindingsInMap[i].action, actionName, StringComparison.InvariantCultureIgnoreCase) != 0) { continue; } ++currentBindingIndexOnAction; if (currentBindingIndexOnAction == bindingIndex) { bindingOverride.action = actionName; ApplyBindingOverride(actionMap, i, bindingOverride); return; } } throw new ArgumentOutOfRangeException( string.Format("Binding index {0} is out of range for action '{1}' with {2} bindings", bindingIndex, action, currentBindingIndexOnAction), "bindingIndex"); }