465 lines
19 KiB
C#
465 lines
19 KiB
C#
using System;
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|
using UnityEngine.InputSystem.LowLevel;
|
|
using UnityEngine.InputSystem.Utilities;
|
|
|
|
namespace UnityEngine.InputSystem
|
|
{
|
|
/// <summary>
|
|
/// Tracks per-device state change monitors and timeouts for <see cref="InputManager"/>.
|
|
/// </summary>
|
|
internal sealed class InputManagerStateMonitors
|
|
{
|
|
private readonly Func<int> m_GetDeviceCount;
|
|
private readonly Func<bool> m_IsProcessingEvents;
|
|
private readonly IInputRuntime m_Runtime;
|
|
|
|
// Indices correspond with those in InputManager's device array.
|
|
internal StateChangeMonitorsForDevice[] m_MonitorsPerDevice;
|
|
private InlinedArray<StateChangeMonitorTimeout> m_Timeouts;
|
|
|
|
public InputManagerStateMonitors(Func<int> getDeviceCount, Func<bool> isProcessingEvents, IInputRuntime runtime)
|
|
{
|
|
m_GetDeviceCount = getDeviceCount ?? throw new ArgumentNullException(nameof(getDeviceCount));
|
|
m_IsProcessingEvents = isProcessingEvents ?? throw new ArgumentNullException(nameof(isProcessingEvents));
|
|
m_Runtime = runtime ?? throw new ArgumentNullException(nameof(runtime));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Runtime instance this monitor collection was constructed with. Used to avoid recreating the collection
|
|
/// when <see cref="InputManager.InstallRuntime"/> is called again with the same runtime (same object identity).
|
|
/// </summary>
|
|
internal IInputRuntime CapturedRuntime => m_Runtime;
|
|
|
|
////TODO: support combining monitors for bitfields
|
|
public void AddStateChangeMonitor(InputControl control, IInputStateChangeMonitor monitor, long monitorIndex, uint groupIndex)
|
|
{
|
|
var devicesCount = m_GetDeviceCount();
|
|
if (devicesCount <= 0)
|
|
return;
|
|
|
|
var device = control.device;
|
|
var deviceIndex = device.m_DeviceIndex;
|
|
Debug.Assert(deviceIndex != InputDevice.kInvalidDeviceIndex);
|
|
|
|
if (m_MonitorsPerDevice == null)
|
|
m_MonitorsPerDevice = new StateChangeMonitorsForDevice[devicesCount];
|
|
else if (m_MonitorsPerDevice.Length <= deviceIndex)
|
|
Array.Resize(ref m_MonitorsPerDevice, devicesCount);
|
|
|
|
if (!m_IsProcessingEvents() && m_MonitorsPerDevice[deviceIndex].needToCompactArrays)
|
|
m_MonitorsPerDevice[deviceIndex].CompactArrays();
|
|
|
|
m_MonitorsPerDevice[deviceIndex].Add(control, monitor, monitorIndex, groupIndex);
|
|
}
|
|
|
|
public void RemoveStateChangeMonitor(InputControl control, IInputStateChangeMonitor monitor, long monitorIndex)
|
|
{
|
|
if (m_MonitorsPerDevice == null)
|
|
return;
|
|
|
|
var device = control.device;
|
|
var deviceIndex = device.m_DeviceIndex;
|
|
|
|
if (deviceIndex == InputDevice.kInvalidDeviceIndex)
|
|
return;
|
|
|
|
if (deviceIndex >= m_MonitorsPerDevice.Length)
|
|
return;
|
|
|
|
m_MonitorsPerDevice[deviceIndex].Remove(monitor, monitorIndex, m_IsProcessingEvents());
|
|
|
|
for (var i = 0; i < m_Timeouts.length; ++i)
|
|
if (m_Timeouts[i].monitor == monitor && m_Timeouts[i].monitorIndex == monitorIndex)
|
|
m_Timeouts[i] = default;
|
|
}
|
|
|
|
public void AddStateChangeMonitorTimeout(InputControl control, IInputStateChangeMonitor monitor, double time, long monitorIndex, int timerIndex)
|
|
{
|
|
m_Timeouts.Append(new StateChangeMonitorTimeout
|
|
{
|
|
control = control,
|
|
time = time,
|
|
monitor = monitor,
|
|
monitorIndex = monitorIndex,
|
|
timerIndex = timerIndex,
|
|
});
|
|
}
|
|
|
|
public void RemoveStateChangeMonitorTimeout(IInputStateChangeMonitor monitor, long monitorIndex, int timerIndex)
|
|
{
|
|
var timeoutCount = m_Timeouts.length;
|
|
for (var i = 0; i < timeoutCount; ++i)
|
|
{
|
|
if (ReferenceEquals(m_Timeouts[i].monitor, monitor)
|
|
&& m_Timeouts[i].monitorIndex == monitorIndex
|
|
&& m_Timeouts[i].timerIndex == timerIndex)
|
|
{
|
|
m_Timeouts[i] = default;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SignalStateChangeMonitor(InputControl control, IInputStateChangeMonitor monitor)
|
|
{
|
|
var device = control.device;
|
|
var deviceIndex = device.m_DeviceIndex;
|
|
|
|
if (m_MonitorsPerDevice == null || deviceIndex >= m_MonitorsPerDevice.Length)
|
|
return;
|
|
|
|
SortMonitorsForDeviceIfNeeded(deviceIndex);
|
|
|
|
ref var monitorsForDevice = ref m_MonitorsPerDevice[deviceIndex];
|
|
for (var i = 0; i < monitorsForDevice.signalled.length; ++i)
|
|
{
|
|
ref var listener = ref monitorsForDevice.listeners[i];
|
|
if (listener.control == control && listener.monitor == monitor)
|
|
monitorsForDevice.signalled.SetBit(i);
|
|
}
|
|
}
|
|
|
|
public unsafe void FireStateChangeNotifications()
|
|
{
|
|
var time = m_Runtime.currentTime;
|
|
var count = Math.Min(m_MonitorsPerDevice.LengthSafe(), m_GetDeviceCount());
|
|
for (var i = 0; i < count; ++i)
|
|
FireStateChangeNotifications(i, time, null);
|
|
}
|
|
|
|
internal void OnDeviceRemoved(InputDevice device)
|
|
{
|
|
ClearMonitorsAndTimeoutsForDevice(device);
|
|
|
|
var deviceIndex = device.m_DeviceIndex;
|
|
if (m_MonitorsPerDevice != null && deviceIndex < m_MonitorsPerDevice.LengthSafe())
|
|
{
|
|
var count = m_MonitorsPerDevice.Length;
|
|
ArrayHelpers.EraseAtWithCapacity(m_MonitorsPerDevice, ref count, deviceIndex);
|
|
}
|
|
}
|
|
|
|
internal void ProcessTimeouts()
|
|
{
|
|
if (m_Timeouts.length == 0)
|
|
return;
|
|
|
|
var currentTime = m_Runtime.currentTime - InputRuntime.s_CurrentTimeOffsetToRealtimeSinceStartup;
|
|
var remainingTimeoutCount = 0;
|
|
for (var i = 0; i < m_Timeouts.length; ++i)
|
|
{
|
|
if (m_Timeouts[i].control == null)
|
|
continue;
|
|
|
|
if (m_Timeouts[i].time <= currentTime)
|
|
{
|
|
var timeout = m_Timeouts[i];
|
|
timeout.monitor.NotifyTimerExpired(timeout.control, currentTime, timeout.monitorIndex, timeout.timerIndex);
|
|
}
|
|
else
|
|
{
|
|
if (i != remainingTimeoutCount)
|
|
m_Timeouts[remainingTimeoutCount] = m_Timeouts[i];
|
|
++remainingTimeoutCount;
|
|
}
|
|
}
|
|
|
|
m_Timeouts.SetLength(remainingTimeoutCount);
|
|
}
|
|
|
|
internal void SortMonitorsForDeviceIfNeeded(int deviceIndex)
|
|
{
|
|
if (m_MonitorsPerDevice != null && deviceIndex < m_MonitorsPerDevice.Length &&
|
|
m_MonitorsPerDevice[deviceIndex].needToUpdateOrderingOfMonitors)
|
|
m_MonitorsPerDevice[deviceIndex].SortMonitorsByIndex();
|
|
}
|
|
|
|
internal unsafe bool ProcessStateChange(int deviceIndex, void* newStateFromEvent, void* oldStateOfDevice, uint newStateSizeInBytes, uint newStateOffsetInBytes)
|
|
{
|
|
if (m_MonitorsPerDevice == null)
|
|
return false;
|
|
|
|
if (deviceIndex >= m_MonitorsPerDevice.Length)
|
|
return false;
|
|
|
|
var memoryRegions = m_MonitorsPerDevice[deviceIndex].memoryRegions;
|
|
if (memoryRegions == null)
|
|
return false;
|
|
|
|
var numMonitors = m_MonitorsPerDevice[deviceIndex].count;
|
|
var signalled = false;
|
|
var signals = m_MonitorsPerDevice[deviceIndex].signalled;
|
|
var haveChangedSignalsBitfield = false;
|
|
|
|
var newEventMemoryRegion = new MemoryHelpers.BitRegion(newStateOffsetInBytes, 0, newStateSizeInBytes * 8);
|
|
for (var i = 0; i < numMonitors; ++i)
|
|
{
|
|
var memoryRegion = memoryRegions[i];
|
|
|
|
if (memoryRegion.sizeInBits == 0)
|
|
{
|
|
var listenerCount = numMonitors;
|
|
var memoryRegionCount = numMonitors;
|
|
m_MonitorsPerDevice[deviceIndex].listeners.EraseAtWithCapacity(ref listenerCount, i);
|
|
memoryRegions.EraseAtWithCapacity(ref memoryRegionCount, i);
|
|
signals.SetLength(numMonitors - 1);
|
|
haveChangedSignalsBitfield = true;
|
|
--numMonitors;
|
|
--i;
|
|
continue;
|
|
}
|
|
|
|
var overlap = newEventMemoryRegion.Overlap(memoryRegion);
|
|
if (overlap.isEmpty || MemoryHelpers.Compare(oldStateOfDevice, (byte*)newStateFromEvent - newStateOffsetInBytes, overlap))
|
|
continue;
|
|
|
|
signals.SetBit(i);
|
|
haveChangedSignalsBitfield = true;
|
|
signalled = true;
|
|
}
|
|
|
|
if (haveChangedSignalsBitfield)
|
|
m_MonitorsPerDevice[deviceIndex].signalled = signals;
|
|
|
|
m_MonitorsPerDevice[deviceIndex].needToCompactArrays = false;
|
|
|
|
return signalled;
|
|
}
|
|
|
|
internal unsafe void FireStateChangeNotifications(int deviceIndex, double internalTime, InputEvent* eventPtr)
|
|
{
|
|
if (m_MonitorsPerDevice == null)
|
|
{
|
|
Debug.Assert(false, "State change monitors array is null - has AddStateChangeMonitor been called?");
|
|
return;
|
|
}
|
|
|
|
if (m_MonitorsPerDevice.Length <= deviceIndex)
|
|
{
|
|
Debug.Assert(false, $"deviceIndex {deviceIndex} passed to FireStateChangeNotifications is out of bounds (current length {m_MonitorsPerDevice.Length}).");
|
|
return;
|
|
}
|
|
|
|
ref var signals = ref m_MonitorsPerDevice[deviceIndex].signalled;
|
|
if (signals.AnyBitIsSet() && m_MonitorsPerDevice[deviceIndex].listeners == null)
|
|
{
|
|
Debug.Assert(false, $"A state change for device {deviceIndex} has been set, but list of listeners is null.");
|
|
return;
|
|
}
|
|
|
|
ref var listeners = ref m_MonitorsPerDevice[deviceIndex].listeners;
|
|
var time = internalTime - InputRuntime.s_CurrentTimeOffsetToRealtimeSinceStartup;
|
|
|
|
var tempEvent = new InputEvent(new FourCC('F', 'A', 'K', 'E'), InputEvent.kBaseEventSize, -1, internalTime);
|
|
if (eventPtr == null)
|
|
eventPtr = (InputEvent*)UnsafeUtility.AddressOf(ref tempEvent);
|
|
|
|
var previouslyHandled = eventPtr->handled;
|
|
for (var i = 0; i < signals.length; ++i)
|
|
{
|
|
if (!signals.TestBit(i))
|
|
continue;
|
|
|
|
var listener = listeners[i];
|
|
try
|
|
{
|
|
listener.monitor.NotifyControlStateChanged(listener.control, time, eventPtr, listener.monitorIndex);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Debug.LogError(
|
|
$"Exception '{exception.GetType().Name}' thrown from state change monitor '{(listener.monitor?.GetType().Name ?? "null")}' on '{(listener.control?.ToString() ?? "null")}'");
|
|
Debug.LogException(exception);
|
|
}
|
|
|
|
if (!previouslyHandled && eventPtr->handled)
|
|
{
|
|
var groupIndex = listeners[i].groupIndex;
|
|
if (InputSystem.settings.IsShortcutResolutionUsingActionPriority)
|
|
{
|
|
var handlerPriority = InputActionStateMonitorIndex.FromPacked(listener.monitorIndex).Priority;
|
|
for (var n = i + 1; n < signals.length; ++n)
|
|
{
|
|
if (listeners[n].groupIndex == groupIndex && listeners[n].monitor == listener.monitor)
|
|
{
|
|
var candidatePriority = InputActionStateMonitorIndex.FromPacked(listeners[n].monitorIndex).Priority;
|
|
if (candidatePriority < handlerPriority)
|
|
signals.ClearBit(n);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (var n = i + 1; n < signals.length; ++n)
|
|
{
|
|
if (listeners[n].groupIndex == groupIndex && listeners[n].monitor == listener.monitor)
|
|
signals.ClearBit(n);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (eventPtr->handled)
|
|
eventPtr->handled = previouslyHandled;
|
|
|
|
signals.ClearBit(i);
|
|
}
|
|
}
|
|
|
|
private void ClearMonitorsAndTimeoutsForDevice(InputDevice device)
|
|
{
|
|
if (m_MonitorsPerDevice == null)
|
|
return;
|
|
|
|
var deviceIndex = device.m_DeviceIndex;
|
|
Debug.Assert(deviceIndex != InputDevice.kInvalidDeviceIndex);
|
|
|
|
if (deviceIndex >= m_MonitorsPerDevice.Length)
|
|
return;
|
|
|
|
m_MonitorsPerDevice[deviceIndex].Clear();
|
|
|
|
for (var i = 0; i < m_Timeouts.length; ++i)
|
|
if (m_Timeouts[i].control?.device == device)
|
|
m_Timeouts[i] = default;
|
|
}
|
|
|
|
private struct StateChangeMonitorTimeout
|
|
{
|
|
public InputControl control;
|
|
public double time;
|
|
public IInputStateChangeMonitor monitor;
|
|
public long monitorIndex;
|
|
public int timerIndex;
|
|
}
|
|
|
|
internal struct StateChangeMonitorListener
|
|
{
|
|
public InputControl control;
|
|
public IInputStateChangeMonitor monitor;
|
|
public long monitorIndex;
|
|
public uint groupIndex;
|
|
}
|
|
|
|
internal struct StateChangeMonitorsForDevice
|
|
{
|
|
public MemoryHelpers.BitRegion[] memoryRegions;
|
|
public StateChangeMonitorListener[] listeners;
|
|
public DynamicBitfield signalled;
|
|
public bool needToUpdateOrderingOfMonitors;
|
|
public bool needToCompactArrays;
|
|
|
|
public int count => signalled.length;
|
|
|
|
public void Add(InputControl control, IInputStateChangeMonitor monitor, long monitorIndex, uint groupIndex)
|
|
{
|
|
var listenerCount = signalled.length;
|
|
ArrayHelpers.AppendWithCapacity(ref listeners, ref listenerCount,
|
|
new StateChangeMonitorListener
|
|
{ monitor = monitor, monitorIndex = monitorIndex, groupIndex = groupIndex, control = control });
|
|
|
|
ref var controlStateBlock = ref control.m_StateBlock;
|
|
var memoryRegionCount = signalled.length;
|
|
ArrayHelpers.AppendWithCapacity(ref memoryRegions, ref memoryRegionCount,
|
|
new MemoryHelpers.BitRegion(controlStateBlock.byteOffset - control.device.stateBlock.byteOffset,
|
|
controlStateBlock.bitOffset, controlStateBlock.sizeInBits));
|
|
|
|
signalled.SetLength(signalled.length + 1);
|
|
|
|
needToUpdateOrderingOfMonitors = true;
|
|
}
|
|
|
|
public void Remove(IInputStateChangeMonitor monitor, long monitorIndex, bool deferRemoval)
|
|
{
|
|
if (listeners == null)
|
|
return;
|
|
|
|
for (var i = 0; i < signalled.length; ++i)
|
|
{
|
|
if (ReferenceEquals(listeners[i].monitor, monitor) && listeners[i].monitorIndex == monitorIndex)
|
|
{
|
|
if (deferRemoval)
|
|
{
|
|
listeners[i] = default;
|
|
memoryRegions[i] = default;
|
|
signalled.ClearBit(i);
|
|
needToCompactArrays = true;
|
|
}
|
|
else
|
|
{
|
|
RemoveAt(i);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
listeners.Clear(count);
|
|
signalled.SetLength(0);
|
|
|
|
needToCompactArrays = false;
|
|
}
|
|
|
|
public void CompactArrays()
|
|
{
|
|
for (var i = count - 1; i >= 0; --i)
|
|
{
|
|
if (memoryRegions[i].sizeInBits != 0)
|
|
continue;
|
|
|
|
RemoveAt(i);
|
|
}
|
|
|
|
needToCompactArrays = false;
|
|
}
|
|
|
|
private void RemoveAt(int i)
|
|
{
|
|
var numListeners = count;
|
|
var numMemoryRegions = count;
|
|
listeners.EraseAtWithCapacity(ref numListeners, i);
|
|
memoryRegions.EraseAtWithCapacity(ref numMemoryRegions, i);
|
|
signalled.SetLength(count - 1);
|
|
}
|
|
|
|
public void SortMonitorsByIndex()
|
|
{
|
|
var useActionPriority = InputSystem.settings.IsShortcutResolutionUsingActionPriority;
|
|
for (var i = 1; i < signalled.length; ++i)
|
|
{
|
|
for (var j = i; j > 0; --j)
|
|
{
|
|
if (useActionPriority)
|
|
{
|
|
var firstPriority = InputActionStateMonitorIndex.FromPacked(listeners[j - 1].monitorIndex).Priority;
|
|
var secondPriority = InputActionStateMonitorIndex.FromPacked(listeners[j].monitorIndex).Priority;
|
|
if (firstPriority >= secondPriority)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Sort by complexities only to keep the sort stable
|
|
// i.e. don't reverse the order of controls which have the same complexity
|
|
var firstComplexity = InputActionState.GetComplexityFromMonitorIndex(listeners[j - 1].monitorIndex);
|
|
var secondComplexity = InputActionState.GetComplexityFromMonitorIndex(listeners[j].monitorIndex);
|
|
if (firstComplexity >= secondComplexity)
|
|
break;
|
|
}
|
|
|
|
listeners.SwapElements(j, j - 1);
|
|
memoryRegions.SwapElements(j, j - 1);
|
|
|
|
// We can ignore the `signalled` array here as we call this method only
|
|
// when all monitors are in non-signalled state.
|
|
}
|
|
}
|
|
|
|
needToUpdateOrderingOfMonitors = false;
|
|
}
|
|
}
|
|
}
|
|
}
|