public InputActionMap[] ToMaps()
{
var mapList = new List <InputActionMap>();
var actionLists = new List <List <InputAction> >();
var bindingLists = new List <List <InputBinding> >();
// Process actions listed at toplevel.
var actionCount = actions != null ? actions.Length : 0;
for (var i = 0; i < actionCount; ++i)
{
var jsonAction = actions[i];
if (string.IsNullOrEmpty(jsonAction.name))
{
throw new Exception(string.Format("Action number {0} has no name", i + 1));
}
////REVIEW: make sure all action names are unique?
// Determine name of action map.
string mapName = null;
var actionName = jsonAction.name;
var indexOfFirstSlash = actionName.IndexOf('/');
if (indexOfFirstSlash != -1)
{
mapName = actionName.Substring(0, indexOfFirstSlash);
actionName = actionName.Substring(indexOfFirstSlash + 1);
if (string.IsNullOrEmpty(actionName))
{
throw new Exception(string.Format(
"Invalid action name '{0}' (missing action name after '/')", jsonAction.name));
}
}
// Try to find existing map.
InputActionMap map = null;
var mapIndex = 0;
for (; mapIndex < mapList.Count; ++mapIndex)
{
if (string.Compare(mapList[mapIndex].name, mapName, StringComparison.InvariantCultureIgnoreCase) == 0)
{
map = mapList[mapIndex];
break;
}
}
// Create new map if it's the first action in the map.
if (map == null)
{
// NOTE: No map IDs supported on this path.
map = new InputActionMap(mapName);
mapIndex = mapList.Count;
mapList.Add(map);
actionLists.Add(new List <InputAction>());
bindingLists.Add(new List <InputBinding>());
}
// Create action.
var action = new InputAction(actionName);
action.m_Id = string.IsNullOrEmpty(jsonAction.id) ? null : jsonAction.id;
action.m_ExpectedControlLayout = !string.IsNullOrEmpty(jsonAction.expectedControlLayout)
? jsonAction.expectedControlLayout
: null;
actionLists[mapIndex].Add(action);
// Add bindings.
if (jsonAction.bindings != null)
{
var bindingsForMap = bindingLists[mapIndex];
for (var n = 0; n < jsonAction.bindings.Length; ++n)
{
var jsonBinding = jsonAction.bindings[n];
var binding = jsonBinding.ToBinding();
binding.action = action.m_Name;
bindingsForMap.Add(binding);
}
}
}
// Process maps.
var mapCount = maps != null ? maps.Length : 0;
for (var i = 0; i < mapCount; ++i)
{
var jsonMap = maps[i];
var mapName = jsonMap.name;
if (string.IsNullOrEmpty(mapName))
{
throw new Exception(string.Format("Map number {0} has no name", i + 1));
}
// Try to find existing map.
InputActionMap map = null;
var mapIndex = 0;
for (; mapIndex < mapList.Count; ++mapIndex)
{
if (string.Compare(mapList[mapIndex].name, mapName, StringComparison.InvariantCultureIgnoreCase) == 0)
{
map = mapList[mapIndex];
break;
}
}
// Create new map if we haven't seen it before.
if (map == null)
{
map = new InputActionMap(mapName);
map.m_Id = string.IsNullOrEmpty(jsonMap.id) ? null : jsonMap.id;
mapIndex = mapList.Count;
mapList.Add(map);
actionLists.Add(new List <InputAction>());
bindingLists.Add(new List <InputBinding>());
}
// Process actions in map.
var actionCountInMap = jsonMap.actions != null ? jsonMap.actions.Length : 0;
for (var n = 0; n < actionCountInMap; ++n)
{
var jsonAction = jsonMap.actions[n];
if (string.IsNullOrEmpty(jsonAction.name))
{
throw new Exception(string.Format("Action number {0} in map '{1}' has no name", i + 1, mapName));
}
// Create action.
var action = new InputAction(jsonAction.name);
action.m_Id = string.IsNullOrEmpty(jsonAction.id) ? null : jsonAction.id;
action.m_ExpectedControlLayout = !string.IsNullOrEmpty(jsonAction.expectedControlLayout)
? jsonAction.expectedControlLayout
: null;
actionLists[mapIndex].Add(action);
// Add bindings.
if (jsonAction.bindings != null)
{
var bindingList = bindingLists[mapIndex];
for (var k = 0; k < jsonAction.bindings.Length; ++k)
{
var jsonBinding = jsonAction.bindings[k];
var binding = jsonBinding.ToBinding();
binding.action = action.m_Name;
bindingList.Add(binding);
}
}
}
// Process bindings in map.
var bindingCountInMap = jsonMap.bindings != null ? jsonMap.bindings.Length : 0;
var bindingsForMap = bindingLists[mapIndex];
for (var n = 0; n < bindingCountInMap; ++n)
{
var jsonBinding = jsonMap.bindings[n];
var binding = jsonBinding.ToBinding();
bindingsForMap.Add(binding);
}
}
// Finalize arrays.
for (var i = 0; i < mapList.Count; ++i)
{
var map = mapList[i];
var actionArray = actionLists[i].ToArray();
var bindingArray = bindingLists[i].ToArray();
map.m_Actions = actionArray;
map.m_Bindings = bindingArray;
for (var n = 0; n < actionArray.Length; ++n)
{
var action = actionArray[n];
action.m_ActionMap = map;
}
}
return(mapList.ToArray());
}
// Add all overrides that have been applied to this action to the given list.
// Returns the number of overrides found.
public static int GetBindingOverrides(this InputAction action, List <InputBinding> overrides)
{
throw new NotImplementedException();
}
public RebindingOperation WithCancelAction(InputAction action)
{
return(this);
}
/// <summary>
/// Resolve and add all bindings and actions from the given map.
/// </summary>
/// <param name="map"></param>
/// <remarks>
/// This is where all binding resolution happens for actions. The method walks through the binding array
/// in <paramref name="map"/> and adds any controls, interactions, processors, and composites as it goes.
/// </remarks>
public unsafe void AddActionMap(InputActionMap map)
{
Debug.Assert(map != null);
var actionsInThisMap = map.m_Actions;
var bindingsInThisMap = map.m_Bindings;
var bindingCountInThisMap = bindingsInThisMap?.Length ?? 0;
var actionCountInThisMap = actionsInThisMap?.Length ?? 0;
var mapIndex = totalMapCount;
// Keep track of indices for this map.
var actionStartIndex = totalActionCount;
var bindingStartIndex = totalBindingCount;
var controlStartIndex = totalControlCount;
var interactionStartIndex = totalInteractionCount;
var processorStartIndex = totalProcessorCount;
var compositeStartIndex = totalCompositeCount;
// Allocate an initial block of memory. We probably will have to re-allocate once
// at the end to accommodate interactions and controls added from the map.
var newMemory = new InputActionState.UnmanagedMemory();
newMemory.Allocate(
mapCount: totalMapCount + 1,
actionCount: totalActionCount + actionCountInThisMap,
bindingCount: totalBindingCount + bindingCountInThisMap,
// We reallocate for the following once we know the final count.
interactionCount: totalInteractionCount,
compositeCount: totalCompositeCount,
controlCount: totalControlCount);
if (memory.isAllocated)
{
newMemory.CopyDataFrom(memory);
}
////TODO: make sure composite objects get all the bindings they need
////TODO: handle case where we have bindings resolving to the same control
//// (not so clear cut what to do there; each binding may have a different interaction setup, for example)
var currentCompositeBindingIndex = InputActionState.kInvalidIndex;
var currentCompositeIndex = InputActionState.kInvalidIndex;
var currentCompositePartIndex = 0;
var currentCompositeActionIndexInMap = InputActionState.kInvalidIndex;
InputAction currentCompositeAction = null;
var bindingMaskOnThisMap = map.m_BindingMask;
var devicesForThisMap = map.devices;
// Can't use `using` as we need to use it with `ref`.
var resolvedControls = new InputControlList <InputControl>(Allocator.Temp);
// We gather all controls in temporary memory and then move them over into newMemory once
// we're done resolving.
try
{
var bindingStatesPtr = newMemory.bindingStates;
for (var n = 0; n < bindingCountInThisMap; ++n)
{
ref var unresolvedBinding = ref bindingsInThisMap[n];
var bindingIndex = bindingStartIndex + n;
var isComposite = unresolvedBinding.isComposite;
var isPartOfComposite = !isComposite && unresolvedBinding.isPartOfComposite;
var bindingState = &bindingStatesPtr[bindingIndex];
try
{
////TODO: if it's a composite, check if any of the children matches our binding masks (if any) and skip composite if none do
// Set binding state to defaults.
bindingState->mapIndex = totalMapCount;
bindingState->compositeOrCompositeBindingIndex = InputActionState.kInvalidIndex;
bindingState->actionIndex = InputActionState.kInvalidIndex;
// Skip binding if it is disabled (path is empty string).
var path = unresolvedBinding.effectivePath;
if (unresolvedBinding.path == "")
{
continue;
}
// Skip binding if it doesn't match with our binding mask (might be empty).
if (!isComposite && bindingMask != null && !bindingMask.Value.Matches(ref unresolvedBinding))
{
continue;
}
// Skip binding if it doesn't match the binding mask on the map (might be empty).
if (!isComposite && bindingMaskOnThisMap != null &&
!bindingMaskOnThisMap.Value.Matches(ref unresolvedBinding))
{
continue;
}
// Try to find action.
//
// NOTE: We ignore actions on bindings that are part of composites. We only allow
// actions to be triggered from the composite itself.
var actionIndexInMap = InputActionState.kInvalidIndex;
var actionName = unresolvedBinding.action;
InputAction action = null;
if (!isPartOfComposite)
{
if (!string.IsNullOrEmpty(actionName))
{
////REVIEW: should we fail here if we don't manage to find the action
actionIndexInMap = map.TryGetActionIndex(actionName);
}
else if (map.m_SingletonAction != null)
{
// Special-case for singleton actions that don't have names.
actionIndexInMap = 0;
}
if (actionIndexInMap != InputActionState.kInvalidIndex)
{
action = actionsInThisMap[actionIndexInMap];
}
}
else
{
actionIndexInMap = currentCompositeActionIndexInMap;
action = currentCompositeAction;
}
// Skip binding if it doesn't match the binding mask on the action (might be empty).
if (!isComposite && action?.m_BindingMask != null &&
!action.m_BindingMask.Value.Matches(ref unresolvedBinding))
{
continue;
}
// Instantiate processors.
var firstProcessorIndex = InputActionState.kInvalidIndex;
var numProcessors = 0;
var processorString = unresolvedBinding.effectiveProcessors;
if (!string.IsNullOrEmpty(processorString))
{
// Add processors from binding.
firstProcessorIndex = ResolveProcessors(processorString);
if (firstProcessorIndex != InputActionState.kInvalidIndex)
{
numProcessors = totalProcessorCount - firstProcessorIndex;
}
}
if (action != null && !string.IsNullOrEmpty(action.m_Processors))
{
// Add processors from action.
var index = ResolveProcessors(action.m_Processors);
if (index != InputActionState.kInvalidIndex)
{
if (firstProcessorIndex == InputActionState.kInvalidIndex)
{
firstProcessorIndex = index;
}
numProcessors += totalProcessorCount - index;
}
}
// Instantiate interactions.
var firstInteractionIndex = InputActionState.kInvalidIndex;
var numInteractions = 0;
var interactionString = unresolvedBinding.effectiveInteractions;
if (!string.IsNullOrEmpty(interactionString))
{
// Add interactions from binding.
firstInteractionIndex = ResolveInteractions(interactionString);
if (firstInteractionIndex != InputActionState.kInvalidIndex)
{
numInteractions = totalInteractionCount - firstInteractionIndex;
}
}
if (action != null && !string.IsNullOrEmpty(action.m_Interactions))
{
// Add interactions from action.
var index = ResolveInteractions(action.m_Interactions);
if (index != InputActionState.kInvalidIndex)
{
if (firstInteractionIndex == InputActionState.kInvalidIndex)
{
firstInteractionIndex = index;
}
numInteractions += totalInteractionCount - index;
}
}
// If it's the start of a composite chain, create the composite.
if (isComposite)
{
var actionIndexForComposite = actionIndexInMap != InputActionState.kInvalidIndex
? actionStartIndex + actionIndexInMap
: InputActionState.kInvalidIndex;
// Instantiate. For composites, the path is the name of the composite.
var composite = InstantiateBindingComposite(unresolvedBinding.path);
currentCompositeIndex =
ArrayHelpers.AppendWithCapacity(ref composites, ref totalCompositeCount, composite);
currentCompositeBindingIndex = bindingIndex;
currentCompositeAction = action;
currentCompositeActionIndexInMap = actionIndexInMap;
*bindingState = new InputActionState.BindingState
{
actionIndex = actionIndexForComposite,
compositeOrCompositeBindingIndex = currentCompositeIndex,
processorStartIndex = firstProcessorIndex,
processorCount = numProcessors,
interactionCount = numInteractions,
interactionStartIndex = firstInteractionIndex,
mapIndex = totalMapCount,
isComposite = true,
// Record where the controls for parts of the composite start.
controlStartIndex = memory.controlCount + resolvedControls.Count,
};
// The composite binding entry itself does not resolve to any controls.
// It creates a composite binding object which is then populated from
// subsequent bindings.
continue;
}
// If we've reached the end of a composite chain, finish
// off the current composite.
if (!isPartOfComposite && currentCompositeBindingIndex != InputActionState.kInvalidIndex)
{
currentCompositePartIndex = 0;
currentCompositeBindingIndex = InputActionState.kInvalidIndex;
currentCompositeIndex = InputActionState.kInvalidIndex;
currentCompositeAction = null;
currentCompositeActionIndexInMap = InputActionState.kInvalidIndex;
}
// Look up controls.
//
// NOTE: We continuously add controls here to `resolvedControls`. Once we've completed our
// pass over the bindings in the map, `resolvedControls` will have all the controls for
// the current map.
var firstControlIndex = memory.controlCount + resolvedControls.Count;
var numControls = 0;
if (devicesForThisMap != null)
{
// Search in devices for only this map.
var list = devicesForThisMap.Value;
for (var i = 0; i < list.Count; ++i)
{
var device = list[i];
if (!device.added)
{
continue; // Skip devices that have been removed.
}
numControls += InputControlPath.TryFindControls(device, path, 0, ref resolvedControls);
}
}
else
{
// Search globally.
numControls = InputSystem.FindControls(path, ref resolvedControls);
}
// If the binding is part of a composite, pass the resolved controls
// on to the composite.
var actionIndexForBinding = InputActionState.kInvalidIndex;
if (isPartOfComposite && currentCompositeBindingIndex != InputActionState.kInvalidIndex && numControls > 0)
{
// Make sure the binding is named. The name determines what in the composite
// to bind to.
if (string.IsNullOrEmpty(unresolvedBinding.name))
{
throw new Exception(
$"Binding with path '{path}' that is part of composite '{composites[currentCompositeIndex]}' is missing a name");
}
// Install the controls on the binding.
BindControlInComposite(composites[currentCompositeIndex], unresolvedBinding.name,
ref currentCompositePartIndex);
// Keep track of total number of controls bound in the composite.
bindingStatesPtr[currentCompositeBindingIndex].controlCount += numControls;
// Force action index on part binding to be same as that of composite.
actionIndexForBinding = bindingStatesPtr[currentCompositeBindingIndex].actionIndex;
}
else if (actionIndexInMap != InputActionState.kInvalidIndex)
{
actionIndexForBinding = actionStartIndex + actionIndexInMap;
}
// Add entry for resolved binding.
*bindingState = new InputActionState.BindingState
{
controlStartIndex = firstControlIndex,
controlCount = numControls,
interactionStartIndex = firstInteractionIndex,
interactionCount = numInteractions,
processorStartIndex = firstProcessorIndex,
processorCount = numProcessors,
isPartOfComposite = unresolvedBinding.isPartOfComposite,
partIndex = currentCompositePartIndex,
actionIndex = actionIndexForBinding,
compositeOrCompositeBindingIndex = currentCompositeBindingIndex,
mapIndex = totalMapCount,
};
}
catch (Exception exception)
{
Debug.LogError(
$"{exception.GetType().Name} while resolving binding '{unresolvedBinding}' in action map '{map}'");
Debug.LogException(exception);
// Don't swallow exceptions that indicate something is wrong in the code rather than
// in the data.
if (exception.IsExceptionIndicatingBugInCode())
{
throw exception;
}
}
}
// Re-allocate memory to accommodate controls and interaction states. The count for those
// we only know once we've completed all resolution.
var controlCountInThisMap = resolvedControls.Count;
var newTotalControlCount = memory.controlCount + controlCountInThisMap;
if (newMemory.interactionCount != totalInteractionCount ||
newMemory.compositeCount != totalCompositeCount ||
newMemory.controlCount != newTotalControlCount)
{
var finalMemory = new InputActionState.UnmanagedMemory();
finalMemory.Allocate(
mapCount: newMemory.mapCount,
actionCount: newMemory.actionCount,
bindingCount: newMemory.bindingCount,
controlCount: newTotalControlCount,
interactionCount: totalInteractionCount,
compositeCount: totalCompositeCount);
finalMemory.CopyDataFrom(newMemory);
newMemory.Dispose();
newMemory = finalMemory;
}
// Add controls to array.
var controlCountInArray = memory.controlCount;
ArrayHelpers.AppendListWithCapacity(ref controls, ref controlCountInArray, resolvedControls);
Debug.Assert(controlCountInArray == newTotalControlCount,
"Control array should have combined count of old and new controls");
// Set up control to binding index mapping.
for (var i = 0; i < bindingCountInThisMap; ++i)
{
var bindingState = &bindingStatesPtr[bindingStartIndex + i];
var numControls = bindingState->controlCount;
var startIndex = bindingState->controlStartIndex;
for (var n = 0; n < numControls; ++n)
{
newMemory.controlIndexToBindingIndex[startIndex + n] = bindingStartIndex + i;
}
}
// Initialize initial interaction states.
for (var i = memory.interactionCount; i < newMemory.interactionCount; ++i)
{
newMemory.interactionStates[i].phase = InputActionPhase.Waiting;
}
// Initialize action data.
var runningIndexInBindingIndices = memory.bindingCount;
for (var i = 0; i < actionCountInThisMap; ++i)
{
var action = actionsInThisMap[i];
var actionIndex = actionStartIndex + i;
// Correlate action with its trigger state.
action.m_ActionIndex = actionIndex;
// Collect bindings for action.
var bindingStartIndexForAction = runningIndexInBindingIndices;
var bindingCountForAction = 0;
var numPossibleConcurrentActuations = 0;
var haveCompositeBinding = false;
for (var n = 0; n < bindingCountInThisMap; ++n)
{
var bindingIndex = bindingStartIndex + n;
var bindingState = &newMemory.bindingStates[bindingIndex];
if (bindingState->actionIndex != actionIndex)
{
continue;
}
if (bindingState->isPartOfComposite)
{
continue;
}
Debug.Assert(bindingIndex <= ushort.MaxValue, "Binding index exceeds limit");
newMemory.actionBindingIndices[runningIndexInBindingIndices] = (ushort)bindingIndex;
++runningIndexInBindingIndices;
++bindingCountForAction;
// Keep track of how many concurrent actuations we may be seeing on the action so that
// we know whether we need to enable conflict resolution or not.
if (bindingState->isComposite)
{
// Composite binding. Actuates as a whole. Check if the composite has successfully
// resolved any controls. If so, it adds one possible actuation.
if (bindingState->controlCount > 0)
{
++numPossibleConcurrentActuations;
}
}
else
{
// Normal binding. Every successfully resolved control results in one possible actuation.
numPossibleConcurrentActuations += bindingState->controlCount;
}
}
Debug.Assert(bindingStartIndexForAction < ushort.MaxValue, "Binding start index on action exceeds limit");
Debug.Assert(bindingCountForAction < ushort.MaxValue, "Binding count on action exceeds limit");
newMemory.actionBindingIndicesAndCounts[i * 2] = (ushort)bindingStartIndexForAction;
newMemory.actionBindingIndicesAndCounts[i * 2 + 1] = (ushort)bindingCountForAction;
// See if we may need conflict resolution on this action. Never needed for pass-through actions.
// Otherwise, if we have more than one bound control or have several bindings and one of them
// is a composite, we enable it.
var isPassThroughAction = action.passThrough;
var mayNeedConflictResolution = !isPassThroughAction && numPossibleConcurrentActuations > 1;
// Initialize initial trigger state.
newMemory.actionStates[actionIndex] =
new InputActionState.TriggerState
{
phase = InputActionPhase.Disabled,
mapIndex = mapIndex,
controlIndex = InputActionState.kInvalidIndex,
interactionIndex = InputActionState.kInvalidIndex,
continuous = action.continuous,
passThrough = isPassThroughAction,
mayNeedConflictResolution = mayNeedConflictResolution,
};
}
// Store indices for map.
newMemory.mapIndices[mapIndex] =
new InputActionState.ActionMapIndices
{
actionStartIndex = actionStartIndex,
actionCount = actionCountInThisMap,
controlStartIndex = controlStartIndex,
controlCount = controlCountInThisMap,
bindingStartIndex = bindingStartIndex,
bindingCount = bindingCountInThisMap,
interactionStartIndex = interactionStartIndex,
interactionCount = totalInteractionCount - interactionStartIndex,
processorStartIndex = processorStartIndex,
processorCount = totalProcessorCount - processorStartIndex,
compositeStartIndex = compositeStartIndex,
compositeCount = totalCompositeCount - compositeStartIndex,
};
map.m_MapIndexInState = mapIndex;
var finalActionMapCount = memory.mapCount;
ArrayHelpers.AppendWithCapacity(ref maps, ref finalActionMapCount, map, capacityIncrement: 4);
Debug.Assert(finalActionMapCount == newMemory.mapCount,
"Final action map count should match old action map count plus one");
// As a final act, swap the new memory in.
memory.Dispose();
memory = newMemory;
}
public static IEnumerable <InputBinding> GetBindingOverrides(this InputAction action)
{
throw new NotImplementedException();
}
public bool Equals(InputAction other)
{
return(ReferenceEquals(action, other));
}
public void Trigger <TValue>(InputAction action, InputControl <TValue> control, TValue value)
where TValue : struct
{
throw new NotImplementedException();
}
internal CompositeSyntax(InputActionMap map, InputAction action, int compositeIndex)
{
m_Action = action;
m_ActionMap = map;
m_CompositeIndex = compositeIndex;
}
public InputActionProperty(InputAction action)
{
m_UseReference = false;
m_Action = action;
m_Reference = null;
}
public static BindingSyntax AddBinding(this InputActionMap actionMap, string path, InputAction action,
string interactions = null, string groups = null)
{
if (action != null && action.actionMap != actionMap)
{
throw new ArgumentException(
string.Format("Action '{0}' is not part of action map '{1}'", action, actionMap), "action");
}
if (action == null)
{
return(AddBinding(actionMap, path: path, interactions: interactions, groups: groups));
}
return(AddBinding(actionMap, path: path, interactions: interactions, groups: groups,
action: action.id));
}
internal BindingSyntax(InputActionMap map, InputAction action, int bindingIndex)
{
m_ActionMap = map;
m_Action = action;
m_BindingIndex = bindingIndex;
}
internal ReadOnlyArray <InputControl> GetControlsForSingleAction(InputAction action)
{
Debug.Assert(m_State != null);
Debug.Assert(m_MapIndex != InputActionMapState.kInvalidIndex);
Debug.Assert(m_Actions != null);
Debug.Assert(action != null);
Debug.Assert(action.m_ActionMap == this);
Debug.Assert(!action.isSingletonAction || m_SingletonAction == action);
// See if we need to refresh.
if (m_ControlsForEachAction == null)
{
if (m_State.totalControlCount == 0)
{
return(new ReadOnlyArray <InputControl>());
}
if (m_SingletonAction != null)
{
// For singleton action, all resolved controls in the state simply
// belong to the action.
m_ControlsForEachAction = m_State.controls;
action.m_ControlStartIndex = 0;
action.m_ControlCount = m_State.totalControlCount;
}
else
{
// For "normal" maps, we rely on the per-action binding data set up in SetUpBindingArrayForEachAction().
// From that, we set up a sorted array of controls.
var mapIndices = m_State.FetchMapIndices(this);
var controlCount = mapIndices.controlCount;
var bindingCount = mapIndices.bindingCount;
var bindingStartIndex = mapIndices.bindingStartIndex;
if (m_BindingsForEachAction == null)
{
SetUpBindingArrayForEachAction();
}
// Go binding by binding in the array that has bindings already sorted for
// each action. Gather their controls and store the result on the actions
// while copying the control references over to a new array.
m_ControlsForEachAction = new InputControl[controlCount];
var bindingStates = m_State.bindingStates;
var controls = m_State.controls;
var currentAction = m_ActionForEachBinding[0];
var currentActionControlStartIndex = 0;
var currentActionControlCount = 0;
var currentControlIndex = 0;
for (var i = 0; i < bindingCount; ++i)
{
var actionForBinding = m_ActionForEachBinding[i];
if (actionForBinding != currentAction)
{
if (currentAction != null)
{
// Store final array slice.
currentAction.m_ControlStartIndex = currentActionControlStartIndex;
currentAction.m_ControlCount = currentActionControlCount;
}
// Switch to new action.
currentAction = actionForBinding;
currentActionControlStartIndex = currentControlIndex;
currentActionControlCount = 0;
}
if (actionForBinding == null)
{
continue; // Binding is not associated with an action.
}
// Copy controls from binding.
var bindingIndex = bindingStartIndex + i;
var controlCountForBinding = bindingStates[bindingIndex].controlCount;
Array.Copy(controls, bindingStates[bindingIndex].controlStartIndex, m_ControlsForEachAction,
currentControlIndex, controlCountForBinding);
currentControlIndex += controlCountForBinding;
currentActionControlCount += controlCountForBinding;
}
if (currentAction != null)
{
currentAction.m_ControlStartIndex = currentActionControlStartIndex;
currentAction.m_ControlCount = currentActionControlCount;
}
}
}
return(new ReadOnlyArray <InputControl>(m_ControlsForEachAction, action.m_ControlStartIndex,
action.m_ControlCount));
}
public static RebindOperation PerformUserRebind(InputAction action, string cancel)
{
throw new NotImplementedException();
}
public void Start(InputAction actionToRebind, string groupsToRebind = null)
{
}
/// <summary>
/// Perform the input action without having to know what it is bound to.
/// </summary>
/// <param name="action">An input action that is currently enabled and has controls it is bound to.</param>
/// <remarks>
/// Blindly triggering an action requires making a few assumptions. Actions are not built to be able to trigger
/// without any input. This means that this method has to generate input on a control that the action is bound to.
///
/// Note that this method has no understanding of the interactions that may be present on the action and thus
/// does not know how they may affect the triggering of the action.
/// </remarks>
public void Trigger(InputAction action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
if (!action.enabled)
{
throw new ArgumentException(
string.Format("Action '{0}' must be enabled in order to be able to trigger it", action), "action");
}
var controls = action.controls;
if (controls.Count == 0)
{
throw new ArgumentException(
string.Format("Action '{0}' must be bound to controls in order to be able to trigger it", action), "action");
}
// See if we have a button we can trigger.
for (var i = 0; i < controls.Count; ++i)
{
var button = controls[i] as ButtonControl;
if (button == null)
{
continue;
}
// We do, so flip its state and we're done.
var device = button.device;
InputEventPtr inputEvent;
using (StateEvent.From(device, out inputEvent))
{
button.WriteValueInto(inputEvent, button.isPressed ? 0 : 1);
InputSystem.QueueEvent(inputEvent);
InputSystem.Update();
}
return;
}
// See if we have an axis we can slide a bit.
for (var i = 0; i < controls.Count; ++i)
{
var axis = controls[i] as AxisControl;
if (axis == null)
{
continue;
}
// We do, so nudge its value a bit.
var device = axis.device;
InputEventPtr inputEvent;
using (StateEvent.From(device, out inputEvent))
{
var currentValue = axis.ReadValue();
var newValue = currentValue + 0.01f;
if (axis.clamp && newValue > axis.clampMax)
{
newValue = axis.clampMin;
}
axis.WriteValueInto(inputEvent, newValue);
InputSystem.QueueEvent(inputEvent);
InputSystem.Update();
}
return;
}
////TODO: support a wider range of controls
throw new NotImplementedException();
}
public static void Enable(this InputAction action, InputControlScheme scheme)
{
throw new NotImplementedException();
}