forked from BilalY/Rasagar
730 lines
35 KiB
C#
730 lines
35 KiB
C#
#if UNITY_EDITOR
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using UnityEditor;
|
|
using UnityEngine.InputSystem.Layouts;
|
|
using UnityEngine.InputSystem.Utilities;
|
|
|
|
////TODO: resolving bindings to actions needs to take "{id}" form into account
|
|
|
|
namespace UnityEngine.InputSystem.Editor
|
|
{
|
|
// Helpers for doctoring around in InputActions using SerializedProperties.
|
|
internal static class InputActionSerializationHelpers
|
|
{
|
|
public static string GetName(SerializedProperty element)
|
|
{
|
|
using (var nameProperty = element.FindPropertyRelative("m_Name"))
|
|
{
|
|
Debug.Assert(nameProperty != null, $"Cannot find m_Name property in {element.propertyPath}");
|
|
return nameProperty.stringValue;
|
|
}
|
|
}
|
|
|
|
public static Guid GetId(SerializedProperty element)
|
|
{
|
|
using (var idProperty = element.FindPropertyRelative("m_Id"))
|
|
{
|
|
Debug.Assert(idProperty != null, $"Cannot find m_Id property in {element.propertyPath}");
|
|
return new Guid(idProperty.stringValue);
|
|
}
|
|
}
|
|
|
|
public static int GetIndex(SerializedProperty arrayProperty, Guid id)
|
|
{
|
|
Debug.Assert(arrayProperty.isArray, $"Property {arrayProperty.propertyPath} is not an array");
|
|
for (var i = 0; i < arrayProperty.arraySize; ++i)
|
|
{
|
|
using (var element = arrayProperty.GetArrayElementAtIndex(i))
|
|
if (GetId(element) == id)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int GetIndex(SerializedProperty arrayProperty, SerializedProperty arrayElement)
|
|
{
|
|
return GetIndex(arrayProperty, GetId(arrayElement));
|
|
}
|
|
|
|
public static int GetIndex(SerializedProperty arrayElement)
|
|
{
|
|
var arrayProperty = arrayElement.GetArrayPropertyFromElement();
|
|
return GetIndex(arrayProperty, arrayElement);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starting with the given binding, find the composite that the binding belongs to. The given binding
|
|
/// must either be the composite or be part of a composite.
|
|
/// </summary>
|
|
public static int GetCompositeStartIndex(SerializedProperty bindingArrayProperty, int bindingIndex)
|
|
{
|
|
for (var i = bindingIndex; i >= 0; --i)
|
|
{
|
|
var bindingProperty = bindingArrayProperty.GetArrayElementAtIndex(i);
|
|
var bindingFlags = (InputBinding.Flags)bindingProperty.FindPropertyRelative("m_Flags").intValue;
|
|
if ((bindingFlags & InputBinding.Flags.Composite) != 0)
|
|
return i;
|
|
Debug.Assert((bindingFlags & InputBinding.Flags.PartOfComposite) != 0,
|
|
"Binding is neither a composite nor part of a composite");
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int GetCompositePartCount(SerializedProperty bindingArrayProperty, int bindingIndex)
|
|
{
|
|
var compositeStartIndex = GetCompositeStartIndex(bindingArrayProperty, bindingIndex);
|
|
if (compositeStartIndex == -1)
|
|
return 0;
|
|
|
|
var numParts = 0;
|
|
for (var i = compositeStartIndex + 1; i < bindingArrayProperty.arraySize; ++i, ++numParts)
|
|
{
|
|
var bindingProperty = bindingArrayProperty.GetArrayElementAtIndex(i);
|
|
var bindingFlags = (InputBinding.Flags)bindingProperty.FindPropertyRelative("m_Flags").intValue;
|
|
if ((bindingFlags & InputBinding.Flags.PartOfComposite) == 0)
|
|
break;
|
|
}
|
|
|
|
return numParts;
|
|
}
|
|
|
|
public static int ConvertBindingIndexOnActionToBindingIndexInArray(SerializedProperty bindingArrayProperty, string actionName,
|
|
int bindingIndexOnAction)
|
|
{
|
|
var bindingCount = bindingArrayProperty.arraySize;
|
|
var indexOnAction = -1;
|
|
var indexInArray = 0;
|
|
for (; indexInArray < bindingCount; ++indexInArray)
|
|
{
|
|
var bindingActionName = bindingArrayProperty.GetArrayElementAtIndex(indexInArray).FindPropertyRelative("m_Action")
|
|
.stringValue;
|
|
if (actionName.Equals(bindingActionName, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
++indexOnAction;
|
|
if (indexOnAction == bindingIndexOnAction)
|
|
return indexInArray;
|
|
}
|
|
}
|
|
return indexInArray;
|
|
}
|
|
|
|
#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
|
|
public static void AddActionMaps(SerializedObject asset, SerializedObject sourceAsset)
|
|
{
|
|
Debug.Assert(asset.targetObject is InputActionAsset);
|
|
Debug.Assert(sourceAsset.targetObject is InputActionAsset);
|
|
|
|
var mapArrayPropertySrc = sourceAsset.FindProperty(nameof(InputActionAsset.m_ActionMaps));
|
|
var mapArrayPropertyDst = asset.FindProperty(nameof(InputActionAsset.m_ActionMaps));
|
|
|
|
// Copy each action map from source and paste at the end of destination
|
|
var buffer = new StringBuilder();
|
|
for (var i = 0; i < mapArrayPropertySrc.arraySize; ++i)
|
|
{
|
|
buffer.Clear();
|
|
var mapProperty = mapArrayPropertySrc.GetArrayElementAtIndex(i);
|
|
CopyPasteHelper.CopyItems(new List<SerializedProperty> {mapProperty}, buffer, typeof(InputActionMap), mapProperty);
|
|
CopyPasteHelper.PasteItems(buffer.ToString(), new[] { mapArrayPropertyDst.arraySize - 1 }, mapArrayPropertyDst);
|
|
}
|
|
}
|
|
|
|
public static void AddControlSchemes(SerializedObject asset, SerializedObject sourceAsset)
|
|
{
|
|
Debug.Assert((asset.targetObject is InputActionAsset));
|
|
Debug.Assert((sourceAsset.targetObject is InputActionAsset));
|
|
|
|
var src = sourceAsset.FindProperty(nameof(InputActionAsset.m_ControlSchemes));
|
|
var dst = asset.FindProperty(nameof(InputActionAsset.m_ControlSchemes));
|
|
|
|
var buffer = new StringBuilder();
|
|
src.CopyToJson(buffer, ignoreObjectReferences: true);
|
|
dst.RestoreFromJson(buffer.ToString());
|
|
}
|
|
|
|
#endif
|
|
|
|
public static SerializedProperty AddActionMap(SerializedObject asset, int index = -1)
|
|
{
|
|
if (!(asset.targetObject is InputActionAsset))
|
|
throw new InvalidOperationException(
|
|
$"Can only add action maps to InputActionAsset objects (actual object is {asset.targetObject}");
|
|
|
|
var mapArrayProperty = asset.FindProperty("m_ActionMaps");
|
|
var name = FindUniqueName(mapArrayProperty, "New action map");
|
|
if (index < 0)
|
|
index = mapArrayProperty.arraySize;
|
|
|
|
mapArrayProperty.InsertArrayElementAtIndex(index);
|
|
var mapProperty = mapArrayProperty.GetArrayElementAtIndex(index);
|
|
|
|
mapProperty.FindPropertyRelative("m_Name").stringValue = name;
|
|
mapProperty.FindPropertyRelative("m_Id").stringValue = Guid.NewGuid().ToString();
|
|
mapProperty.FindPropertyRelative("m_Actions").ClearArray();
|
|
mapProperty.FindPropertyRelative("m_Bindings").ClearArray();
|
|
// NB: This isn't always required: If there's already values in the mapArrayProperty, then inserting a new
|
|
// element will duplicate the values from the adjacent element to the new element.
|
|
// However, if the array has been emptied - i.e. if all action maps have been deleted -
|
|
// then the m_Asset property is null, and needs setting here.
|
|
if (mapProperty.FindPropertyRelative("m_Asset").objectReferenceValue == null)
|
|
mapProperty.FindPropertyRelative("m_Asset").objectReferenceValue = asset.targetObject;
|
|
|
|
return mapProperty;
|
|
}
|
|
|
|
public static void DeleteActionMap(SerializedObject asset, Guid id)
|
|
{
|
|
var mapArrayProperty = asset.FindProperty("m_ActionMaps");
|
|
var mapIndex = GetIndex(mapArrayProperty, id);
|
|
if (mapIndex == -1)
|
|
throw new ArgumentException($"No map with id {id} in {asset}", nameof(id));
|
|
mapArrayProperty.DeleteArrayElementAtIndex(mapIndex);
|
|
}
|
|
|
|
public static void DeleteAllActionMaps(SerializedObject asset)
|
|
{
|
|
Debug.Assert(asset.targetObject is InputActionAsset);
|
|
|
|
var mapArrayProperty = asset.FindProperty("m_ActionMaps");
|
|
while (mapArrayProperty.arraySize > 0)
|
|
mapArrayProperty.DeleteArrayElementAtIndex(0);
|
|
}
|
|
|
|
public static void MoveActionMap(SerializedObject asset, int fromIndex, int toIndex)
|
|
{
|
|
var mapArrayProperty = asset.FindProperty("m_ActionMaps");
|
|
mapArrayProperty.MoveArrayElement(fromIndex, toIndex);
|
|
}
|
|
|
|
public static void MoveAction(SerializedProperty actionMap, int fromIndex, int toIndex)
|
|
{
|
|
var actionArrayProperty = actionMap.FindPropertyRelative(nameof(InputActionMap.m_Actions));
|
|
actionArrayProperty.MoveArrayElement(fromIndex, toIndex);
|
|
}
|
|
|
|
public static void MoveBinding(SerializedProperty actionMap, int fromIndex, int toIndex)
|
|
{
|
|
var arrayProperty = actionMap.FindPropertyRelative(nameof(InputActionMap.m_Bindings));
|
|
arrayProperty.MoveArrayElement(fromIndex, toIndex);
|
|
}
|
|
|
|
// Append a new action to the end of the set.
|
|
public static SerializedProperty AddAction(SerializedProperty actionMap, int index = -1)
|
|
{
|
|
var actionsArrayProperty = actionMap.FindPropertyRelative("m_Actions");
|
|
if (index < 0)
|
|
index = actionsArrayProperty.arraySize;
|
|
|
|
var actionName = FindUniqueName(actionsArrayProperty, "New action");
|
|
|
|
actionsArrayProperty.InsertArrayElementAtIndex(index);
|
|
var actionProperty = actionsArrayProperty.GetArrayElementAtIndex(index);
|
|
|
|
actionProperty.FindPropertyRelative("m_Name").stringValue = actionName;
|
|
actionProperty.FindPropertyRelative("m_Type").intValue = (int)InputActionType.Button; // Default to creating button actions.
|
|
actionProperty.FindPropertyRelative("m_Id").stringValue = Guid.NewGuid().ToString();
|
|
actionProperty.FindPropertyRelative("m_ExpectedControlType").stringValue = "Button";
|
|
actionProperty.FindPropertyRelative("m_Flags").intValue = 0;
|
|
actionProperty.FindPropertyRelative("m_Interactions").stringValue = "";
|
|
actionProperty.FindPropertyRelative("m_Processors").stringValue = "";
|
|
|
|
return actionProperty;
|
|
}
|
|
|
|
public static void DeleteActionAndBindings(SerializedProperty actionMap, Guid actionId)
|
|
{
|
|
using (var actionsArrayProperty = actionMap.FindPropertyRelative("m_Actions"))
|
|
using (var bindingsArrayProperty = actionMap.FindPropertyRelative("m_Bindings"))
|
|
{
|
|
// Find index of action.
|
|
var actionIndex = GetIndex(actionsArrayProperty, actionId);
|
|
if (actionIndex == -1)
|
|
throw new ArgumentException($"No action with ID {actionId} in {actionMap.propertyPath}",
|
|
nameof(actionId));
|
|
|
|
using (var actionsProperty = actionsArrayProperty.GetArrayElementAtIndex(actionIndex))
|
|
{
|
|
var actionName = GetName(actionsProperty);
|
|
var actionIdString = actionId.ToString();
|
|
|
|
// Delete all bindings that refer to the action by ID or name.
|
|
for (var i = 0; i < bindingsArrayProperty.arraySize; ++i)
|
|
{
|
|
using (var bindingProperty = bindingsArrayProperty.GetArrayElementAtIndex(i))
|
|
using (var bindingActionProperty = bindingProperty.FindPropertyRelative("m_Action"))
|
|
{
|
|
var targetAction = bindingActionProperty.stringValue;
|
|
if (targetAction.Equals(actionName, StringComparison.InvariantCultureIgnoreCase) ||
|
|
targetAction == actionIdString)
|
|
{
|
|
bindingsArrayProperty.DeleteArrayElementAtIndex(i);
|
|
--i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
actionsArrayProperty.DeleteArrayElementAtIndex(actionIndex);
|
|
}
|
|
}
|
|
|
|
// Equivalent to InputAction.AddBinding().
|
|
public static SerializedProperty AddBinding(SerializedProperty actionProperty,
|
|
SerializedProperty actionMapProperty = null, SerializedProperty afterBinding = null,
|
|
string groups = "", string path = "", string name = "",
|
|
string interactions = "", string processors = "",
|
|
InputBinding.Flags flags = InputBinding.Flags.None)
|
|
{
|
|
var bindingsArrayProperty = actionMapProperty != null
|
|
? actionMapProperty.FindPropertyRelative("m_Bindings")
|
|
: actionProperty.FindPropertyRelative("m_SingletonActionBindings");
|
|
var bindingsCount = bindingsArrayProperty.arraySize;
|
|
var actionName = actionProperty.FindPropertyRelative("m_Name").stringValue;
|
|
|
|
int bindingIndex;
|
|
if (afterBinding != null)
|
|
{
|
|
// If we're supposed to put the binding right after another binding, find the
|
|
// binding's index. Also, if it's a composite, skip past all its parts.
|
|
bindingIndex = GetIndex(bindingsArrayProperty, afterBinding);
|
|
if (IsCompositeBinding(afterBinding))
|
|
bindingIndex += GetCompositePartCount(bindingsArrayProperty, bindingIndex);
|
|
++bindingIndex; // Put it *after* the binding.
|
|
}
|
|
else
|
|
{
|
|
// Find the index of the last binding for the action in the array.
|
|
var indexOfLastBindingForAction = -1;
|
|
for (var i = 0; i < bindingsCount; ++i)
|
|
{
|
|
var bindingProperty = bindingsArrayProperty.GetArrayElementAtIndex(i);
|
|
var bindingActionName = bindingProperty.FindPropertyRelative("m_Action").stringValue;
|
|
if (actionName.Equals(bindingActionName, StringComparison.InvariantCultureIgnoreCase))
|
|
indexOfLastBindingForAction = i;
|
|
}
|
|
|
|
// Insert after last binding or at end of array.
|
|
bindingIndex = indexOfLastBindingForAction != -1 ? indexOfLastBindingForAction + 1 : bindingsCount;
|
|
}
|
|
|
|
////TODO: bind using {id} rather than action name
|
|
return AddBindingToBindingArray(bindingsArrayProperty,
|
|
bindingIndex: bindingIndex,
|
|
actionName: actionName,
|
|
groups: groups,
|
|
path: path,
|
|
name: name,
|
|
interactions: interactions,
|
|
processors: processors,
|
|
flags: flags);
|
|
}
|
|
|
|
public static SerializedProperty AddBindingToBindingArray(SerializedProperty bindingsArrayProperty, int bindingIndex = -1,
|
|
string actionName = "", string groups = "", string path = "", string name = "", string interactions = "", string processors = "",
|
|
InputBinding.Flags flags = InputBinding.Flags.None)
|
|
{
|
|
Debug.Assert(bindingsArrayProperty != null);
|
|
Debug.Assert(bindingsArrayProperty.isArray, "SerializedProperty is not an array of bindings");
|
|
Debug.Assert(bindingIndex == -1 || (bindingIndex >= 0 && bindingIndex <= bindingsArrayProperty.arraySize));
|
|
|
|
if (bindingIndex == -1)
|
|
bindingIndex = bindingsArrayProperty.arraySize;
|
|
|
|
bindingsArrayProperty.InsertArrayElementAtIndex(bindingIndex);
|
|
|
|
var newBindingProperty = bindingsArrayProperty.GetArrayElementAtIndex(bindingIndex);
|
|
newBindingProperty.FindPropertyRelative("m_Path").stringValue = path;
|
|
newBindingProperty.FindPropertyRelative("m_Groups").stringValue = groups;
|
|
newBindingProperty.FindPropertyRelative("m_Interactions").stringValue = interactions;
|
|
newBindingProperty.FindPropertyRelative("m_Processors").stringValue = processors;
|
|
newBindingProperty.FindPropertyRelative("m_Flags").intValue = (int)flags;
|
|
newBindingProperty.FindPropertyRelative("m_Action").stringValue = actionName;
|
|
newBindingProperty.FindPropertyRelative("m_Name").stringValue = name;
|
|
newBindingProperty.FindPropertyRelative("m_Id").stringValue = Guid.NewGuid().ToString();
|
|
|
|
////FIXME: this likely leaves m_Bindings in the map for singleton actions unsync'd in some cases
|
|
|
|
return newBindingProperty;
|
|
}
|
|
|
|
public static void SetBindingPartName(SerializedProperty bindingProperty, string partName)
|
|
{
|
|
//expects beautified partName
|
|
bindingProperty.FindPropertyRelative("m_Name").stringValue = partName;
|
|
}
|
|
|
|
public static void ChangeBinding(SerializedProperty bindingProperty, string path = null, string groups = null,
|
|
string interactions = null, string processors = null, string action = null)
|
|
{
|
|
// Path.
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
var pathProperty = bindingProperty.FindPropertyRelative("m_Path");
|
|
pathProperty.stringValue = path;
|
|
}
|
|
|
|
// Groups.
|
|
if (!string.IsNullOrEmpty(groups))
|
|
{
|
|
var groupsProperty = bindingProperty.FindPropertyRelative("m_Groups");
|
|
groupsProperty.stringValue = groups;
|
|
}
|
|
|
|
// Interactions.
|
|
if (!string.IsNullOrEmpty(interactions))
|
|
{
|
|
var interactionsProperty = bindingProperty.FindPropertyRelative("m_Interactions");
|
|
interactionsProperty.stringValue = interactions;
|
|
}
|
|
|
|
// Processors.
|
|
if (!string.IsNullOrEmpty(processors))
|
|
{
|
|
var processorsProperty = bindingProperty.FindPropertyRelative("m_Processors");
|
|
processorsProperty.stringValue = processors;
|
|
}
|
|
|
|
// Action.
|
|
if (!string.IsNullOrEmpty(action))
|
|
{
|
|
var actionProperty = bindingProperty.FindPropertyRelative("m_Action");
|
|
actionProperty.stringValue = action;
|
|
}
|
|
}
|
|
|
|
public static void DeleteBinding(SerializedProperty binding, SerializedProperty actionMap)
|
|
{
|
|
var bindingsProperty = actionMap.FindPropertyRelative("m_Bindings");
|
|
DeleteBinding(binding, bindingsProperty, binding.GetIndexOfArrayElement());
|
|
}
|
|
|
|
private static void DeleteBinding(SerializedProperty bindingProperty, SerializedProperty bindingArrayProperty, int bindingIndex)
|
|
{
|
|
var bindingFlags = (InputBinding.Flags)bindingProperty.FindPropertyRelative("m_Flags").intValue;
|
|
var isComposite = (bindingFlags & InputBinding.Flags.Composite) != 0;
|
|
// If it's a composite, delete all its parts first.
|
|
if (isComposite)
|
|
{
|
|
for (var partIndex = bindingIndex + 1; partIndex < bindingArrayProperty.arraySize;)
|
|
{
|
|
var part = bindingArrayProperty.GetArrayElementAtIndex(partIndex);
|
|
var flags = (InputBinding.Flags)part.FindPropertyRelative("m_Flags").intValue;
|
|
if ((flags & InputBinding.Flags.PartOfComposite) == 0)
|
|
break;
|
|
bindingArrayProperty.DeleteArrayElementAtIndex(partIndex);
|
|
}
|
|
}
|
|
|
|
bindingArrayProperty.DeleteArrayElementAtIndex(bindingIndex);
|
|
}
|
|
|
|
public static void DeleteBinding(SerializedProperty bindingArrayProperty, Guid id)
|
|
{
|
|
var bindingIndex = GetIndex(bindingArrayProperty, id);
|
|
var bindingProperty = bindingArrayProperty.GetArrayElementAtIndex(bindingIndex);
|
|
DeleteBinding(bindingProperty, bindingArrayProperty, bindingIndex);
|
|
}
|
|
|
|
public static void EnsureUniqueName(SerializedProperty arrayElement)
|
|
{
|
|
var arrayProperty = arrayElement.GetArrayPropertyFromElement();
|
|
var arrayIndexOfElement = arrayElement.GetIndexOfArrayElement();
|
|
var nameProperty = arrayElement.FindPropertyRelative("m_Name");
|
|
var baseName = nameProperty.stringValue;
|
|
nameProperty.stringValue = FindUniqueName(arrayProperty, baseName, ignoreIndex: arrayIndexOfElement);
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "False positive (possibly caused by lambda expression?).")]
|
|
public static string FindUniqueName(SerializedProperty arrayProperty, string baseName, int ignoreIndex = -1)
|
|
{
|
|
return StringHelpers.MakeUniqueName(baseName,
|
|
Enumerable.Range(0, arrayProperty.arraySize),
|
|
index =>
|
|
{
|
|
if (index == ignoreIndex)
|
|
return string.Empty;
|
|
var elementProperty = arrayProperty.GetArrayElementAtIndex(index);
|
|
var nameProperty = elementProperty.FindPropertyRelative("m_Name");
|
|
if (nameProperty == null)
|
|
throw new ArgumentException($"Cannot find m_Name property in elements of array",
|
|
nameof(arrayProperty));
|
|
return nameProperty.stringValue;
|
|
});
|
|
}
|
|
|
|
public static void AssignUniqueIDs(SerializedProperty element)
|
|
{
|
|
AssignUniqueID(element);
|
|
foreach (var child in element.GetChildren())
|
|
{
|
|
if (!child.isArray)
|
|
continue;
|
|
|
|
var fieldType = child.GetFieldType();
|
|
if (fieldType == typeof(InputBinding[]) || fieldType == typeof(InputAction[]) ||
|
|
fieldType == typeof(InputActionMap))
|
|
{
|
|
for (var i = 0; i < child.arraySize; ++i)
|
|
using (var childElement = child.GetArrayElementAtIndex(i))
|
|
AssignUniqueIDs(childElement);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void AssignUniqueID(SerializedProperty property)
|
|
{
|
|
var idProperty = property.FindPropertyRelative("m_Id");
|
|
idProperty.stringValue = Guid.NewGuid().ToString();
|
|
}
|
|
|
|
public static void RenameAction(SerializedProperty actionProperty, SerializedProperty actionMapProperty, string newName)
|
|
{
|
|
// Make sure name is unique.
|
|
var actionsArrayProperty = actionMapProperty.FindPropertyRelative("m_Actions");
|
|
var uniqueName = FindUniqueName(actionsArrayProperty, newName, actionProperty.GetIndexOfArrayElement());
|
|
|
|
// Update all bindings that refer to the action.
|
|
var nameProperty = actionProperty.FindPropertyRelative("m_Name");
|
|
var oldName = nameProperty.stringValue;
|
|
var bindingsProperty = actionMapProperty.FindPropertyRelative("m_Bindings");
|
|
for (var i = 0; i < bindingsProperty.arraySize; i++)
|
|
{
|
|
var element = bindingsProperty.GetArrayElementAtIndex(i);
|
|
var actionNameProperty = element.FindPropertyRelative("m_Action");
|
|
if (actionNameProperty.stringValue.Equals(oldName, StringComparison.InvariantCultureIgnoreCase))
|
|
actionNameProperty.stringValue = uniqueName;
|
|
}
|
|
|
|
// Update name.
|
|
nameProperty.stringValue = uniqueName;
|
|
}
|
|
|
|
public static void RenameActionMap(SerializedProperty actionMapProperty, string newName)
|
|
{
|
|
// Make sure name is unique in InputActionAsset.
|
|
var assetObject = actionMapProperty.serializedObject;
|
|
var mapsArrayProperty = assetObject.FindProperty("m_ActionMaps");
|
|
var uniqueName = FindUniqueName(mapsArrayProperty, newName, actionMapProperty.GetIndexOfArrayElement());
|
|
|
|
// Assign to map.
|
|
var nameProperty = actionMapProperty.FindPropertyRelative("m_Name");
|
|
nameProperty.stringValue = uniqueName;
|
|
}
|
|
|
|
public static void RenameComposite(SerializedProperty compositeGroupProperty, string newName)
|
|
{
|
|
var nameProperty = compositeGroupProperty.FindPropertyRelative("m_Name");
|
|
nameProperty.stringValue = newName;
|
|
}
|
|
|
|
public static SerializedProperty AddCompositeBinding(SerializedProperty actionProperty, SerializedProperty actionMapProperty,
|
|
string compositeName, Type compositeType = null, string groups = "", bool addPartBindings = true)
|
|
{
|
|
var newProperty = AddBinding(actionProperty, actionMapProperty);
|
|
newProperty.FindPropertyRelative("m_Name").stringValue = ObjectNames.NicifyVariableName(compositeName);
|
|
newProperty.FindPropertyRelative("m_Path").stringValue = compositeName;
|
|
newProperty.FindPropertyRelative("m_Flags").intValue = (int)InputBinding.Flags.Composite;
|
|
|
|
if (addPartBindings)
|
|
{
|
|
var fields = compositeType.GetFields(BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance);
|
|
foreach (var field in fields)
|
|
{
|
|
// Skip fields that aren't marked with [InputControl] attribute.
|
|
if (field.GetCustomAttribute<InputControlAttribute>(false) == null)
|
|
continue;
|
|
|
|
var partProperty = AddBinding(actionProperty, actionMapProperty, groups: groups);
|
|
partProperty.FindPropertyRelative("m_Name").stringValue = field.Name;
|
|
partProperty.FindPropertyRelative("m_Flags").intValue = (int)InputBinding.Flags.PartOfComposite;
|
|
}
|
|
}
|
|
|
|
return newProperty;
|
|
}
|
|
|
|
public static bool IsCompositeBinding(SerializedProperty bindingProperty)
|
|
{
|
|
using (var flagsProperty = bindingProperty.FindPropertyRelative("m_Flags"))
|
|
{
|
|
var flags = (InputBinding.Flags)flagsProperty.intValue;
|
|
return (flags & InputBinding.Flags.Composite) != 0;
|
|
}
|
|
}
|
|
|
|
public static SerializedProperty ChangeCompositeBindingType(SerializedProperty bindingProperty,
|
|
NameAndParameters nameAndParameters)
|
|
{
|
|
var bindingsArrayProperty = bindingProperty.GetArrayPropertyFromElement();
|
|
Debug.Assert(bindingsArrayProperty != null, "SerializedProperty is not an array of bindings");
|
|
var bindingIndex = bindingProperty.GetIndexOfArrayElement();
|
|
|
|
Debug.Assert(IsCompositeBinding(bindingProperty),
|
|
$"Binding {bindingProperty.propertyPath} is not a composite");
|
|
|
|
// If the composite still has the default name, change it to the default
|
|
// one for the new composite type.
|
|
var pathProperty = bindingProperty.FindPropertyRelative("m_Path");
|
|
var nameProperty = bindingProperty.FindPropertyRelative("m_Name");
|
|
if (nameProperty.stringValue ==
|
|
ObjectNames.NicifyVariableName(NameAndParameters.Parse(pathProperty.stringValue).name))
|
|
nameProperty.stringValue = ObjectNames.NicifyVariableName(nameAndParameters.name);
|
|
|
|
pathProperty.stringValue = nameAndParameters.ToString();
|
|
|
|
// Adjust part bindings if we have information on the registered composite. If we don't have
|
|
// a type, we don't know about the parts. In that case, leave part bindings untouched.
|
|
var compositeType = InputBindingComposite.s_Composites.LookupTypeRegistration(nameAndParameters.name);
|
|
if (compositeType != null)
|
|
{
|
|
var actionName = bindingProperty.FindPropertyRelative("m_Action").stringValue;
|
|
|
|
// Repurpose existing part bindings for the new composite or add any part bindings that
|
|
// we're missing.
|
|
var fields = compositeType.GetFields(BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance);
|
|
var partIndex = 0;
|
|
var partBindingsStartIndex = bindingIndex + 1;
|
|
foreach (var field in fields)
|
|
{
|
|
// Skip fields that aren't marked with [InputControl] attribute.
|
|
if (field.GetCustomAttribute<InputControlAttribute>(false) == null)
|
|
continue;
|
|
|
|
// See if we can reuse an existing part binding.
|
|
SerializedProperty partProperty = null;
|
|
if (partBindingsStartIndex + partIndex < bindingsArrayProperty.arraySize)
|
|
{
|
|
////REVIEW: this should probably look up part bindings by name rather than going sequentially
|
|
var element = bindingsArrayProperty.GetArrayElementAtIndex(partBindingsStartIndex + partIndex);
|
|
if (((InputBinding.Flags)element.FindPropertyRelative("m_Flags").intValue & InputBinding.Flags.PartOfComposite) != 0)
|
|
partProperty = element;
|
|
}
|
|
|
|
// If not, insert a new binding.
|
|
if (partProperty == null)
|
|
{
|
|
partProperty = AddBindingToBindingArray(bindingsArrayProperty, partBindingsStartIndex + partIndex,
|
|
flags: InputBinding.Flags.PartOfComposite);
|
|
}
|
|
|
|
// Initialize.
|
|
partProperty.FindPropertyRelative("m_Name").stringValue = ObjectNames.NicifyVariableName(field.Name);
|
|
partProperty.FindPropertyRelative("m_Action").stringValue = actionName;
|
|
++partIndex;
|
|
}
|
|
|
|
////REVIEW: when we allow adding the same part multiple times, we may want to do something smarter here
|
|
// Delete extraneous part bindings.
|
|
while (partBindingsStartIndex + partIndex < bindingsArrayProperty.arraySize)
|
|
{
|
|
var element = bindingsArrayProperty.GetArrayElementAtIndex(partBindingsStartIndex + partIndex);
|
|
if (((InputBinding.Flags)element.FindPropertyRelative("m_Flags").intValue & InputBinding.Flags.PartOfComposite) == 0)
|
|
break;
|
|
|
|
bindingsArrayProperty.DeleteArrayElementAtIndex(partBindingsStartIndex + partIndex);
|
|
// No incrementing of partIndex.
|
|
}
|
|
}
|
|
|
|
return bindingProperty;
|
|
}
|
|
|
|
public static void ReplaceBindingGroup(SerializedObject asset, string oldBindingGroup, string newBindingGroup, bool deleteOrphanedBindings = false)
|
|
{
|
|
var mapArrayProperty = asset.FindProperty("m_ActionMaps");
|
|
var mapCount = mapArrayProperty.arraySize;
|
|
|
|
for (var k = 0; k < mapCount; ++k)
|
|
{
|
|
var actionMapProperty = mapArrayProperty.GetArrayElementAtIndex(k);
|
|
var bindingsArrayProperty = actionMapProperty.FindPropertyRelative("m_Bindings");
|
|
var bindingsCount = bindingsArrayProperty.arraySize;
|
|
|
|
for (var i = 0; i < bindingsCount; ++i)
|
|
{
|
|
var bindingProperty = bindingsArrayProperty.GetArrayElementAtIndex(i);
|
|
var groupsProperty = bindingProperty.FindPropertyRelative("m_Groups");
|
|
var groups = groupsProperty.stringValue;
|
|
|
|
// Ignore bindings not belonging to any control scheme.
|
|
if (string.IsNullOrEmpty(groups))
|
|
continue;
|
|
|
|
var groupsArray = groups.Split(InputBinding.Separator);
|
|
var numGroups = groupsArray.LengthSafe();
|
|
var didRename = false;
|
|
for (var n = 0; n < numGroups; ++n)
|
|
{
|
|
if (string.Compare(groupsArray[n], oldBindingGroup, StringComparison.InvariantCultureIgnoreCase) != 0)
|
|
continue;
|
|
if (string.IsNullOrEmpty(newBindingGroup))
|
|
{
|
|
ArrayHelpers.EraseAt(ref groupsArray, n);
|
|
--n;
|
|
--numGroups;
|
|
}
|
|
else
|
|
groupsArray[n] = newBindingGroup;
|
|
didRename = true;
|
|
}
|
|
if (!didRename)
|
|
continue;
|
|
|
|
if (groupsArray != null)
|
|
groupsProperty.stringValue = string.Join(InputBinding.kSeparatorString, groupsArray);
|
|
else
|
|
{
|
|
if (deleteOrphanedBindings)
|
|
{
|
|
// Binding no long belongs to any binding group. Delete it.
|
|
bindingsArrayProperty.DeleteArrayElementAtIndex(i);
|
|
--i;
|
|
--bindingsCount;
|
|
}
|
|
else
|
|
{
|
|
groupsProperty.stringValue = string.Empty;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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))));
|
|
}
|
|
|
|
#region Control Schemes
|
|
|
|
public static void DeleteAllControlSchemes(SerializedObject asset)
|
|
{
|
|
var schemes = GetControlSchemesArray(asset);
|
|
while (schemes.arraySize > 0)
|
|
schemes.DeleteArrayElementAtIndex(0);
|
|
}
|
|
|
|
public static int IndexOfControlScheme(SerializedProperty controlSchemeArray, string controlSchemeName)
|
|
{
|
|
var serializedControlScheme = controlSchemeArray.FirstOrDefault(sp =>
|
|
sp.FindPropertyRelative(nameof(InputControlScheme.m_Name)).stringValue == controlSchemeName);
|
|
return serializedControlScheme?.GetIndexOfArrayElement() ?? -1;
|
|
}
|
|
|
|
public static SerializedProperty GetControlSchemesArray(SerializedObject asset)
|
|
{
|
|
return asset.FindProperty(nameof(InputActionAsset.m_ControlSchemes));
|
|
}
|
|
|
|
#endregion // Control Schemes
|
|
}
|
|
}
|
|
#endif // UNITY_EDITOR
|