1569 lines
68 KiB
C#
1569 lines
68 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using UnityEngine.InputSystem.Utilities;
|
|
using Unity.Collections;
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|
using UnityEngine.InputSystem.Layouts;
|
|
using UnityEngine.Profiling;
|
|
|
|
namespace UnityEngine.InputSystem.LowLevel
|
|
{
|
|
/// <summary>
|
|
/// InputEventTrace lets you record input events for later processing. It also has features for writing traces
|
|
/// to disk, for loading them from disk, and for playing back previously recorded traces.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// InputEventTrace lets you record input events into a buffer for either a specific device, or for all events
|
|
/// received by the input system. This is useful for testing purposes or for replaying recorded input.
|
|
///
|
|
/// Note that event traces <em>must</em> be disposed of (by calling <see cref="Dispose"/>) after use or they
|
|
/// will leak memory on the unmanaged (C++) memory heap.
|
|
///
|
|
/// Event traces are serializable such that they can survive domain reloads in the editor.
|
|
/// </remarks>
|
|
[Serializable]
|
|
public sealed unsafe class InputEventTrace : IDisposable, IEnumerable<InputEventPtr>
|
|
{
|
|
private const int kDefaultBufferSize = 1024 * 1024;
|
|
|
|
/// <summary>
|
|
/// If <see name="recordFrameMarkers"/> is enabled, an <see cref="InputEvent"/> with this <see cref="FourCC"/>
|
|
/// code in its <see cref="InputEvent.type"/> is recorded whenever the input system starts a new update, i.e.
|
|
/// whenever <see cref="InputSystem.onBeforeUpdate"/> is triggered. This is useful for replaying events in such
|
|
/// a way that they are correctly spaced out over frames.
|
|
/// </summary>
|
|
public static FourCC FrameMarkerEvent => new FourCC('F', 'R', 'M', 'E');
|
|
|
|
/// <summary>
|
|
/// Set device to record events for. Set to <see cref="InputDevice.InvalidDeviceId"/> by default
|
|
/// in which case events from all devices are recorded.
|
|
/// </summary>
|
|
public int deviceId
|
|
{
|
|
get => m_DeviceId;
|
|
set => m_DeviceId = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether the trace is currently recording input.
|
|
/// </summary>
|
|
/// <value>True if the trace is currently recording events.</value>
|
|
/// <seealso cref="Enable"/>
|
|
/// <seealso cref="Disable"/>
|
|
public bool enabled => m_Enabled;
|
|
|
|
/// <summary>
|
|
/// If true, input update boundaries will be recorded as events. By default, this is off.
|
|
/// </summary>
|
|
/// <value>Whether frame boundaries should be recorded in the trace.</value>
|
|
/// <remarks>
|
|
/// When recording with this off, all events are written one after the other for as long
|
|
/// as the recording is active. This means that when a recording runs over multiple frames,
|
|
/// it is no longer possible for the trace to tell which events happened in distinct frames.
|
|
///
|
|
/// By turning this feature on, frame marker events (i.e. <see cref="InputEvent"/> instances
|
|
/// with <see cref="InputEvent.type"/> set to <see cref="FrameMarkerEvent"/>) will be written
|
|
/// to the trace every time an input update occurs. When playing such a trace back via <see
|
|
/// cref="ReplayController.PlayAllFramesOneByOne"/>, events will get spaced out over frames corresponding
|
|
/// to how they were spaced out when input was initially recorded.
|
|
///
|
|
/// Note that having this feature enabled will fill up traces much quicker. Instead of being
|
|
/// filled up only when there is input, TODO
|
|
/// </remarks>
|
|
/// <seealso cref="ReplayController.PlayAllFramesOneByOne"/>
|
|
/// <seealso cref="FrameMarkerEvent"/>
|
|
public bool recordFrameMarkers
|
|
{
|
|
get => m_RecordFrameMarkers;
|
|
set
|
|
{
|
|
if (m_RecordFrameMarkers == value)
|
|
return;
|
|
m_RecordFrameMarkers = value;
|
|
if (m_Enabled)
|
|
{
|
|
if (value)
|
|
InputSystem.onBeforeUpdate += OnBeforeUpdate;
|
|
else
|
|
InputSystem.onBeforeUpdate -= OnBeforeUpdate;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Total number of events currently in the trace.
|
|
/// </summary>
|
|
/// <value>Number of events recorded in the trace.</value>
|
|
public long eventCount => m_EventCount;
|
|
|
|
/// <summary>
|
|
/// The amount of memory consumed by all events combined that are currently
|
|
/// stored in the trace.
|
|
/// </summary>
|
|
/// <value>Total size of event data currently in trace.</value>
|
|
public long totalEventSizeInBytes => m_EventSizeInBytes;
|
|
|
|
/// <summary>
|
|
/// Total size of memory buffer (in bytes) currently allocated.
|
|
/// </summary>
|
|
/// <value>Size of memory currently allocated.</value>
|
|
/// <remarks>
|
|
/// The buffer is allocated on the unmanaged heap.
|
|
/// </remarks>
|
|
public long allocatedSizeInBytes => m_EventBuffer != default ? m_EventBufferSize : 0;
|
|
|
|
/// <summary>
|
|
/// Largest size (in bytes) that the memory buffer is allowed to grow to. By default, this is
|
|
/// the same as <see cref="allocatedSizeInBytes"/> meaning that the buffer is not allowed to grow but will
|
|
/// rather wrap around when full.
|
|
/// </summary>
|
|
/// <value>Largest size the memory buffer is allowed to grow to.</value>
|
|
public long maxSizeInBytes => m_MaxEventBufferSize;
|
|
|
|
/// <summary>
|
|
/// Information about all devices for which events have been recorded in the trace.
|
|
/// </summary>
|
|
/// <value>Record of devices recorded in the trace.</value>
|
|
public ReadOnlyArray<DeviceInfo> deviceInfos => m_DeviceInfos;
|
|
|
|
/// <summary>
|
|
/// Optional delegate to decide whether an input should be stored in a trace. Null by default.
|
|
/// </summary>
|
|
/// <value>Delegate to accept or reject individual events.</value>
|
|
/// <remarks>
|
|
/// When this is set, the callback will be invoked on every event that would otherwise be stored
|
|
/// directly in the trace. If the callback returns <c>true</c>, the trace will continue to record
|
|
/// the event. If the callback returns <c>false</c>, the event will be ignored and not recorded.
|
|
///
|
|
/// The callback should generally mutate the event. If you do so, note that this will impact
|
|
/// event processing in general, not just recording of the event in the trace.
|
|
/// </remarks>
|
|
public Func<InputEventPtr, InputDevice, bool> onFilterEvent
|
|
{
|
|
get => m_OnFilterEvent;
|
|
set => m_OnFilterEvent = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event that is triggered every time an event has been recorded in the trace.
|
|
/// </summary>
|
|
public event Action<InputEventPtr> onEvent
|
|
{
|
|
add => m_EventListeners.AddCallback(value);
|
|
remove => m_EventListeners.RemoveCallback(value);
|
|
}
|
|
|
|
public InputEventTrace(InputDevice device, long bufferSizeInBytes = kDefaultBufferSize, bool growBuffer = false,
|
|
long maxBufferSizeInBytes = -1, long growIncrementSizeInBytes = -1)
|
|
: this(bufferSizeInBytes, growBuffer, maxBufferSizeInBytes, growIncrementSizeInBytes)
|
|
{
|
|
if (device == null)
|
|
throw new ArgumentNullException(nameof(device));
|
|
|
|
m_DeviceId = device.deviceId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a disabled event trace that does not perform any allocation yet. An event trace only starts consuming resources
|
|
/// the first time it is enabled.
|
|
/// </summary>
|
|
/// <param name="bufferSizeInBytes">Size of buffer that will be allocated on first event captured by trace. Defaults to 1MB.</param>
|
|
/// <param name="growBuffer">If true, the event buffer will be grown automatically when it reaches capacity, up to a maximum
|
|
/// size of <paramref name="maxBufferSizeInBytes"/>. This is off by default.</param>
|
|
/// <param name="maxBufferSizeInBytes">If <paramref name="growBuffer"/> is true, this is the maximum size that the buffer should
|
|
/// be grown to. If the maximum size is reached, old events are being overwritten.</param>
|
|
public InputEventTrace(long bufferSizeInBytes = kDefaultBufferSize, bool growBuffer = false, long maxBufferSizeInBytes = -1, long growIncrementSizeInBytes = -1)
|
|
{
|
|
m_EventBufferSize = (uint)bufferSizeInBytes;
|
|
|
|
if (growBuffer)
|
|
{
|
|
if (maxBufferSizeInBytes < 0)
|
|
m_MaxEventBufferSize = 256 * kDefaultBufferSize;
|
|
else
|
|
m_MaxEventBufferSize = maxBufferSizeInBytes;
|
|
|
|
if (growIncrementSizeInBytes < 0)
|
|
m_GrowIncrementSize = kDefaultBufferSize;
|
|
else
|
|
m_GrowIncrementSize = growIncrementSizeInBytes;
|
|
}
|
|
else
|
|
{
|
|
m_MaxEventBufferSize = m_EventBufferSize;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write the contents of the event trace to a file.
|
|
/// </summary>
|
|
/// <param name="filePath">Path of the file to write.</param>
|
|
/// <exception cref="ArgumentNullException"><paramref name="filePath"/> is <c>null</c> or empty.</exception>
|
|
/// <exception cref="FileNotFoundException"><paramref name="filePath"/> is invalid.</exception>
|
|
/// <exception cref="DirectoryNotFoundException">A directory in <paramref name="filePath"/> is invalid.</exception>
|
|
/// <exception cref="UnauthorizedAccessException"><paramref name="filePath"/> cannot be accessed.</exception>
|
|
/// <seealso cref="ReadFrom(string)"/>
|
|
public void WriteTo(string filePath)
|
|
{
|
|
if (string.IsNullOrEmpty(filePath))
|
|
throw new ArgumentNullException(nameof(filePath));
|
|
|
|
using (var stream = File.OpenWrite(filePath))
|
|
WriteTo(stream);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write the contents of the event trace to the given stream.
|
|
/// </summary>
|
|
/// <param name="stream">Stream to write the data to. Must support seeking (i.e. <c>Stream.canSeek</c> must be true).</param>
|
|
/// <exception cref="ArgumentNullException"><paramref name="stream"/> is <c>null</c>.</exception>
|
|
/// <exception cref="ArgumentException"><paramref name="stream"/> does not support seeking.</exception>
|
|
/// <exception cref="IOException">An error occurred trying to write to <paramref name="stream"/>.</exception>
|
|
public void WriteTo(Stream stream)
|
|
{
|
|
if (stream == null)
|
|
throw new ArgumentNullException(nameof(stream));
|
|
if (!stream.CanSeek)
|
|
throw new ArgumentException("Stream does not support seeking", nameof(stream));
|
|
|
|
var writer = new BinaryWriter(stream);
|
|
|
|
var flags = default(FileFlags);
|
|
if (InputSystem.settings.updateMode == InputSettings.UpdateMode.ProcessEventsInFixedUpdate)
|
|
flags |= FileFlags.FixedUpdate;
|
|
|
|
// Write header.
|
|
writer.Write(kFileFormat);
|
|
writer.Write(kFileVersion);
|
|
writer.Write((int)flags);
|
|
writer.Write((int)Application.platform);
|
|
writer.Write((ulong)m_EventCount);
|
|
writer.Write((ulong)m_EventSizeInBytes);
|
|
|
|
// Write events.
|
|
foreach (var eventPtr in this)
|
|
{
|
|
////TODO: find way to directly write a byte* buffer to the stream instead of copying to a temp byte[]
|
|
|
|
var sizeInBytes = eventPtr.sizeInBytes;
|
|
var buffer = new byte[sizeInBytes];
|
|
fixed(byte* bufferPtr = buffer)
|
|
{
|
|
UnsafeUtility.MemCpy(bufferPtr, eventPtr.data, sizeInBytes);
|
|
writer.Write(buffer);
|
|
}
|
|
}
|
|
|
|
// Write devices.
|
|
writer.Flush();
|
|
var positionOfDeviceList = stream.Position;
|
|
var deviceCount = m_DeviceInfos.LengthSafe();
|
|
writer.Write(deviceCount);
|
|
for (var i = 0; i < deviceCount; ++i)
|
|
{
|
|
ref var device = ref m_DeviceInfos[i];
|
|
writer.Write(device.deviceId);
|
|
writer.Write(device.layout);
|
|
writer.Write(device.stateFormat);
|
|
writer.Write(device.stateSizeInBytes);
|
|
writer.Write(device.m_FullLayoutJson ?? string.Empty);
|
|
}
|
|
|
|
// Write offset of device list.
|
|
writer.Flush();
|
|
var offsetOfDeviceList = stream.Position - positionOfDeviceList;
|
|
writer.Write(offsetOfDeviceList);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the contents of an input event trace stored in the given file.
|
|
/// </summary>
|
|
/// <param name="filePath">Path to a file.</param>
|
|
/// <exception cref="ArgumentNullException"><paramref name="filePath"/> is <c>null</c> or empty.</exception>
|
|
/// <exception cref="FileNotFoundException"><paramref name="filePath"/> is invalid.</exception>
|
|
/// <exception cref="DirectoryNotFoundException">A directory in <paramref name="filePath"/> is invalid.</exception>
|
|
/// <exception cref="UnauthorizedAccessException"><paramref name="filePath"/> cannot be accessed.</exception>
|
|
/// <remarks>
|
|
/// This method replaces the contents of the trace with those read from the given file.
|
|
/// </remarks>
|
|
/// <seealso cref="WriteTo(string)"/>
|
|
public void ReadFrom(string filePath)
|
|
{
|
|
if (string.IsNullOrEmpty(filePath))
|
|
throw new ArgumentNullException(nameof(filePath));
|
|
|
|
using (var stream = File.OpenRead(filePath))
|
|
ReadFrom(stream);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the contents of an input event trace from the given stream.
|
|
/// </summary>
|
|
/// <param name="stream">A stream of binary data containing a recorded event trace as written out with <see cref="WriteTo(Stream)"/>.
|
|
/// Must support reading.</param>
|
|
/// <exception cref="ArgumentNullException"><paramref name="stream"/> is <c>null</c>.</exception>
|
|
/// <exception cref="ArgumentException"><paramref name="stream"/> does not support reading.</exception>
|
|
/// <exception cref="IOException">An error occurred trying to read from <paramref name="stream"/>.</exception>
|
|
/// <remarks>
|
|
/// This method replaces the contents of the event trace with those read from the stream. It does not append
|
|
/// to the existing trace.
|
|
/// </remarks>
|
|
/// <seealso cref="WriteTo(Stream)"/>
|
|
public void ReadFrom(Stream stream)
|
|
{
|
|
if (stream == null)
|
|
throw new ArgumentNullException(nameof(stream));
|
|
if (!stream.CanRead)
|
|
throw new ArgumentException("Stream does not support reading", nameof(stream));
|
|
|
|
var reader = new BinaryReader(stream);
|
|
|
|
// Read header.
|
|
if (reader.ReadInt32() != kFileFormat)
|
|
throw new IOException($"Stream does not appear to be an InputEventTrace (no '{kFileFormat}' code)");
|
|
if (reader.ReadInt32() > kFileVersion)
|
|
throw new IOException($"Stream is an InputEventTrace but a newer version (expected version {kFileVersion} or below)");
|
|
reader.ReadInt32(); // Flags; ignored for now.
|
|
reader.ReadInt32(); // Platform; for now we're not doing anything with it.
|
|
var eventCount = reader.ReadUInt64();
|
|
var totalEventSizeInBytes = reader.ReadUInt64();
|
|
var oldBuffer = m_EventBuffer;
|
|
|
|
if (eventCount > 0 && totalEventSizeInBytes > 0)
|
|
{
|
|
// Allocate buffer, if need be.
|
|
byte* buffer;
|
|
if (m_EventBuffer != null && m_EventBufferSize >= (long)totalEventSizeInBytes)
|
|
{
|
|
// Existing buffer is large enough.
|
|
buffer = m_EventBuffer;
|
|
}
|
|
else
|
|
{
|
|
buffer = (byte*)UnsafeUtility.Malloc((long)totalEventSizeInBytes, InputEvent.kAlignment, Allocator.Persistent);
|
|
m_EventBufferSize = (long)totalEventSizeInBytes;
|
|
}
|
|
try
|
|
{
|
|
// Read events.
|
|
var tailPtr = buffer;
|
|
var endPtr = tailPtr + totalEventSizeInBytes;
|
|
var totalEventSize = 0L;
|
|
for (var i = 0ul; i < eventCount; ++i)
|
|
{
|
|
var eventType = reader.ReadInt32();
|
|
var eventSizeInBytes = (uint)reader.ReadUInt16();
|
|
var eventDeviceId = (uint)reader.ReadUInt16();
|
|
|
|
if (eventSizeInBytes > endPtr - tailPtr)
|
|
break;
|
|
|
|
*(int*)tailPtr = eventType;
|
|
tailPtr += 4;
|
|
*(ushort*)tailPtr = (ushort)eventSizeInBytes;
|
|
tailPtr += 2;
|
|
*(ushort*)tailPtr = (ushort)eventDeviceId;
|
|
tailPtr += 2;
|
|
|
|
////TODO: find way to directly read from stream into a byte* pointer
|
|
var remainingSize = (int)eventSizeInBytes - sizeof(int) - sizeof(short) - sizeof(short);
|
|
var tempBuffer = reader.ReadBytes(remainingSize);
|
|
fixed(byte* tempBufferPtr = tempBuffer)
|
|
UnsafeUtility.MemCpy(tailPtr, tempBufferPtr, remainingSize);
|
|
|
|
tailPtr += remainingSize.AlignToMultipleOf(InputEvent.kAlignment);
|
|
totalEventSize += eventSizeInBytes.AlignToMultipleOf(InputEvent.kAlignment);
|
|
|
|
if (tailPtr >= endPtr)
|
|
break;
|
|
}
|
|
|
|
// Read device infos.
|
|
var deviceCount = reader.ReadInt32();
|
|
var deviceInfos = new DeviceInfo[deviceCount];
|
|
for (var i = 0; i < deviceCount; ++i)
|
|
{
|
|
deviceInfos[i] = new DeviceInfo
|
|
{
|
|
deviceId = reader.ReadInt32(),
|
|
layout = reader.ReadString(),
|
|
stateFormat = reader.ReadInt32(),
|
|
stateSizeInBytes = reader.ReadInt32(),
|
|
m_FullLayoutJson = reader.ReadString()
|
|
};
|
|
}
|
|
|
|
// Install buffer.
|
|
m_EventBuffer = buffer;
|
|
m_EventBufferHead = m_EventBuffer;
|
|
m_EventBufferTail = endPtr;
|
|
m_EventCount = (long)eventCount;
|
|
m_EventSizeInBytes = totalEventSize;
|
|
m_DeviceInfos = deviceInfos;
|
|
}
|
|
catch
|
|
{
|
|
if (buffer != oldBuffer)
|
|
UnsafeUtility.Free(buffer, Allocator.Persistent);
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_EventBuffer = default;
|
|
m_EventBufferHead = default;
|
|
m_EventBufferTail = default;
|
|
}
|
|
|
|
// Release old buffer, if we've switched to a new one.
|
|
if (m_EventBuffer != oldBuffer && oldBuffer != null)
|
|
UnsafeUtility.Free(oldBuffer, Allocator.Persistent);
|
|
|
|
++m_ChangeCounter;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load an input event trace from the given file.
|
|
/// </summary>
|
|
/// <param name="filePath">Path to a file.</param>
|
|
/// <exception cref="ArgumentNullException"><paramref name="filePath"/> is <c>null</c> or empty.</exception>
|
|
/// <exception cref="FileNotFoundException"><paramref name="filePath"/> is invalid.</exception>
|
|
/// <exception cref="DirectoryNotFoundException">A directory in <paramref name="filePath"/> is invalid.</exception>
|
|
/// <exception cref="UnauthorizedAccessException"><paramref name="filePath"/> cannot be accessed.</exception>
|
|
/// <seealso cref="WriteTo(string)"/>
|
|
/// <seealso cref="ReadFrom(string)"/>
|
|
public static InputEventTrace LoadFrom(string filePath)
|
|
{
|
|
if (string.IsNullOrEmpty(filePath))
|
|
throw new ArgumentNullException(nameof(filePath));
|
|
|
|
using (var stream = File.OpenRead(filePath))
|
|
return LoadFrom(stream);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load an event trace from a previously captured event stream.
|
|
/// </summary>
|
|
/// <param name="stream">A stream as written by <see cref="WriteTo(Stream)"/>. Must support reading.</param>
|
|
/// <returns>The loaded event trace.</returns>
|
|
/// <exception cref="ArgumentException"><paramref name="stream"/> is not readable.</exception>
|
|
/// <exception cref="ArgumentNullException"><paramref name="stream"/> is <c>null</c>.</exception>
|
|
/// <exception cref="IOException">The stream cannot be loaded (e.g. wrong format; details in the exception).</exception>
|
|
/// <seealso cref="WriteTo(Stream)"/>
|
|
public static InputEventTrace LoadFrom(Stream stream)
|
|
{
|
|
if (stream == null)
|
|
throw new ArgumentNullException(nameof(stream));
|
|
if (!stream.CanRead)
|
|
throw new ArgumentException("Stream must be readable", nameof(stream));
|
|
|
|
var trace = new InputEventTrace();
|
|
trace.ReadFrom(stream);
|
|
|
|
return trace;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start a replay of the events in the trace.
|
|
/// </summary>
|
|
/// <returns>An object that controls playback.</returns>
|
|
/// <remarks>
|
|
/// Calling this method implicitly turns off recording, if currently enabled (i.e. it calls <see cref="Disable"/>),
|
|
/// as replaying an event trace cannot be done while it is also concurrently modified.
|
|
/// </remarks>
|
|
public ReplayController Replay()
|
|
{
|
|
Disable();
|
|
return new ReplayController(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resize the current event memory buffer to the specified size.
|
|
/// </summary>
|
|
/// <param name="newBufferSize">Size to allocate for the buffer.</param>
|
|
/// <param name="newMaxBufferSize">Optional parameter to specifying the mark up to which the buffer is allowed to grow. By default,
|
|
/// this is negative which indicates the buffer should not grow. In this case, <see cref="maxSizeInBytes"/> will be set
|
|
/// to <paramref name="newBufferSize"/>. If this parameter is a non-negative number, it must be greater than or equal to
|
|
/// <paramref name="newBufferSize"/> and will become the new value for <see cref="maxSizeInBytes"/>.</param>
|
|
/// <returns>True if the new buffer was successfully allocated.</returns>
|
|
/// <exception cref="ArgumentException"><paramref name="newBufferSize"/> is negative.</exception>
|
|
public bool Resize(long newBufferSize, long newMaxBufferSize = -1)
|
|
{
|
|
if (newBufferSize <= 0)
|
|
throw new ArgumentException("Size must be positive", nameof(newBufferSize));
|
|
|
|
if (m_EventBufferSize == newBufferSize)
|
|
return true;
|
|
|
|
if (newMaxBufferSize < newBufferSize)
|
|
newMaxBufferSize = newBufferSize;
|
|
|
|
// Allocate.
|
|
var newEventBuffer = (byte*)UnsafeUtility.Malloc(newBufferSize, InputEvent.kAlignment, Allocator.Persistent);
|
|
if (newEventBuffer == default)
|
|
return false;
|
|
|
|
// If we have existing contents, migrate them.
|
|
if (m_EventCount > 0)
|
|
{
|
|
// If we're shrinking the buffer or have a buffer that has already wrapped around,
|
|
// migrate events one by one.
|
|
if (newBufferSize < m_EventBufferSize || m_HasWrapped)
|
|
{
|
|
var fromPtr = new InputEventPtr((InputEvent*)m_EventBufferHead);
|
|
var toPtr = (InputEvent*)newEventBuffer;
|
|
var newEventCount = 0;
|
|
var newEventSizeInBytes = 0;
|
|
var remainingEventBytes = m_EventSizeInBytes;
|
|
|
|
for (var i = 0; i < m_EventCount; ++i)
|
|
{
|
|
var eventSizeInBytes = fromPtr.sizeInBytes;
|
|
var alignedEventSizeInBytes = eventSizeInBytes.AlignToMultipleOf(InputEvent.kAlignment);
|
|
|
|
// We only start copying once we know that the remaining events we have fit in the new buffer.
|
|
// This way we get the newest events and not the oldest ones.
|
|
if (remainingEventBytes <= newBufferSize)
|
|
{
|
|
UnsafeUtility.MemCpy(toPtr, fromPtr.ToPointer(), eventSizeInBytes);
|
|
toPtr = InputEvent.GetNextInMemory(toPtr);
|
|
newEventSizeInBytes += (int)alignedEventSizeInBytes;
|
|
++newEventCount;
|
|
}
|
|
|
|
remainingEventBytes -= alignedEventSizeInBytes;
|
|
if (!GetNextEvent(ref fromPtr))
|
|
break;
|
|
}
|
|
|
|
m_HasWrapped = false;
|
|
m_EventCount = newEventCount;
|
|
m_EventSizeInBytes = newEventSizeInBytes;
|
|
}
|
|
else
|
|
{
|
|
// Simple case of just having to copy everything between head and tail.
|
|
UnsafeUtility.MemCpy(newEventBuffer,
|
|
m_EventBufferHead,
|
|
m_EventSizeInBytes);
|
|
}
|
|
}
|
|
|
|
if (m_EventBuffer != null)
|
|
UnsafeUtility.Free(m_EventBuffer, Allocator.Persistent);
|
|
|
|
m_EventBufferSize = newBufferSize;
|
|
m_EventBuffer = newEventBuffer;
|
|
m_EventBufferHead = newEventBuffer;
|
|
m_EventBufferTail = m_EventBuffer + m_EventSizeInBytes;
|
|
m_MaxEventBufferSize = newMaxBufferSize;
|
|
|
|
++m_ChangeCounter;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset the trace. Clears all recorded events.
|
|
/// </summary>
|
|
public void Clear()
|
|
{
|
|
m_EventBufferHead = m_EventBufferTail = default;
|
|
m_EventCount = 0;
|
|
m_EventSizeInBytes = 0;
|
|
++m_ChangeCounter;
|
|
m_DeviceInfos = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start recording events.
|
|
/// </summary>
|
|
/// <seealso cref="Disable"/>
|
|
public void Enable()
|
|
{
|
|
if (m_Enabled)
|
|
return;
|
|
|
|
if (m_EventBuffer == default)
|
|
Allocate();
|
|
|
|
InputSystem.onEvent += OnInputEvent;
|
|
if (m_RecordFrameMarkers)
|
|
InputSystem.onBeforeUpdate += OnBeforeUpdate;
|
|
|
|
m_Enabled = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop recording events.
|
|
/// </summary>
|
|
/// <seealso cref="Enable"/>
|
|
public void Disable()
|
|
{
|
|
if (!m_Enabled)
|
|
return;
|
|
|
|
InputSystem.onEvent -= OnInputEvent;
|
|
InputSystem.onBeforeUpdate -= OnBeforeUpdate;
|
|
|
|
m_Enabled = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Based on the given event pointer, return a pointer to the next event in the trace.
|
|
/// </summary>
|
|
/// <param name="current">A pointer to an event in the trace or a <c>default(InputEventTrace)</c>. In the former case,
|
|
/// the pointer will be updated to the next event, if there is one. In the latter case, the pointer will be updated
|
|
/// to the first event in the trace, if there is one.</param>
|
|
/// <returns>True if <c>current</c> has been set to the next event, false otherwise.</returns>
|
|
/// <remarks>
|
|
/// Event storage in memory may be circular if the event buffer is fixed in size or has reached maximum
|
|
/// size and new events start overwriting old events. This method will automatically start with the first
|
|
/// event when the given <paramref name="current"/> event is null. Any subsequent call with then loop over
|
|
/// the remaining events until no more events are available.
|
|
///
|
|
/// Note that it is VERY IMPORTANT that the buffer is not modified while iterating over events this way.
|
|
/// If this is not ensured, invalid memory accesses may result.
|
|
///
|
|
/// <example>
|
|
/// <code>
|
|
/// // Loop over all events in the InputEventTrace in the `trace` variable.
|
|
/// var current = default(InputEventPtr);
|
|
/// while (trace.GetNextEvent(ref current))
|
|
/// {
|
|
/// Debug.Log(current);
|
|
/// }
|
|
/// </code>
|
|
/// </example>
|
|
/// </remarks>
|
|
public bool GetNextEvent(ref InputEventPtr current)
|
|
{
|
|
if (m_EventBuffer == default)
|
|
return false;
|
|
|
|
// If head is null, tail is too and it means there's nothing in the
|
|
// buffer yet.
|
|
if (m_EventBufferHead == default)
|
|
return false;
|
|
|
|
// If current is null, start iterating at head.
|
|
if (!current.valid)
|
|
{
|
|
current = new InputEventPtr((InputEvent*)m_EventBufferHead);
|
|
return true;
|
|
}
|
|
|
|
// Otherwise feel our way forward.
|
|
|
|
var nextEvent = (byte*)current.Next().data;
|
|
var endOfBuffer = m_EventBuffer + m_EventBufferSize;
|
|
|
|
// If we've run into our tail, there's no more events.
|
|
if (nextEvent == m_EventBufferTail)
|
|
return false;
|
|
|
|
// If we've reached blank space at the end of the buffer, wrap
|
|
// around to the beginning. In this scenario there must be an event
|
|
// at the beginning of the buffer; tail won't position itself at
|
|
// m_EventBuffer.
|
|
if (endOfBuffer - nextEvent < InputEvent.kBaseEventSize ||
|
|
((InputEvent*)nextEvent)->sizeInBytes == 0)
|
|
{
|
|
nextEvent = m_EventBuffer;
|
|
if (nextEvent == current.ToPointer())
|
|
return false; // There's only a single event in the buffer.
|
|
}
|
|
|
|
// We're good. There's still space between us and our tail.
|
|
current = new InputEventPtr((InputEvent*)nextEvent);
|
|
return true;
|
|
}
|
|
|
|
public IEnumerator<InputEventPtr> GetEnumerator()
|
|
{
|
|
return new Enumerator(this);
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop recording, if necessary, and clear the trace such that it released unmanaged
|
|
/// memory which might be allocated.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// For any trace that has recorded events, calling this method is crucial in order to not
|
|
/// leak memory on the unmanaged (C++) memory heap.
|
|
/// </remarks>
|
|
public void Dispose()
|
|
{
|
|
Disable();
|
|
Release();
|
|
}
|
|
|
|
// We want to make sure that it's not possible to iterate with an enumerable over
|
|
// a trace that is being changed so we bump this counter every time we modify the
|
|
// buffer and check in the enumerator that the counts match.
|
|
[NonSerialized] private int m_ChangeCounter;
|
|
[NonSerialized] private bool m_Enabled;
|
|
[NonSerialized] private Func<InputEventPtr, InputDevice, bool> m_OnFilterEvent;
|
|
|
|
[SerializeField] private int m_DeviceId = InputDevice.InvalidDeviceId;
|
|
[NonSerialized] private CallbackArray<Action<InputEventPtr>> m_EventListeners;
|
|
|
|
// Buffer for storing event trace. Allocated in native so that we can survive a
|
|
// domain reload without losing event traces.
|
|
// NOTE: Ideally this would simply use InputEventBuffer but we can't serialize that one because
|
|
// of the NativeArray it has inside. Also, due to the wrap-around nature, storage of
|
|
// events in the buffer may not be linear.
|
|
[SerializeField] private long m_EventBufferSize;
|
|
[SerializeField] private long m_MaxEventBufferSize;
|
|
[SerializeField] private long m_GrowIncrementSize;
|
|
[SerializeField] private long m_EventCount;
|
|
[SerializeField] private long m_EventSizeInBytes;
|
|
// These are ulongs for the sake of Unity serialization which can't handle pointers or IntPtrs.
|
|
[SerializeField] private ulong m_EventBufferStorage;
|
|
[SerializeField] private ulong m_EventBufferHeadStorage;
|
|
[SerializeField] private ulong m_EventBufferTailStorage;
|
|
[SerializeField] private bool m_HasWrapped;
|
|
[SerializeField] private bool m_RecordFrameMarkers;
|
|
[SerializeField] private DeviceInfo[] m_DeviceInfos;
|
|
|
|
private byte* m_EventBuffer
|
|
{
|
|
get => (byte*)m_EventBufferStorage;
|
|
set => m_EventBufferStorage = (ulong)value;
|
|
}
|
|
|
|
private byte* m_EventBufferHead
|
|
{
|
|
get => (byte*)m_EventBufferHeadStorage;
|
|
set => m_EventBufferHeadStorage = (ulong)value;
|
|
}
|
|
|
|
private byte* m_EventBufferTail
|
|
{
|
|
get => (byte*)m_EventBufferTailStorage;
|
|
set => m_EventBufferTailStorage = (ulong)value;
|
|
}
|
|
|
|
private void Allocate()
|
|
{
|
|
m_EventBuffer = (byte*)UnsafeUtility.Malloc(m_EventBufferSize, InputEvent.kAlignment, Allocator.Persistent);
|
|
}
|
|
|
|
private void Release()
|
|
{
|
|
Clear();
|
|
|
|
if (m_EventBuffer != default)
|
|
{
|
|
UnsafeUtility.Free(m_EventBuffer, Allocator.Persistent);
|
|
m_EventBuffer = default;
|
|
}
|
|
}
|
|
|
|
private void OnBeforeUpdate()
|
|
{
|
|
////TODO: make this work correctly with the different update types
|
|
|
|
if (m_RecordFrameMarkers)
|
|
{
|
|
// Record frame marker event.
|
|
// NOTE: ATM these events don't get valid event IDs. Might be this is even useful but is more a side-effect
|
|
// of there not being a method to obtain an ID except by actually queuing an event.
|
|
var frameMarkerEvent = new InputEvent
|
|
{
|
|
type = FrameMarkerEvent,
|
|
internalTime = InputRuntime.s_Instance.currentTime,
|
|
sizeInBytes = (uint)UnsafeUtility.SizeOf<InputEvent>()
|
|
};
|
|
|
|
OnInputEvent(new InputEventPtr((InputEvent*)UnsafeUtility.AddressOf(ref frameMarkerEvent)), null);
|
|
}
|
|
}
|
|
|
|
private void OnInputEvent(InputEventPtr inputEvent, InputDevice device)
|
|
{
|
|
// Ignore events that are already marked as handled.
|
|
if (inputEvent.handled)
|
|
return;
|
|
|
|
// Ignore if the event isn't for our device (except if it's a frame marker).
|
|
if (m_DeviceId != InputDevice.InvalidDeviceId && inputEvent.deviceId != m_DeviceId && inputEvent.type != FrameMarkerEvent)
|
|
return;
|
|
|
|
// Give callback a chance to filter event.
|
|
if (m_OnFilterEvent != null && !m_OnFilterEvent(inputEvent, device))
|
|
return;
|
|
|
|
// This shouldn't happen but ignore the event if we're not tracing.
|
|
if (m_EventBuffer == default)
|
|
return;
|
|
|
|
var bytesNeeded = inputEvent.sizeInBytes.AlignToMultipleOf(InputEvent.kAlignment);
|
|
|
|
// Make sure we can fit the event at all.
|
|
if (bytesNeeded > m_MaxEventBufferSize)
|
|
return;
|
|
|
|
Profiler.BeginSample("InputEventTrace");
|
|
|
|
if (m_EventBufferTail == default)
|
|
{
|
|
// First event in buffer.
|
|
m_EventBufferHead = m_EventBuffer;
|
|
m_EventBufferTail = m_EventBuffer;
|
|
}
|
|
|
|
var newTail = m_EventBufferTail + bytesNeeded;
|
|
var newTailOvertakesHead = newTail > m_EventBufferHead && m_EventBufferHead != m_EventBuffer;
|
|
|
|
// If tail goes out of bounds, enlarge the buffer or wrap around to the beginning.
|
|
var newTailGoesPastEndOfBuffer = newTail > m_EventBuffer + m_EventBufferSize;
|
|
if (newTailGoesPastEndOfBuffer)
|
|
{
|
|
// If we haven't reached the max size yet, grow the buffer.
|
|
if (m_EventBufferSize < m_MaxEventBufferSize && !m_HasWrapped)
|
|
{
|
|
var increment = Math.Max(m_GrowIncrementSize, bytesNeeded.AlignToMultipleOf(InputEvent.kAlignment));
|
|
var newBufferSize = m_EventBufferSize + increment;
|
|
if (newBufferSize > m_MaxEventBufferSize)
|
|
newBufferSize = m_MaxEventBufferSize;
|
|
|
|
if (newBufferSize < bytesNeeded)
|
|
return;
|
|
|
|
Resize(newBufferSize);
|
|
|
|
newTail = m_EventBufferTail + bytesNeeded;
|
|
}
|
|
|
|
// See if we fit.
|
|
var spaceLeft = m_EventBufferSize - (m_EventBufferTail - m_EventBuffer);
|
|
if (spaceLeft < bytesNeeded)
|
|
{
|
|
// No, so wrap around.
|
|
m_HasWrapped = true;
|
|
|
|
// Make sure head isn't trying to advance into gap we may be leaving at the end of the
|
|
// buffer by wiping the space if it could fit an event.
|
|
if (spaceLeft >= InputEvent.kBaseEventSize)
|
|
UnsafeUtility.MemClear(m_EventBufferTail, InputEvent.kBaseEventSize);
|
|
|
|
m_EventBufferTail = m_EventBuffer;
|
|
newTail = m_EventBuffer + bytesNeeded;
|
|
|
|
// If the tail overtook both the head and the end of the buffer,
|
|
// we need to make sure the head is wrapped around as well.
|
|
if (newTailOvertakesHead)
|
|
m_EventBufferHead = m_EventBuffer;
|
|
|
|
// Recheck whether we're overtaking head.
|
|
newTailOvertakesHead = newTail > m_EventBufferHead;
|
|
}
|
|
}
|
|
|
|
// If the new tail runs into head, bump head as many times as we need to
|
|
// make room for the event. Head may itself wrap around here.
|
|
if (newTailOvertakesHead)
|
|
{
|
|
var newHead = m_EventBufferHead;
|
|
var endOfBufferMinusOneEvent =
|
|
m_EventBuffer + m_EventBufferSize - InputEvent.kBaseEventSize;
|
|
|
|
while (newHead < newTail)
|
|
{
|
|
var numBytes = ((InputEvent*)newHead)->sizeInBytes;
|
|
newHead += numBytes;
|
|
--m_EventCount;
|
|
m_EventSizeInBytes -= numBytes;
|
|
if (newHead > endOfBufferMinusOneEvent || ((InputEvent*)newHead)->sizeInBytes == 0)
|
|
{
|
|
newHead = m_EventBuffer;
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_EventBufferHead = newHead;
|
|
}
|
|
|
|
var buffer = m_EventBufferTail;
|
|
m_EventBufferTail = newTail;
|
|
|
|
// Copy data to buffer.
|
|
UnsafeUtility.MemCpy(buffer, inputEvent.data, inputEvent.sizeInBytes);
|
|
++m_ChangeCounter;
|
|
++m_EventCount;
|
|
m_EventSizeInBytes += bytesNeeded;
|
|
|
|
// Make sure we have a record for the device.
|
|
if (device != null)
|
|
{
|
|
var haveRecord = false;
|
|
if (m_DeviceInfos != null)
|
|
for (var i = 0; i < m_DeviceInfos.Length; ++i)
|
|
if (m_DeviceInfos[i].deviceId == device.deviceId)
|
|
{
|
|
haveRecord = true;
|
|
break;
|
|
}
|
|
if (!haveRecord)
|
|
ArrayHelpers.Append(ref m_DeviceInfos, new DeviceInfo
|
|
{
|
|
m_DeviceId = device.deviceId,
|
|
m_Layout = device.layout,
|
|
m_StateFormat = device.stateBlock.format,
|
|
m_StateSizeInBytes = (int)device.stateBlock.alignedSizeInBytes,
|
|
|
|
// If it's a generated layout, store the full layout JSON in the device info. We do this so that
|
|
// when saving traces for this kind of input, we can recreate the device.
|
|
m_FullLayoutJson = InputControlLayout.s_Layouts.IsGeneratedLayout(device.m_Layout)
|
|
? InputSystem.LoadLayout(device.layout).ToJson()
|
|
: null
|
|
});
|
|
}
|
|
|
|
// Notify listeners.
|
|
if (m_EventListeners.length > 0)
|
|
DelegateHelpers.InvokeCallbacksSafe(ref m_EventListeners, new InputEventPtr((InputEvent*)buffer),
|
|
"InputEventTrace.onEvent");
|
|
|
|
Profiler.EndSample();
|
|
}
|
|
|
|
private class Enumerator : IEnumerator<InputEventPtr>
|
|
{
|
|
private InputEventTrace m_Trace;
|
|
private int m_ChangeCounter;
|
|
internal InputEventPtr m_Current;
|
|
|
|
public Enumerator(InputEventTrace trace)
|
|
{
|
|
m_Trace = trace;
|
|
m_ChangeCounter = trace.m_ChangeCounter;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
m_Trace = null;
|
|
m_Current = new InputEventPtr();
|
|
}
|
|
|
|
public bool MoveNext()
|
|
{
|
|
if (m_Trace == null)
|
|
throw new ObjectDisposedException(ToString());
|
|
if (m_Trace.m_ChangeCounter != m_ChangeCounter)
|
|
throw new InvalidOperationException("Trace has been modified while enumerating!");
|
|
|
|
return m_Trace.GetNextEvent(ref m_Current);
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
m_Current = default;
|
|
m_ChangeCounter = m_Trace.m_ChangeCounter;
|
|
}
|
|
|
|
public InputEventPtr Current => m_Current;
|
|
object IEnumerator.Current => Current;
|
|
}
|
|
|
|
private static FourCC kFileFormat => new FourCC('I', 'E', 'V', 'T');
|
|
private static int kFileVersion = 1;
|
|
|
|
[Flags]
|
|
private enum FileFlags
|
|
{
|
|
FixedUpdate = 1 << 0, // Events were recorded with system being in fixed-update mode.
|
|
}
|
|
|
|
/// <summary>
|
|
/// Controls replaying of events recorded in an <see cref="InputEventTrace"/>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Playback can be controlled either on a per-event or a per-frame basis. Note that playing back events
|
|
/// frame by frame requires frame markers to be present in the trace (see <see cref="recordFrameMarkers"/>).
|
|
///
|
|
/// By default, events will be queued as is except for their timestamps which will be set to the current
|
|
/// time that each event is queued at.
|
|
///
|
|
/// What this means is that events replay with the same device ID (see <see cref="InputEvent.deviceId"/>)
|
|
/// they were captured on. If the trace is replayed in the same session that it was recorded in, this means
|
|
/// that the events will replay on the same device (if it still exists).
|
|
///
|
|
/// To map recorded events to a different device, you can either call <see cref="WithDeviceMappedFromTo(int,int)"/> to
|
|
/// map an arbitrary device ID to a new one or call <see cref="WithAllDevicesMappedToNewInstances"/> to create
|
|
/// new (temporary) devices for the duration of playback.
|
|
///
|
|
/// <example>
|
|
/// <code>
|
|
/// var trace = new InputEventTrace(myDevice);
|
|
/// trace.Enable();
|
|
///
|
|
/// // ... run one or more frames ...
|
|
///
|
|
/// trace.Replay().OneFrame();
|
|
/// </code>
|
|
/// </example>
|
|
/// </remarks>
|
|
/// <seealso cref="InputEventTrace.Replay"/>
|
|
public class ReplayController : IDisposable
|
|
{
|
|
/// <summary>
|
|
/// The event trace associated with the replay controller.
|
|
/// </summary>
|
|
/// <value>Trace from which events are replayed.</value>
|
|
public InputEventTrace trace => m_EventTrace;
|
|
|
|
/// <summary>
|
|
/// Whether replay has finished.
|
|
/// </summary>
|
|
/// <value>True if replay has finished or is not in progress.</value>
|
|
/// <seealso cref="PlayAllFramesOneByOne"/>
|
|
/// <seealso cref="PlayAllEvents"/>
|
|
public bool finished { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Whether replay is paused.
|
|
/// </summary>
|
|
/// <value>True if replay is currently paused.</value>
|
|
public bool paused { get; set; }
|
|
|
|
/// <summary>
|
|
/// Current position in the event stream.
|
|
/// </summary>
|
|
/// <value>Index of current event in trace.</value>
|
|
public int position { get; private set; }
|
|
|
|
/// <summary>
|
|
/// List of devices created by the replay controller.
|
|
/// </summary>
|
|
/// <value>Devices created by the replay controller.</value>
|
|
/// <remarks>
|
|
/// By default, a replay controller will queue events as is, i.e. with <see cref="InputEvent.deviceId"/> of
|
|
/// each event left as is. This means that the events will target existing devices (if any) that have the
|
|
/// respective ID.
|
|
///
|
|
/// Using <see cref="WithAllDevicesMappedToNewInstances"/>, a replay controller can be instructed to create
|
|
/// new, temporary devices instead for each unique <see cref="InputEvent.deviceId"/> encountered in the stream.
|
|
/// All devices created by the controller this way will be put on this list.
|
|
/// </remarks>
|
|
/// <seealso cref="WithAllDevicesMappedToNewInstances"/>
|
|
public IEnumerable<InputDevice> createdDevices => m_CreatedDevices;
|
|
|
|
private InputEventTrace m_EventTrace;
|
|
private Enumerator m_Enumerator;
|
|
private InlinedArray<KeyValuePair<int, int>> m_DeviceIDMappings;
|
|
private bool m_CreateNewDevices;
|
|
private InlinedArray<InputDevice> m_CreatedDevices;
|
|
private Action m_OnFinished;
|
|
private Action<InputEventPtr> m_OnEvent;
|
|
private double m_StartTimeAsPerFirstEvent;
|
|
private double m_StartTimeAsPerRuntime;
|
|
private int m_AllEventsByTimeIndex = 0;
|
|
private List<InputEventPtr> m_AllEventsByTime;
|
|
|
|
internal ReplayController(InputEventTrace trace)
|
|
{
|
|
if (trace == null)
|
|
throw new ArgumentNullException(nameof(trace));
|
|
|
|
m_EventTrace = trace;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes devices created by the controller when using <see cref="WithAllDevicesMappedToNewInstances"/>.
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
InputSystem.onBeforeUpdate -= OnBeginFrame;
|
|
finished = true;
|
|
|
|
foreach (var device in m_CreatedDevices)
|
|
InputSystem.RemoveDevice(device);
|
|
m_CreatedDevices = default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replay events recorded from <paramref name="recordedDevice"/> on device <paramref name="playbackDevice"/>.
|
|
/// </summary>
|
|
/// <param name="recordedDevice">Device events have been recorded from.</param>
|
|
/// <param name="playbackDevice">Device events should be played back on.</param>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="recordedDevice"/> is <c>null</c> -or-
|
|
/// <paramref name="playbackDevice"/> is <c>null</c>.</exception>
|
|
/// <remarks>
|
|
/// This method causes all events with a device ID (see <see cref="InputDevice.deviceId"/> and <see cref="InputEvent.deviceId"/>)
|
|
/// corresponding to the one of <paramref cref="recordedDevice"/> to be queued with the device ID of <paramref name="playbackDevice"/>.
|
|
/// </remarks>
|
|
public ReplayController WithDeviceMappedFromTo(InputDevice recordedDevice, InputDevice playbackDevice)
|
|
{
|
|
if (recordedDevice == null)
|
|
throw new ArgumentNullException(nameof(recordedDevice));
|
|
if (playbackDevice == null)
|
|
throw new ArgumentNullException(nameof(playbackDevice));
|
|
|
|
WithDeviceMappedFromTo(recordedDevice.deviceId, playbackDevice.deviceId);
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replace <see cref="InputEvent.deviceId"/> values of events that are equal to <paramref name="recordedDeviceId"/>
|
|
/// with device ID <paramref name="playbackDeviceId"/>.
|
|
/// </summary>
|
|
/// <param name="recordedDeviceId"><see cref="InputDevice.deviceId"/> to map from.</param>
|
|
/// <param name="playbackDeviceId"><see cref="InputDevice.deviceId"/> to map to.</param>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
public ReplayController WithDeviceMappedFromTo(int recordedDeviceId, int playbackDeviceId)
|
|
{
|
|
// If there's an existing mapping entry for the device, update it.
|
|
for (var i = 0; i < m_DeviceIDMappings.length; ++i)
|
|
{
|
|
if (m_DeviceIDMappings[i].Key != recordedDeviceId)
|
|
continue;
|
|
|
|
if (recordedDeviceId == playbackDeviceId) // Device mapped back to itself.
|
|
m_DeviceIDMappings.RemoveAtWithCapacity(i);
|
|
else
|
|
m_DeviceIDMappings[i] = new KeyValuePair<int, int>(recordedDeviceId, playbackDeviceId);
|
|
|
|
return this;
|
|
}
|
|
|
|
// Ignore if mapped to itself.
|
|
if (recordedDeviceId == playbackDeviceId)
|
|
return this;
|
|
|
|
// Record mapping.
|
|
m_DeviceIDMappings.AppendWithCapacity(new KeyValuePair<int, int>(recordedDeviceId, playbackDeviceId));
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// For all events, create new devices to replay the events on instead of replaying the events on existing devices.
|
|
/// </summary>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
/// <remarks>
|
|
/// Note that devices created by the <c>ReplayController</c> will stick around for as long as the replay
|
|
/// controller is not disposed of. This means that multiple successive replays using the same <c>ReplayController</c>
|
|
/// will replay the events on the same devices that were created on the first replay. It also means that in order
|
|
/// to do away with the created devices, it is necessary to call <see cref="Dispose"/>.
|
|
/// </remarks>
|
|
/// <seealso cref="Dispose"/>
|
|
/// <seealso cref="createdDevices"/>
|
|
public ReplayController WithAllDevicesMappedToNewInstances()
|
|
{
|
|
m_CreateNewDevices = true;
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invoke the given callback when playback finishes.
|
|
/// </summary>
|
|
/// <param name="action">A callback to invoke when playback finishes.</param>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
public ReplayController OnFinished(Action action)
|
|
{
|
|
m_OnFinished = action;
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invoke the given callback when an event is about to be queued.
|
|
/// </summary>
|
|
/// <param name="action">A callback to invoke when an event is getting queued.</param>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
public ReplayController OnEvent(Action<InputEventPtr> action)
|
|
{
|
|
m_OnEvent = action;
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Takes the next event from the trace and queues it.
|
|
/// </summary>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
/// <exception cref="InvalidOperationException">There are no more events in the <see cref="trace"/> -or- the only
|
|
/// events left are frame marker events (see <see cref="InputEventTrace.FrameMarkerEvent"/>).</exception>
|
|
/// <remarks>
|
|
/// This method takes the next event at the current read position and queues it using <see cref="InputSystem.QueueEvent"/>.
|
|
/// The read position is advanced past the taken event.
|
|
///
|
|
/// Frame marker events (see <see cref="InputEventTrace.FrameMarkerEvent"/>) are skipped.
|
|
/// </remarks>
|
|
public ReplayController PlayOneEvent()
|
|
{
|
|
// Skip events until we hit something that isn't a frame marker.
|
|
if (!MoveNext(true, out var eventPtr))
|
|
throw new InvalidOperationException("No more events");
|
|
|
|
QueueEvent(eventPtr);
|
|
|
|
return this;
|
|
}
|
|
|
|
////TODO: OneFrame
|
|
////TODO: RewindOneEvent
|
|
////TODO: RewindOneFrame
|
|
////TODO: Stop
|
|
|
|
/// <summary>
|
|
/// Rewind playback all the way to the beginning of the event trace.
|
|
/// </summary>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
public ReplayController Rewind()
|
|
{
|
|
m_Enumerator = default;
|
|
m_AllEventsByTime = null;
|
|
m_AllEventsByTimeIndex = -1;
|
|
position = 0;
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replay all frames one by one from the current playback position.
|
|
/// </summary>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
/// <remarks>
|
|
/// Events will be fed to the input system from within <see cref="InputSystem.onBeforeUpdate"/>. Each update
|
|
/// will receive events for one frame.
|
|
///
|
|
/// Note that for this method to correctly space out events and distribute them to frames, frame markers
|
|
/// must be present in the trace (see <see cref="recordFrameMarkers"/>). If not present, all events will
|
|
/// be fed into first frame.
|
|
/// </remarks>
|
|
/// <seealso cref="recordFrameMarkers"/>
|
|
/// <seealso cref="InputSystem.onBeforeUpdate"/>
|
|
/// <seealso cref="PlayAllEvents"/>
|
|
/// <seealso cref="PlayAllEventsAccordingToTimestamps"/>
|
|
public ReplayController PlayAllFramesOneByOne()
|
|
{
|
|
finished = false;
|
|
InputSystem.onBeforeUpdate += OnBeginFrame;
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Go through all remaining event in the trace starting at the current read position and queue them using
|
|
/// <see cref="InputSystem.QueueEvent"/>.
|
|
/// </summary>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
/// <remarks>
|
|
/// Unlike methods such as <see cref="PlayAllFramesOneByOne"/>, this method immediately queues events and immediately
|
|
/// completes playback upon return from the method.
|
|
/// </remarks>
|
|
/// <seealso cref="PlayAllFramesOneByOne"/>
|
|
/// <seealso cref="PlayAllEventsAccordingToTimestamps"/>
|
|
public ReplayController PlayAllEvents()
|
|
{
|
|
finished = false;
|
|
try
|
|
{
|
|
while (MoveNext(true, out var eventPtr))
|
|
QueueEvent(eventPtr);
|
|
}
|
|
finally
|
|
{
|
|
Finished();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replay events in a way that tries to preserve the original timing sequence.
|
|
/// </summary>
|
|
/// <returns>The same ReplayController instance.</returns>
|
|
/// <remarks>
|
|
/// This method will take the current time as the starting time to which make all events
|
|
/// relative to. Based on this time, it will try to correlate the original event timing
|
|
/// with the timing of input updates as they happen. When successful, this will compensate
|
|
/// for differences in frame timings compared to when input was recorded and instead queue
|
|
/// input in frames that are closer to the original timing.
|
|
///
|
|
/// Note that this method will perform one initial scan of the trace to determine a linear
|
|
/// ordering of the events by time (the input system does not require any such ordering on the
|
|
/// events in its queue and thus events in a trace, especially if there are multiple devices
|
|
/// involved, may be out of order).
|
|
/// </remarks>
|
|
/// <seealso cref="PlayAllFramesOneByOne"/>
|
|
/// <seealso cref="PlayAllEvents"/>
|
|
public ReplayController PlayAllEventsAccordingToTimestamps()
|
|
{
|
|
// Sort remaining events by time.
|
|
var eventsByTime = new List<InputEventPtr>();
|
|
while (MoveNext(true, out var eventPtr))
|
|
eventsByTime.Add(eventPtr);
|
|
eventsByTime.Sort((a, b) => a.time.CompareTo(b.time));
|
|
m_Enumerator.Dispose();
|
|
m_Enumerator = null;
|
|
m_AllEventsByTime = eventsByTime;
|
|
position = 0;
|
|
|
|
// Start playback.
|
|
finished = false;
|
|
m_StartTimeAsPerFirstEvent = -1;
|
|
m_AllEventsByTimeIndex = -1;
|
|
InputSystem.onBeforeUpdate += OnBeginFrame;
|
|
return this;
|
|
}
|
|
|
|
private void OnBeginFrame()
|
|
{
|
|
if (paused)
|
|
return;
|
|
|
|
if (!MoveNext(false, out var currentEventPtr))
|
|
{
|
|
if (m_AllEventsByTime == null || m_AllEventsByTimeIndex >= m_AllEventsByTime.Count)
|
|
Finished();
|
|
return;
|
|
}
|
|
|
|
// Check for empty frame (note: when playing back events by time, we won't see frame marker events
|
|
// returned from MoveNext).
|
|
if (currentEventPtr.type == FrameMarkerEvent)
|
|
{
|
|
if (!MoveNext(false, out var nextEvent))
|
|
{
|
|
// Last frame.
|
|
Finished();
|
|
return;
|
|
}
|
|
|
|
// Check for empty frame.
|
|
if (nextEvent.type == FrameMarkerEvent)
|
|
{
|
|
--position;
|
|
m_Enumerator.m_Current = currentEventPtr;
|
|
return;
|
|
}
|
|
|
|
currentEventPtr = nextEvent;
|
|
}
|
|
|
|
// Inject our events into the frame.
|
|
while (true)
|
|
{
|
|
QueueEvent(currentEventPtr);
|
|
|
|
// Stop if we reach the end of the stream.
|
|
if (!MoveNext(false, out var nextEvent))
|
|
{
|
|
if (m_AllEventsByTime == null || m_AllEventsByTimeIndex >= m_AllEventsByTime.Count)
|
|
Finished();
|
|
break;
|
|
}
|
|
|
|
// Stop if we've reached the next frame (won't happen if we're playing events by time).
|
|
if (nextEvent.type == FrameMarkerEvent)
|
|
{
|
|
// Back up one event.
|
|
m_Enumerator.m_Current = currentEventPtr;
|
|
--position;
|
|
break;
|
|
}
|
|
|
|
currentEventPtr = nextEvent;
|
|
}
|
|
}
|
|
|
|
private void Finished()
|
|
{
|
|
finished = true;
|
|
InputSystem.onBeforeUpdate -= OnBeginFrame;
|
|
m_OnFinished?.Invoke();
|
|
}
|
|
|
|
private void QueueEvent(InputEventPtr eventPtr)
|
|
{
|
|
// Shift time on event.
|
|
var originalTimestamp = eventPtr.internalTime;
|
|
if (m_AllEventsByTime != null)
|
|
eventPtr.internalTime = m_StartTimeAsPerRuntime + (eventPtr.internalTime - m_StartTimeAsPerFirstEvent);
|
|
else
|
|
eventPtr.internalTime = InputRuntime.s_Instance.currentTime;
|
|
|
|
// Remember original event ID. QueueEvent will automatically update the event ID
|
|
// and actually do so in place.
|
|
var originalEventId = eventPtr.id;
|
|
|
|
// Map device ID.
|
|
var originalDeviceId = eventPtr.deviceId;
|
|
eventPtr.deviceId = ApplyDeviceMapping(originalDeviceId);
|
|
|
|
// Notify.
|
|
m_OnEvent?.Invoke(eventPtr);
|
|
|
|
// Queue event.
|
|
try
|
|
{
|
|
InputSystem.QueueEvent(eventPtr);
|
|
}
|
|
finally
|
|
{
|
|
// Restore modification we made to the event buffer.
|
|
eventPtr.internalTime = originalTimestamp;
|
|
eventPtr.id = originalEventId;
|
|
eventPtr.deviceId = originalDeviceId;
|
|
}
|
|
}
|
|
|
|
private bool MoveNext(bool skipFrameEvents, out InputEventPtr eventPtr)
|
|
{
|
|
eventPtr = default;
|
|
|
|
if (m_AllEventsByTime != null)
|
|
{
|
|
if (m_AllEventsByTimeIndex + 1 >= m_AllEventsByTime.Count)
|
|
{
|
|
position = m_AllEventsByTime.Count;
|
|
m_AllEventsByTimeIndex = m_AllEventsByTime.Count;
|
|
return false;
|
|
}
|
|
|
|
if (m_AllEventsByTimeIndex < 0)
|
|
{
|
|
m_StartTimeAsPerFirstEvent = m_AllEventsByTime[0].internalTime;
|
|
m_StartTimeAsPerRuntime = InputRuntime.s_Instance.currentTime;
|
|
}
|
|
else if (m_AllEventsByTimeIndex < m_AllEventsByTime.Count - 1 &&
|
|
m_AllEventsByTime[m_AllEventsByTimeIndex + 1].internalTime > m_StartTimeAsPerFirstEvent + (InputRuntime.s_Instance.currentTime - m_StartTimeAsPerRuntime))
|
|
{
|
|
// We're queuing by original time and the next event isn't up yet,
|
|
// so early out.
|
|
return false;
|
|
}
|
|
|
|
++m_AllEventsByTimeIndex;
|
|
++position;
|
|
eventPtr = m_AllEventsByTime[m_AllEventsByTimeIndex];
|
|
}
|
|
else
|
|
{
|
|
if (m_Enumerator == null)
|
|
m_Enumerator = new Enumerator(m_EventTrace);
|
|
|
|
do
|
|
{
|
|
if (!m_Enumerator.MoveNext())
|
|
return false;
|
|
|
|
++position;
|
|
eventPtr = m_Enumerator.Current;
|
|
}
|
|
while (skipFrameEvents && eventPtr.type == FrameMarkerEvent);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private int ApplyDeviceMapping(int originalDeviceId)
|
|
{
|
|
// Look up in mappings.
|
|
for (var i = 0; i < m_DeviceIDMappings.length; ++i)
|
|
{
|
|
var entry = m_DeviceIDMappings[i];
|
|
if (entry.Key == originalDeviceId)
|
|
return entry.Value;
|
|
}
|
|
|
|
// Create device, if needed.
|
|
if (m_CreateNewDevices)
|
|
{
|
|
try
|
|
{
|
|
// Find device info.
|
|
var deviceIndex = m_EventTrace.deviceInfos.IndexOf(x => x.deviceId == originalDeviceId);
|
|
if (deviceIndex != -1)
|
|
{
|
|
var deviceInfo = m_EventTrace.deviceInfos[deviceIndex];
|
|
|
|
// If we don't have the layout, try to add it from the persisted layout info.
|
|
var layoutName = new InternedString(deviceInfo.layout);
|
|
if (!InputControlLayout.s_Layouts.HasLayout(layoutName))
|
|
{
|
|
if (string.IsNullOrEmpty(deviceInfo.m_FullLayoutJson))
|
|
return originalDeviceId;
|
|
|
|
InputSystem.RegisterLayout(deviceInfo.m_FullLayoutJson);
|
|
}
|
|
|
|
// Create device.
|
|
var device = InputSystem.AddDevice(layoutName);
|
|
WithDeviceMappedFromTo(originalDeviceId, device.deviceId);
|
|
m_CreatedDevices.AppendWithCapacity(device);
|
|
return device.deviceId;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Swallow and just return originalDeviceId.
|
|
}
|
|
}
|
|
|
|
return originalDeviceId;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Information about a device whose input has been captured in an <see cref="InputEventTrace"/>
|
|
/// </summary>
|
|
/// <seealso cref="InputEventTrace.deviceInfos"/>
|
|
[Serializable]
|
|
public struct DeviceInfo
|
|
{
|
|
/// <summary>
|
|
/// Id of the device as stored in the events for the device.
|
|
/// </summary>
|
|
/// <seealso cref="InputDevice.deviceId"/>
|
|
public int deviceId
|
|
{
|
|
get => m_DeviceId;
|
|
set => m_DeviceId = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Name of the layout used by the device.
|
|
/// </summary>
|
|
/// <seealso cref="InputControl.layout"/>
|
|
public string layout
|
|
{
|
|
get => m_Layout;
|
|
set => m_Layout = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tag for the format in which state for the device is stored.
|
|
/// </summary>
|
|
/// <seealso cref="InputControl.stateBlock"/>
|
|
/// <seealso cref="InputStateBlock.format"/>
|
|
public FourCC stateFormat
|
|
{
|
|
get => m_StateFormat;
|
|
set => m_StateFormat = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Size of a full state snapshot of the device.
|
|
/// </summary>
|
|
public int stateSizeInBytes
|
|
{
|
|
get => m_StateSizeInBytes;
|
|
set => m_StateSizeInBytes = value;
|
|
}
|
|
|
|
[SerializeField] internal int m_DeviceId;
|
|
[SerializeField] internal string m_Layout;
|
|
[SerializeField] internal FourCC m_StateFormat;
|
|
[SerializeField] internal int m_StateSizeInBytes;
|
|
[SerializeField] internal string m_FullLayoutJson;
|
|
}
|
|
}
|
|
}
|