534 lines
20 KiB
C#
534 lines
20 KiB
C#
// InputBindingManager.cs
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using System.Reactive.Linq;
|
|
using System.Threading.Tasks;
|
|
using UnityEngine;
|
|
using UnityEngine.InputSystem;
|
|
using System.Reactive.Subjects;
|
|
using AlicizaX.InputGlyph;
|
|
using RxUnit = System.Reactive.Unit;
|
|
|
|
namespace InputRemapper
|
|
{
|
|
public class InputBindingManager : MonoBehaviour
|
|
{
|
|
public const string NULL_BINDING = "__NULL__";
|
|
|
|
[Tooltip("InputActionAsset to manage")]
|
|
public InputActionAsset actions;
|
|
|
|
[SerializeField] private InputGlyphDatabase inputGlyphDatabase;
|
|
|
|
public string fileName = "input_bindings.json";
|
|
public bool debugMode = false;
|
|
|
|
public Dictionary<string, ActionMap> actionMap = new Dictionary<string, ActionMap>();
|
|
public List<RebindContext> preparedRebinds = new List<RebindContext>();
|
|
|
|
internal InputActionRebindingExtensions.RebindingOperation rebindOperation;
|
|
private readonly List<string> pressedActions = new List<string>();
|
|
private bool isApplyPending = false;
|
|
private string defaultBindingsJson = string.Empty;
|
|
|
|
public ReplaySubject<RxUnit> OnInputsInit = new ReplaySubject<RxUnit>(1);
|
|
public Subject<bool> OnApply = new Subject<bool>();
|
|
public Subject<RebindContext> OnRebindPrepare = new Subject<RebindContext>();
|
|
public Subject<RxUnit> OnRebindStart = new Subject<RxUnit>();
|
|
public Subject<bool> OnRebindEnd = new Subject<bool>();
|
|
public Subject<(RebindContext prepared, RebindContext conflict)> OnRebindConflict = new Subject<(RebindContext, RebindContext)>();
|
|
|
|
public string SavePath
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_EDITOR
|
|
string folder = Application.dataPath;
|
|
#else
|
|
string folder = Application.persistentDataPath;
|
|
#endif
|
|
if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);
|
|
return Path.Combine(folder, fileName);
|
|
}
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (actions == null)
|
|
{
|
|
Debug.LogError("InputBindingManager: InputActionAsset not assigned.");
|
|
return;
|
|
}
|
|
|
|
BuildActionMap();
|
|
|
|
try
|
|
{
|
|
defaultBindingsJson = actions.SaveBindingOverridesAsJson();
|
|
}
|
|
catch
|
|
{
|
|
defaultBindingsJson = string.Empty;
|
|
}
|
|
|
|
if (File.Exists(SavePath))
|
|
{
|
|
try
|
|
{
|
|
var json = File.ReadAllText(SavePath);
|
|
if (!string.IsNullOrEmpty(json))
|
|
{
|
|
actions.LoadBindingOverridesFromJson(json);
|
|
RefreshBindingPathsFromActions();
|
|
if (debugMode) Debug.Log($"Loaded overrides from {SavePath}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("Failed to load overrides: " + ex);
|
|
}
|
|
}
|
|
|
|
OnInputsInit.OnNext(RxUnit.Default);
|
|
actions.Enable();
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
rebindOperation?.Dispose();
|
|
rebindOperation = null;
|
|
|
|
OnInputsInit?.OnCompleted();
|
|
OnApply?.OnCompleted();
|
|
OnRebindPrepare?.OnCompleted();
|
|
OnRebindStart?.OnCompleted();
|
|
OnRebindEnd?.OnCompleted();
|
|
OnRebindConflict?.OnCompleted();
|
|
}
|
|
|
|
private void BuildActionMap()
|
|
{
|
|
actionMap.Clear();
|
|
foreach (var map in actions.actionMaps)
|
|
actionMap.Add(map.name, new ActionMap(map));
|
|
}
|
|
|
|
private void RefreshBindingPathsFromActions()
|
|
{
|
|
foreach (var mapPair in actionMap)
|
|
{
|
|
foreach (var actionPair in mapPair.Value.actions)
|
|
{
|
|
var a = actionPair.Value;
|
|
foreach (var bpair in a.bindings)
|
|
{
|
|
bpair.Value.bindingPath.EffectivePath = a.action.bindings[bpair.Key].effectivePath;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ActionMap
|
|
{
|
|
public string name;
|
|
public Dictionary<string, Action> actions = new Dictionary<string, Action>();
|
|
|
|
public ActionMap(InputActionMap map)
|
|
{
|
|
name = map.name;
|
|
foreach (var action in map.actions) actions.Add(action.name, new Action(action));
|
|
}
|
|
|
|
public class Action
|
|
{
|
|
public InputAction action;
|
|
public Dictionary<int, Binding> bindings = new Dictionary<int, Binding>();
|
|
|
|
public Action(InputAction action)
|
|
{
|
|
this.action = action;
|
|
int count = action.bindings.Count;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (action.bindings[i].isComposite)
|
|
{
|
|
int first = i + 1;
|
|
int last = first;
|
|
while (last < count && action.bindings[last].isPartOfComposite) last++;
|
|
for (int p = first; p < last; p++)
|
|
AddBinding(action.bindings[p], p);
|
|
i = last - 1;
|
|
}
|
|
else
|
|
{
|
|
AddBinding(action.bindings[i], i);
|
|
}
|
|
}
|
|
|
|
void AddBinding(InputBinding binding, int bindingIndex)
|
|
{
|
|
bindings.Add(bindingIndex, new Binding
|
|
{
|
|
name = binding.name,
|
|
parentAction = action.name,
|
|
compositePart = binding.name,
|
|
bindingIndex = bindingIndex,
|
|
group = binding.groups?.Split(InputBinding.Separator) ?? Array.Empty<string>(),
|
|
bindingPath = new BindingPath(binding.path, binding.overridePath),
|
|
inputBinding = binding
|
|
});
|
|
}
|
|
}
|
|
|
|
public struct Binding
|
|
{
|
|
public string name;
|
|
public string parentAction;
|
|
public string compositePart;
|
|
public int bindingIndex;
|
|
public string[] group;
|
|
public BindingPath bindingPath;
|
|
public InputBinding inputBinding;
|
|
}
|
|
}
|
|
}
|
|
|
|
public sealed class BindingPath
|
|
{
|
|
public string bindingPath;
|
|
public string overridePath;
|
|
private readonly Subject<RxUnit> observer = new Subject<RxUnit>();
|
|
|
|
public BindingPath(string bindingPath, string overridePath)
|
|
{
|
|
this.bindingPath = bindingPath;
|
|
this.overridePath = overridePath;
|
|
}
|
|
|
|
public string EffectivePath
|
|
{
|
|
get => !string.IsNullOrEmpty(overridePath) ? overridePath : bindingPath;
|
|
set
|
|
{
|
|
overridePath = (value == bindingPath) ? string.Empty : value;
|
|
observer.OnNext(RxUnit.Default);
|
|
}
|
|
}
|
|
|
|
public IObservable<string> EffectivePathObservable => observer.Select(_ => EffectivePath);
|
|
}
|
|
|
|
public class RebindContext
|
|
{
|
|
public InputAction action;
|
|
public int bindingIndex;
|
|
public string overridePath;
|
|
|
|
public RebindContext(InputAction action, int bindingIndex, string overridePath)
|
|
{
|
|
this.action = action;
|
|
this.bindingIndex = bindingIndex;
|
|
this.overridePath = overridePath;
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj is not RebindContext other) return false;
|
|
if (action == null || other.action == null) return false;
|
|
return action.name == other.action.name && bindingIndex == other.bindingIndex;
|
|
}
|
|
|
|
public override int GetHashCode() => (action?.name ?? string.Empty, bindingIndex).GetHashCode();
|
|
public override string ToString() => $"{action?.name ?? "<null>"}:{bindingIndex}";
|
|
}
|
|
|
|
/* ---------------- Public API ---------------- */
|
|
|
|
public static InputAction Action(string actionName)
|
|
{
|
|
foreach (var map in Instance.actionMap)
|
|
{
|
|
if (map.Value.actions.TryGetValue(actionName, out var a)) return a.action;
|
|
}
|
|
|
|
Debug.LogError($"[InputBindingManager] Could not find action '{actionName}'");
|
|
return null;
|
|
}
|
|
|
|
public static void StartRebind(string actionName, string compositePartName = null)
|
|
{
|
|
var action = Action(actionName);
|
|
if (action == null) return;
|
|
|
|
// decide bindingIndex & deviceMatch automatically
|
|
int bindingIndex = Instance.FindBestBindingIndexForKeyboard(action, compositePartName);
|
|
if (bindingIndex < 0)
|
|
{
|
|
Debug.LogError($"[InputBindingManager] No suitable binding found for action '{actionName}' (part={compositePartName ?? "<null>"})");
|
|
return;
|
|
}
|
|
|
|
Instance.actions.Disable();
|
|
Instance.PerformInteractiveRebinding(action, bindingIndex, "<Keyboard>", true);
|
|
Instance.OnRebindStart.OnNext(RxUnit.Default);
|
|
if (Instance.debugMode) Debug.Log("[InputBindingManager] Rebind started");
|
|
}
|
|
|
|
public static void CancelRebind() => Instance.rebindOperation?.Cancel();
|
|
|
|
public static async Task<bool> ConfirmApply(bool clearConflicts = true)
|
|
{
|
|
if (!Instance.isApplyPending) return false;
|
|
|
|
try
|
|
{
|
|
foreach (var ctx in Instance.preparedRebinds)
|
|
{
|
|
if (string.IsNullOrEmpty(ctx.overridePath))
|
|
{
|
|
}
|
|
else if (ctx.overridePath == NULL_BINDING) ctx.action.RemoveBindingOverride(ctx.bindingIndex);
|
|
else ctx.action.ApplyBindingOverride(ctx.bindingIndex, ctx.overridePath);
|
|
|
|
var bp = GetBindingPath(ctx.action.name, ctx.bindingIndex);
|
|
if (bp != null) bp.EffectivePath = (ctx.overridePath == NULL_BINDING) ? string.Empty : ctx.overridePath;
|
|
}
|
|
|
|
Instance.preparedRebinds.Clear();
|
|
await Instance.WriteOverridesToDiskAsync();
|
|
Instance.OnApply.OnNext(true);
|
|
Instance.isApplyPending = false;
|
|
if (Instance.debugMode) Debug.Log("[InputBindingManager] Apply confirmed and saved.");
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("[InputBindingManager] Failed to apply binds: " + ex);
|
|
Instance.OnApply.OnNext(false);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static void DiscardPrepared()
|
|
{
|
|
if (!Instance.isApplyPending) return;
|
|
Instance.preparedRebinds.Clear();
|
|
Instance.isApplyPending = false;
|
|
Instance.OnApply.OnNext(false);
|
|
if (Instance.debugMode) Debug.Log("[InputBindingManager] Prepared rebinds discarded.");
|
|
}
|
|
|
|
private void PerformInteractiveRebinding(InputAction action, int bindingIndex, string deviceMatchPath = null, bool excludeMouseMovementAndScroll = true)
|
|
{
|
|
var op = action.PerformInteractiveRebinding(bindingIndex);
|
|
|
|
if (!string.IsNullOrEmpty(deviceMatchPath)) op = op.WithControlsHavingToMatchPath(deviceMatchPath);
|
|
if (excludeMouseMovementAndScroll)
|
|
{
|
|
op = op.WithControlsExcluding("<Mouse>/delta");
|
|
op = op.WithControlsExcluding("<Mouse>/scroll");
|
|
op = op.WithControlsExcluding("<Mouse>/scroll/x");
|
|
op = op.WithControlsExcluding("<Mouse>/scroll/y");
|
|
}
|
|
|
|
rebindOperation = op
|
|
.OnApplyBinding((o, path) =>
|
|
{
|
|
if (AnyPreparedRebind(path, action, bindingIndex, out var existing))
|
|
{
|
|
PrepareRebind(new RebindContext(action, bindingIndex, path));
|
|
PrepareRebind(new RebindContext(existing.action, existing.bindingIndex, NULL_BINDING));
|
|
OnRebindConflict.OnNext((new RebindContext(action, bindingIndex, path), existing));
|
|
}
|
|
else if (AnyBindingPath(path, action, bindingIndex, out var dup))
|
|
{
|
|
PrepareRebind(new RebindContext(action, bindingIndex, path));
|
|
PrepareRebind(new RebindContext(dup.action, dup.bindingIndex, NULL_BINDING));
|
|
OnRebindConflict.OnNext((new RebindContext(action, bindingIndex, path), new RebindContext(dup.action, dup.bindingIndex, dup.action.bindings[dup.bindingIndex].path)));
|
|
}
|
|
else
|
|
{
|
|
PrepareRebind(new RebindContext(action, bindingIndex, path));
|
|
}
|
|
})
|
|
.OnComplete(opc =>
|
|
{
|
|
if (debugMode) Debug.Log("[InputBindingManager] Rebind completed");
|
|
actions.Enable();
|
|
OnRebindEnd.OnNext(true);
|
|
CleanRebindOperation();
|
|
})
|
|
.OnCancel(opc =>
|
|
{
|
|
if (debugMode) Debug.Log("[InputBindingManager] Rebind cancelled");
|
|
actions.Enable();
|
|
OnRebindEnd.OnNext(false);
|
|
CleanRebindOperation();
|
|
})
|
|
.WithCancelingThrough("<Keyboard>/escape")
|
|
.Start();
|
|
}
|
|
|
|
private void CleanRebindOperation()
|
|
{
|
|
rebindOperation?.Dispose();
|
|
rebindOperation = null;
|
|
}
|
|
|
|
private bool AnyPreparedRebind(string bindingPath, InputAction currentAction, int currentIndex, out RebindContext duplicate)
|
|
{
|
|
foreach (var ctx in preparedRebinds)
|
|
{
|
|
if (ctx.overridePath == bindingPath && (ctx.action != currentAction || (ctx.action == currentAction && ctx.bindingIndex != currentIndex)))
|
|
{
|
|
duplicate = ctx;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
duplicate = null;
|
|
return false;
|
|
}
|
|
|
|
private bool AnyBindingPath(string bindingPath, InputAction currentAction, int currentIndex, out (InputAction action, int bindingIndex) duplicate)
|
|
{
|
|
foreach (var map in actionMap)
|
|
{
|
|
foreach (var actionPair in map.Value.actions)
|
|
{
|
|
foreach (var bindingPair in actionPair.Value.bindings)
|
|
{
|
|
if (actionPair.Value.action == currentAction && bindingPair.Key == currentIndex) continue;
|
|
var eff = bindingPair.Value.bindingPath.EffectivePath;
|
|
if (eff == bindingPath)
|
|
{
|
|
duplicate = (actionPair.Value.action, bindingPair.Key);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
duplicate = default;
|
|
return false;
|
|
}
|
|
|
|
private void PrepareRebind(RebindContext context)
|
|
{
|
|
preparedRebinds.RemoveAll(x => x.Equals(context));
|
|
|
|
if (string.IsNullOrEmpty(context.overridePath))
|
|
{
|
|
var bp = GetBindingPath(context.action.name, context.bindingIndex);
|
|
if (bp != null) context.overridePath = bp.bindingPath;
|
|
}
|
|
|
|
var bindingPath = GetBindingPath(context.action.name, context.bindingIndex);
|
|
if (bindingPath == null) return;
|
|
|
|
if (bindingPath.EffectivePath != context.overridePath)
|
|
{
|
|
preparedRebinds.Add(context);
|
|
isApplyPending = true;
|
|
OnRebindPrepare.OnNext(context);
|
|
if (debugMode) Debug.Log($"Prepared rebind: {context} -> {context.overridePath}");
|
|
}
|
|
}
|
|
|
|
private async Task WriteOverridesToDiskAsync()
|
|
{
|
|
try
|
|
{
|
|
var json = actions.SaveBindingOverridesAsJson();
|
|
var dir = Path.GetDirectoryName(SavePath);
|
|
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
|
|
using (var sw = new StreamWriter(SavePath, false)) await sw.WriteAsync(json);
|
|
if (debugMode) Debug.Log($"Overrides saved to {SavePath}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("Failed to save overrides: " + ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task ResetToDefaultAsync()
|
|
{
|
|
try
|
|
{
|
|
if (!string.IsNullOrEmpty(defaultBindingsJson)) actions.LoadBindingOverridesFromJson(defaultBindingsJson);
|
|
else
|
|
{
|
|
foreach (var map in actionMap)
|
|
foreach (var a in map.Value.actions)
|
|
for (int b = 0; b < a.Value.action.bindings.Count; b++)
|
|
a.Value.action.RemoveBindingOverride(b);
|
|
}
|
|
|
|
RefreshBindingPathsFromActions();
|
|
await WriteOverridesToDiskAsync();
|
|
if (debugMode) Debug.Log("Reset to default and saved.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("Failed to reset defaults: " + ex);
|
|
}
|
|
}
|
|
|
|
public static BindingPath GetBindingPath(string actionName, int bindingIndex = 0)
|
|
{
|
|
foreach (var map in Instance.actionMap)
|
|
{
|
|
if (map.Value.actions.TryGetValue(actionName, out var action))
|
|
{
|
|
if (action.bindings.TryGetValue(bindingIndex, out var binding)) return binding.bindingPath;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
// choose best binding index for keyboard; if compositePartName != null then look for part
|
|
public int FindBestBindingIndexForKeyboard(InputAction action, string compositePartName = null)
|
|
{
|
|
if (action == null) return -1;
|
|
|
|
int fallbackPart = -1;
|
|
int fallbackNonComposite = -1;
|
|
|
|
for (int i = 0; i < action.bindings.Count; i++)
|
|
{
|
|
var b = action.bindings[i];
|
|
|
|
if (!string.IsNullOrEmpty(compositePartName))
|
|
{
|
|
if (!b.isPartOfComposite) continue;
|
|
if (!string.Equals(b.name, compositePartName, StringComparison.OrdinalIgnoreCase)) continue;
|
|
}
|
|
|
|
if (b.isPartOfComposite)
|
|
{
|
|
if (fallbackPart == -1) fallbackPart = i;
|
|
if (!string.IsNullOrEmpty(b.path) && b.path.StartsWith("<Keyboard>", StringComparison.OrdinalIgnoreCase)) return i;
|
|
if (!string.IsNullOrEmpty(b.effectivePath) && b.effectivePath.StartsWith("<Keyboard>", StringComparison.OrdinalIgnoreCase)) return i;
|
|
}
|
|
else
|
|
{
|
|
if (fallbackNonComposite == -1) fallbackNonComposite = i;
|
|
if (!string.IsNullOrEmpty(b.path) && b.path.StartsWith("<Keyboard>", StringComparison.OrdinalIgnoreCase)) return i;
|
|
if (!string.IsNullOrEmpty(b.effectivePath) && b.effectivePath.StartsWith("<Keyboard>", StringComparison.OrdinalIgnoreCase)) return i;
|
|
}
|
|
}
|
|
|
|
if (fallbackNonComposite >= 0) return fallbackNonComposite;
|
|
return fallbackPart;
|
|
}
|
|
|
|
public static InputBindingManager Instance => _instance ??= FindObjectOfType<InputBindingManager>();
|
|
private static InputBindingManager _instance;
|
|
}
|
|
}
|