1615 lines
69 KiB
C#
1615 lines
69 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using Unity.Collections;
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine.InputSystem.LowLevel;
|
|
using UnityEngine.InputSystem.Utilities;
|
|
|
|
////REVIEW: should this enumerate *backwards* in time rather than *forwards*?
|
|
|
|
////TODO: allow correlating history to frames/updates
|
|
|
|
////TODO: add ability to grow such that you can set it to e.g. record up to 4 seconds of history and it will automatically keep the buffer size bounded
|
|
|
|
////REVIEW: should we align the extra memory on a 4 byte boundary?
|
|
|
|
namespace UnityEngine.InputSystem.LowLevel
|
|
{
|
|
/// <summary>
|
|
/// Record a history of state changes applied to one or more controls.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This class makes it easy to track input values over time. It will automatically retain input state up to a given
|
|
/// maximum history depth (<see cref="historyDepth"/>). When the history is full, it will start overwriting the oldest
|
|
/// entry each time a new history record is received.
|
|
///
|
|
/// The class listens to changes on the given controls by adding change monitors (<see cref="IInputStateChangeMonitor"/>)
|
|
/// to each control.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <code>
|
|
/// // Track all stick controls in the system.
|
|
/// var history = new InputStateHistory<Vector2>("*/<Stick>");
|
|
/// foreach (var control in history.controls)
|
|
/// Debug.Log("Capturing input on " + control);
|
|
///
|
|
/// // Start capturing.
|
|
/// history.StartRecording();
|
|
///
|
|
/// // Perform a couple artificial value changes.
|
|
/// Gamepad.current.leftStick.QueueValueChange(new Vector2(0.123f, 0.234f));
|
|
/// Gamepad.current.leftStick.QueueValueChange(new Vector2(0.234f, 0.345f));
|
|
/// Gamepad.current.leftStick.QueueValueChange(new Vector2(0.345f, 0.456f));
|
|
/// InputSystem.Update();
|
|
///
|
|
/// // Every value change will be visible in the history.
|
|
/// foreach (var record in history)
|
|
/// Debug.Log($"{record.control} changed value to {record.ReadValue()}");
|
|
///
|
|
/// // Histories allocate unmanaged memory and must be disposed of in order to not leak.
|
|
/// history.Dispose();
|
|
/// </code>
|
|
/// </example>
|
|
/// <seealso cref="Record"/>
|
|
public class InputStateHistory : IDisposable, IEnumerable<InputStateHistory.Record>, IInputStateChangeMonitor
|
|
{
|
|
private const int kDefaultHistorySize = 128;
|
|
|
|
/// <summary>
|
|
/// Total number of state records currently captured in the history.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Number of records in the collection.
|
|
///
|
|
/// This will always be at most <see cref="historyDepth"/>.
|
|
/// To record a change use <see cref="RecordStateChange(InputControl,InputEventPtr)"/>.
|
|
/// </remarks>
|
|
public int Count => m_RecordCount;
|
|
|
|
/// <summary>
|
|
/// Current version stamp. Every time a record is stored in the history,
|
|
/// this is incremented by one.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Version stamp that indicates the number of mutations.
|
|
/// To record a change use <see cref="RecordStateChange(InputControl,InputEventPtr)"/>.
|
|
/// </remarks>
|
|
public uint version => m_CurrentVersion;
|
|
|
|
/// <summary>
|
|
/// Maximum number of records that can be recorded in the history.
|
|
/// </summary>
|
|
/// <exception cref="ArgumentException"><paramref name="value"/> is negative.</exception>
|
|
/// <remarks>
|
|
/// Upper limit on number of records.
|
|
/// A fixed size memory block of unmanaged memory will be allocated to store history
|
|
/// records.
|
|
/// When the history is full, it will start overwriting the oldest
|
|
/// entry each time a new history record is received.
|
|
/// </remarks>
|
|
public int historyDepth
|
|
{
|
|
get => m_HistoryDepth;
|
|
set
|
|
{
|
|
if (value < 0)
|
|
throw new ArgumentException("History depth cannot be negative", nameof(value));
|
|
if (m_RecordBuffer.IsCreated)
|
|
throw new NotImplementedException();
|
|
m_HistoryDepth = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Size of additional data storage to allocate per record.
|
|
/// </summary>
|
|
/// <exception cref="ArgumentException"><paramref name="value"/> is negative.</exception>
|
|
/// <remarks>
|
|
/// Additional custom data can be stored per record up to the size of this value.
|
|
/// To retrieve a pointer to this memory use <see cref="Record.GetUnsafeExtraMemoryPtr"/>
|
|
/// Used by <see cref="EnhancedTouch.Touch.history"/>
|
|
/// </remarks>
|
|
public int extraMemoryPerRecord
|
|
{
|
|
get => m_ExtraMemoryPerRecord;
|
|
set
|
|
{
|
|
if (value < 0)
|
|
throw new ArgumentException("Memory size cannot be negative", nameof(value));
|
|
if (m_RecordBuffer.IsCreated)
|
|
throw new NotImplementedException();
|
|
m_ExtraMemoryPerRecord = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specify which player loop positions the state history will be monitored for.
|
|
/// </summary>
|
|
/// <exception cref="ArgumentException"><paramref name="value"/>When an invalid mask is provided (e.g. <see cref="InputUpdateType.None"/>).</exception>
|
|
/// <remarks>
|
|
/// The state history will only be monitored for the specified player loop positions.
|
|
/// <see cref="InputUpdateType.Editor"/> is excluded from this list
|
|
/// </remarks>
|
|
public InputUpdateType updateMask
|
|
{
|
|
get => m_UpdateMask ?? InputSystem.s_Manager.updateMask & ~InputUpdateType.Editor;
|
|
set
|
|
{
|
|
if (value == InputUpdateType.None)
|
|
throw new ArgumentException("'InputUpdateType.None' is not a valid update mask", nameof(value));
|
|
m_UpdateMask = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// List of input controls the state history will be recording for.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The list of input controls the state history will be recording for is specified on construction of the <see cref="InputStateHistory"/>
|
|
/// </remarks>
|
|
public ReadOnlyArray<InputControl> controls => new ReadOnlyArray<InputControl>(m_Controls, 0, m_ControlCount);
|
|
|
|
/// <summary>
|
|
/// Returns an entry in the state history at the given index.
|
|
/// </summary>
|
|
/// <param name="index">Index into the array.</param>
|
|
/// <remarks>
|
|
/// Returns a <see cref="Record"/> entry from the state history at the given index.
|
|
/// </remarks>
|
|
/// <exception cref="IndexOutOfRangeException"><paramref name="index"/> is less than 0 or greater than <see cref="Count"/>.</exception>
|
|
public unsafe Record this[int index]
|
|
{
|
|
get
|
|
{
|
|
if (index < 0 || index >= m_RecordCount)
|
|
throw new ArgumentOutOfRangeException(
|
|
$"Index {index} is out of range for history with {m_RecordCount} entries", nameof(index));
|
|
|
|
var recordIndex = UserIndexToRecordIndex(index);
|
|
return new Record(this, recordIndex, GetRecord(recordIndex));
|
|
}
|
|
set
|
|
{
|
|
if (index < 0 || index >= m_RecordCount)
|
|
throw new ArgumentOutOfRangeException(
|
|
$"Index {index} is out of range for history with {m_RecordCount} entries", nameof(index));
|
|
|
|
var recordIndex = UserIndexToRecordIndex(index);
|
|
new Record(this, recordIndex, GetRecord(recordIndex)).CopyFrom(value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional delegate to perform when a record is added to the history array.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Can be used to fill in the extra memory with custom data using <see cref="Record.GetUnsafeExtraMemoryPtr"/>
|
|
/// </remarks>
|
|
public Action<Record> onRecordAdded { get; set; }
|
|
|
|
/// <summary>
|
|
/// Optional delegate to decide whether the state change should be stored in the history.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Can be used to filter out some events to focus on recording the ones you are most interested in.
|
|
///
|
|
/// If the callback returns <c>true</c>, a record will be added to the history
|
|
/// If the callback returns <c>false</c>, the event will be ignored and not recorded.
|
|
/// </remarks>
|
|
public Func<InputControl, double, InputEventPtr, bool> onShouldRecordStateChange { get; set; }
|
|
|
|
/// <summary>
|
|
/// Creates a new InputStateHistory class to record all control state changes.
|
|
/// </summary>
|
|
/// <param name="maxStateSizeInBytes">Maximum size of control state in the record entries. Controls with larger state will not be recorded.</param>
|
|
/// <remarks>
|
|
/// Creates a new InputStateHistory to record a history of control state changes.
|
|
///
|
|
/// New controls are automatically added into the state history if their state is smaller than the threshold.
|
|
/// </remarks>
|
|
public InputStateHistory(int maxStateSizeInBytes)
|
|
{
|
|
if (maxStateSizeInBytes <= 0)
|
|
throw new ArgumentException("State size must be >= 0", nameof(maxStateSizeInBytes));
|
|
|
|
m_AddNewControls = true;
|
|
m_StateSizeInBytes = maxStateSizeInBytes.AlignToMultipleOf(4);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new InputStateHistory class to record state changes for a specified control.
|
|
/// </summary>
|
|
/// <param name="path">Control path to identify which controls to monitor.</param>
|
|
/// <remarks>
|
|
/// Creates a new InputStateHistory to record a history of state changes for the specified controls.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <code>
|
|
/// // Track all stick controls in the system.
|
|
/// var history = new InputStateHistory("*/<Stick>");
|
|
/// </code>
|
|
/// </example>
|
|
public InputStateHistory(string path)
|
|
{
|
|
using (var controls = InputSystem.FindControls(path))
|
|
{
|
|
m_Controls = controls.ToArray();
|
|
m_ControlCount = m_Controls.Length;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new InputStateHistory class to record state changes for a specified control.
|
|
/// </summary>
|
|
/// <param name="control">Control to monitor.</param>
|
|
/// <remarks>
|
|
/// Creates a new InputStateHistory to record a history of state changes for the specified control.
|
|
/// </remarks>
|
|
public InputStateHistory(InputControl control)
|
|
{
|
|
if (control == null)
|
|
throw new ArgumentNullException(nameof(control));
|
|
|
|
m_Controls = new[] {control};
|
|
m_ControlCount = 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new InputStateHistory class to record state changes for a specified controls.
|
|
/// </summary>
|
|
/// <param name="controls">Controls to monitor.</param>
|
|
/// <remarks>
|
|
/// Creates a new InputStateHistory to record a history of state changes for the specified controls.
|
|
/// </remarks>
|
|
public InputStateHistory(IEnumerable<InputControl> controls)
|
|
{
|
|
if (controls != null)
|
|
{
|
|
m_Controls = controls.ToArray();
|
|
m_ControlCount = m_Controls.Length;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// InputStateHistory destructor.
|
|
/// </summary>
|
|
~InputStateHistory()
|
|
{
|
|
Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear the history record.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Clear the history record. Resetting the list to empty.
|
|
///
|
|
/// This won't clear controls that have been added on the fly.
|
|
/// </remarks>
|
|
public void Clear()
|
|
{
|
|
m_HeadIndex = 0;
|
|
m_RecordCount = 0;
|
|
++m_CurrentVersion;
|
|
|
|
// NOTE: Won't clear controls that have been added on the fly.
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a record to the input state history.
|
|
/// </summary>
|
|
/// <param name="record">Record to add.</param>
|
|
/// <returns>The newly added record from the history array (as a copy is made).</returns>
|
|
/// <remarks>
|
|
/// Add a record to the input state history.
|
|
/// Allocates an entry in the history array and returns this copy of the original data passed to the function.
|
|
/// </remarks>
|
|
public unsafe Record AddRecord(Record record)
|
|
{
|
|
var recordPtr = AllocateRecord(out var index);
|
|
var newRecord = new Record(this, index, recordPtr);
|
|
newRecord.CopyFrom(record);
|
|
return newRecord;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start recording state history for the specified controls.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Start recording state history for the controls specified in the <see cref="InputStateHistory"/> constructor.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <code>
|
|
/// using (var allTouchTaps = new InputStateHistory("<Touchscreen>/touch*/tap"))
|
|
/// {
|
|
/// allTouchTaps.StartRecording();
|
|
/// allTouchTaps.StopRecording();
|
|
/// }
|
|
/// </code>
|
|
/// </example>
|
|
public void StartRecording()
|
|
{
|
|
// We defer allocation until we actually get values on a control.
|
|
|
|
foreach (var control in controls)
|
|
InputState.AddChangeMonitor(control, this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop recording state history for the specified controls.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Stop recording state history for the controls specified in the <see cref="InputStateHistory"/> constructor.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <code>
|
|
/// using (var allTouchTaps = new InputStateHistory("<Touchscreen>/touch*/tap"))
|
|
/// {
|
|
/// allTouchTaps.StartRecording();
|
|
/// allTouchTaps.StopRecording();
|
|
/// }
|
|
/// </code>
|
|
/// </example>
|
|
public void StopRecording()
|
|
{
|
|
foreach (var control in controls)
|
|
InputState.RemoveChangeMonitor(control, this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Record a state change for a specific control.
|
|
/// </summary>
|
|
/// <param name="control">The control to record the state change for.</param>
|
|
/// <param name="eventPtr">The current event data to record.</param>
|
|
/// <returns>The newly added record.</returns>
|
|
/// <remarks>
|
|
/// Record a state change for a specific control.
|
|
/// Will call the <see cref="onRecordAdded"/> delegate after adding the record.
|
|
/// Note this does not call the <see cref="onShouldRecordStateChange"/> delegate.
|
|
/// </remarks>
|
|
public unsafe Record RecordStateChange(InputControl control, InputEventPtr eventPtr)
|
|
{
|
|
if (eventPtr.IsA<DeltaStateEvent>())
|
|
throw new NotImplementedException();
|
|
|
|
if (!eventPtr.IsA<StateEvent>())
|
|
throw new ArgumentException($"Event must be a state event but is '{eventPtr}' instead",
|
|
nameof(eventPtr));
|
|
|
|
var statePtr = (byte*)StateEvent.From(eventPtr)->state - control.device.stateBlock.byteOffset;
|
|
return RecordStateChange(control, statePtr, eventPtr.time);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Record a state change for a specific control.
|
|
/// </summary>
|
|
/// <param name="control">The control to record the state change for.</param>
|
|
/// <param name="statePtr">The current state data to record.</param>
|
|
/// <param name="time">Time stamp to apply (overriding the event timestamp)</param>
|
|
/// <returns>The newly added record.</returns>
|
|
/// <remarks>
|
|
/// Record a state change for a specific control.
|
|
/// Will call the <see cref="onRecordAdded"/> delegate after adding the record.
|
|
/// Note this does not call the <see cref="onShouldRecordStateChange"/> delegate.
|
|
/// </remarks>
|
|
public unsafe Record RecordStateChange(InputControl control, void* statePtr, double time)
|
|
{
|
|
var controlIndex = ArrayHelpers.IndexOfReference(m_Controls, control, m_ControlCount);
|
|
if (controlIndex == -1)
|
|
{
|
|
if (m_AddNewControls)
|
|
{
|
|
if (control.stateBlock.alignedSizeInBytes > m_StateSizeInBytes)
|
|
throw new InvalidOperationException(
|
|
$"Cannot add control '{control}' with state larger than {m_StateSizeInBytes} bytes");
|
|
controlIndex = ArrayHelpers.AppendWithCapacity(ref m_Controls, ref m_ControlCount, control);
|
|
}
|
|
else
|
|
throw new ArgumentException($"Control '{control}' is not part of InputStateHistory",
|
|
nameof(control));
|
|
}
|
|
|
|
var recordPtr = AllocateRecord(out var index);
|
|
recordPtr->time = time;
|
|
recordPtr->version = ++m_CurrentVersion;
|
|
var stateBufferPtr = recordPtr->statePtrWithoutControlIndex;
|
|
if (m_ControlCount > 1 || m_AddNewControls)
|
|
{
|
|
// If there's multiple controls, write index of control to which the state change
|
|
// pertains as an int before the state memory contents following it.
|
|
recordPtr->controlIndex = controlIndex;
|
|
stateBufferPtr = recordPtr->statePtrWithControlIndex;
|
|
}
|
|
|
|
var stateSize = control.stateBlock.alignedSizeInBytes;
|
|
var stateOffset = control.stateBlock.byteOffset;
|
|
|
|
UnsafeUtility.MemCpy(stateBufferPtr, (byte*)statePtr + stateOffset, stateSize);
|
|
|
|
// Trigger callback.
|
|
var record = new Record(this, index, recordPtr);
|
|
onRecordAdded?.Invoke(record);
|
|
|
|
return record;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate all state history records.
|
|
/// </summary>
|
|
/// <returns>An enumerator going over the state history records.</returns>
|
|
/// <remarks>
|
|
/// Enumerate all state history records.
|
|
/// </remarks>
|
|
/// <seealso cref="GetEnumerator"/>
|
|
public IEnumerator<Record> GetEnumerator()
|
|
{
|
|
return new Enumerator(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate all state history records.
|
|
/// </summary>
|
|
/// <returns>An enumerator going over the state history records.</returns>
|
|
/// <remarks>
|
|
/// Enumerate all state history records.
|
|
/// </remarks>
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dispose of the state history records.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Stops recording and cleans up the state history
|
|
/// </remarks>
|
|
public void Dispose()
|
|
{
|
|
StopRecording();
|
|
Destroy();
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Destroy the state history records.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Deletes the state history records.
|
|
/// </remarks>
|
|
protected void Destroy()
|
|
{
|
|
if (m_RecordBuffer.IsCreated)
|
|
{
|
|
m_RecordBuffer.Dispose();
|
|
m_RecordBuffer = new NativeArray<byte>();
|
|
}
|
|
}
|
|
|
|
private void Allocate()
|
|
{
|
|
// Find max size of state.
|
|
if (!m_AddNewControls)
|
|
{
|
|
m_StateSizeInBytes = 0;
|
|
foreach (var control in controls)
|
|
m_StateSizeInBytes = (int)Math.Max((uint)m_StateSizeInBytes, control.stateBlock.alignedSizeInBytes);
|
|
}
|
|
else
|
|
{
|
|
Debug.Assert(m_StateSizeInBytes > 0, "State size must be have initialized!");
|
|
}
|
|
|
|
// Allocate historyDepth times state blocks of the given max size. For each one
|
|
// add space for the RecordHeader header.
|
|
// NOTE: If we only have a single control, we omit storing the integer control index.
|
|
var totalSizeOfBuffer = bytesPerRecord * m_HistoryDepth;
|
|
m_RecordBuffer = new NativeArray<byte>(totalSizeOfBuffer, Allocator.Persistent,
|
|
NativeArrayOptions.UninitializedMemory);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remap a records internal index to an index from the start of the recording in the circular buffer.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Remap a records internal index, which is relative to the start of the record buffer,
|
|
/// to an index relative to the start of the recording in the circular buffer.
|
|
/// </remarks>
|
|
/// <param name="index">Record index (from the start of the record array).</param>
|
|
/// <returns>An index relative to the start of the recording in the circular buffer.</returns>
|
|
protected internal int RecordIndexToUserIndex(int index)
|
|
{
|
|
if (index < m_HeadIndex)
|
|
return m_HistoryDepth - m_HeadIndex + index;
|
|
return index - m_HeadIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remap an index from the start of the recording in the circular buffer to a records internal index.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Remap an index relative to the start of the recording in the circular buffer,
|
|
/// to a records internal index, which is relative to the start of the record buffer.
|
|
/// </remarks>
|
|
/// <param name="index">An index relative to the start of the recording in the circular buffer.</param>
|
|
/// <returns>Record index (from the start of the record array).</returns>
|
|
protected internal int UserIndexToRecordIndex(int index)
|
|
{
|
|
return (m_HeadIndex + index) % m_HistoryDepth;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve a record from the input state history.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Retrieve a record from the input state history by Record index.
|
|
/// </remarks>
|
|
/// <param name="index">Record index into the input state history records buffer.</param>
|
|
/// <returns>The record header for the specified index</returns>
|
|
/// <exception cref="InvalidOperationException">When the buffer is no longer valid as it has been disposed.</exception>
|
|
/// <exception cref="ArgumentOutOfRangeException">If the index is out of range of the history depth.</exception>
|
|
protected internal unsafe RecordHeader* GetRecord(int index)
|
|
{
|
|
if (!m_RecordBuffer.IsCreated)
|
|
throw new InvalidOperationException("History buffer has been disposed");
|
|
if (index < 0 || index >= m_HistoryDepth)
|
|
throw new ArgumentOutOfRangeException(nameof(index));
|
|
return GetRecordUnchecked(index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve a record from the input state history, without any bounds check.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Retrieve a record from the input state history by record index, without any bounds check
|
|
/// </remarks>
|
|
/// <param name="index">Record index into the input state history records buffer.</param>
|
|
/// <returns>The record header for the specified index</returns>
|
|
internal unsafe RecordHeader* GetRecordUnchecked(int index)
|
|
{
|
|
return (RecordHeader*)((byte*)m_RecordBuffer.GetUnsafePtr() + index * bytesPerRecord);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocate a new record in the input state history.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Allocate a new record in the input state history.
|
|
/// </remarks>
|
|
/// <param name="index">The index of the newly created record</param>
|
|
/// <returns>The header of the newly created record</returns>
|
|
protected internal unsafe RecordHeader* AllocateRecord(out int index)
|
|
{
|
|
if (!m_RecordBuffer.IsCreated)
|
|
Allocate();
|
|
|
|
index = (m_HeadIndex + m_RecordCount) % m_HistoryDepth;
|
|
|
|
// If we're full, advance head to make room.
|
|
if (m_RecordCount == m_HistoryDepth)
|
|
m_HeadIndex = (m_HeadIndex + 1) % m_HistoryDepth;
|
|
else
|
|
{
|
|
// We have a fixed max size given by the history depth and will start overwriting
|
|
// older entries once we reached max size.
|
|
++m_RecordCount;
|
|
}
|
|
|
|
return (RecordHeader*)((byte*)m_RecordBuffer.GetUnsafePtr() + bytesPerRecord * index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns value from the control in the specified record header.
|
|
/// </summary>
|
|
/// <param name="data">The record header to query.</param>
|
|
/// <typeparam name="TValue">The type of the value being read</typeparam>
|
|
/// <returns>The value from the record.</returns>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value or the specified type is not present.</exception>
|
|
protected unsafe TValue ReadValue<TValue>(RecordHeader* data)
|
|
where TValue : struct
|
|
{
|
|
// Get control. If we only have a single one, the index isn't stored on the data.
|
|
var haveSingleControl = m_ControlCount == 1 && !m_AddNewControls;
|
|
var control = haveSingleControl ? controls[0] : controls[data->controlIndex];
|
|
if (!(control is InputControl<TValue> controlOfType))
|
|
throw new InvalidOperationException(
|
|
$"Cannot read value of type '{TypeHelpers.GetNiceTypeName(typeof(TValue))}' from control '{control}' with value type '{TypeHelpers.GetNiceTypeName(control.valueType)}'");
|
|
|
|
// Grab state memory.
|
|
var statePtr = haveSingleControl ? data->statePtrWithoutControlIndex : data->statePtrWithControlIndex;
|
|
statePtr -= control.stateBlock.byteOffset;
|
|
return controlOfType.ReadValueFromState(statePtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the control's final, processed value from the given state and return the value as an object.
|
|
/// </summary>
|
|
/// <param name="data">The record header to query.</param>
|
|
/// <returns>The value of the control associated with the record header.</returns>
|
|
/// <remarks>
|
|
/// This method allocates GC memory and should not be used during normal gameplay operation.
|
|
/// </remarks>
|
|
/// <exception cref="InvalidOperationException">When the specified value is not present.</exception>
|
|
protected unsafe object ReadValueAsObject(RecordHeader* data)
|
|
{
|
|
// Get control. If we only have a single one, the index isn't stored on the data.
|
|
var haveSingleControl = m_ControlCount == 1 && !m_AddNewControls;
|
|
var control = haveSingleControl ? controls[0] : controls[data->controlIndex];
|
|
|
|
// Grab state memory.
|
|
var statePtr = haveSingleControl ? data->statePtrWithoutControlIndex : data->statePtrWithControlIndex;
|
|
statePtr -= control.stateBlock.byteOffset;
|
|
return control.ReadValueFromStateAsObject(statePtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delegate to list to control state change notifications.
|
|
/// </summary>
|
|
/// <param name="control">Control that is being monitored by the state change monitor and that had its state memory changed.</param>
|
|
/// <param name="time">Time on the <see cref="InputEvent.time"/> timeline at which the control state change was received.</param>
|
|
/// <param name="eventPtr">If the state change was initiated by a state event (either a <see cref="StateEvent"/>
|
|
/// or <see cref="DeltaStateEvent"/>), this is the pointer to that event. Otherwise, it is pointer that is still
|
|
/// <see cref="InputEventPtr.valid"/>, but refers a "dummy" event that is not a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>.</param>
|
|
/// <param name="monitorIndex">Index of the monitor as passed to <see cref="InputState.AddChangeMonitor(InputControl,IInputStateChangeMonitor,long,uint)"/></param>
|
|
/// <remarks>
|
|
/// Records a state change after checking the <see cref="updateMask"/> and the <see cref="onShouldRecordStateChange"/> callback.
|
|
/// </remarks>
|
|
unsafe void IInputStateChangeMonitor.NotifyControlStateChanged(InputControl control, double time,
|
|
InputEventPtr eventPtr, long monitorIndex)
|
|
{
|
|
// Ignore state change if it's in an input update we're not interested in.
|
|
var currentUpdateType = InputState.currentUpdateType;
|
|
var updateTypeMask = updateMask;
|
|
if ((currentUpdateType & updateTypeMask) == 0)
|
|
return;
|
|
|
|
// Ignore state change if we have a filter and the state change doesn't pass the check.
|
|
if (onShouldRecordStateChange != null && !onShouldRecordStateChange(control, time, eventPtr))
|
|
return;
|
|
|
|
RecordStateChange(control, control.currentStatePtr, time);
|
|
}
|
|
|
|
// Unused.
|
|
/// <summary>
|
|
/// Called when a timeout set on a state change monitor has expired.
|
|
/// </summary>
|
|
/// <param name="control">Control on which the timeout expired.</param>
|
|
/// <param name="time">Input time at which the timer expired. This is the time at which an <see cref="InputSystem.Update"/> is being
|
|
/// run whose <see cref="InputState.currentTime"/> is past the time of expiration.</param>
|
|
/// <param name="monitorIndex">Index of the monitor as given to <see cref="InputState.AddChangeMonitor(InputControl,IInputStateChangeMonitor,long,uint)"/>.</param>
|
|
/// <param name="timerIndex">Index of the timer as given to <see cref="InputState.AddChangeMonitorTimeout"/>.</param>
|
|
/// <seealso cref="InputState.AddChangeMonitorTimeout"/>
|
|
void IInputStateChangeMonitor.NotifyTimerExpired(InputControl control, double time, long monitorIndex,
|
|
int timerIndex)
|
|
{
|
|
}
|
|
|
|
internal InputControl[] m_Controls;
|
|
internal int m_ControlCount;
|
|
private NativeArray<byte> m_RecordBuffer;
|
|
private int m_StateSizeInBytes;
|
|
private int m_RecordCount;
|
|
private int m_HistoryDepth = kDefaultHistorySize;
|
|
private int m_ExtraMemoryPerRecord;
|
|
internal int m_HeadIndex;
|
|
internal uint m_CurrentVersion;
|
|
private InputUpdateType? m_UpdateMask;
|
|
internal readonly bool m_AddNewControls;
|
|
|
|
internal int bytesPerRecord =>
|
|
(m_StateSizeInBytes +
|
|
m_ExtraMemoryPerRecord +
|
|
(m_ControlCount == 1 && !m_AddNewControls
|
|
? RecordHeader.kSizeWithoutControlIndex
|
|
: RecordHeader.kSizeWithControlIndex)).AlignToMultipleOf(4);
|
|
|
|
private struct Enumerator : IEnumerator<Record>
|
|
{
|
|
private readonly InputStateHistory m_History;
|
|
private int m_Index;
|
|
|
|
public Enumerator(InputStateHistory history)
|
|
{
|
|
m_History = history;
|
|
m_Index = -1;
|
|
}
|
|
|
|
public bool MoveNext()
|
|
{
|
|
if (m_Index + 1 >= m_History.Count)
|
|
return false;
|
|
++m_Index;
|
|
return true;
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
m_Index = -1;
|
|
}
|
|
|
|
public Record Current => m_History[m_Index];
|
|
|
|
object IEnumerator.Current => Current;
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>State change record header</summary>
|
|
/// <remarks>
|
|
/// Input State change record header containing the timestamp and other common record data.
|
|
/// Stored in the <see cref="InputStateHistory"/>.
|
|
/// </remarks>
|
|
/// <seealso cref="InputStateHistory"/>
|
|
[StructLayout(LayoutKind.Explicit)]
|
|
protected internal unsafe struct RecordHeader
|
|
{
|
|
/// <summary>
|
|
/// The time stamp of the input state record.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The time stamp of the input state record in the owning container.
|
|
/// <see cref="IInputRuntime.currentTime"/>
|
|
/// </remarks>
|
|
[FieldOffset(0)] public double time;
|
|
|
|
/// <summary>
|
|
/// The version of the input state record.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Current version stamp. See <see cref="InputStateHistory.version"/>.
|
|
/// </remarks>
|
|
[FieldOffset(8)] public uint version;
|
|
|
|
/// <summary>
|
|
/// The index of the record.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The index of the record relative to the start of the buffer.
|
|
/// See <see cref="InputStateHistory.RecordIndexToUserIndex"/> to remap this record index to a user index.
|
|
/// </remarks>
|
|
[FieldOffset(12)] public int controlIndex;
|
|
|
|
[FieldOffset(12)] private fixed byte m_StateWithoutControlIndex[1];
|
|
[FieldOffset(16)] private fixed byte m_StateWithControlIndex[1];
|
|
|
|
/// <summary>
|
|
/// The state data including the control index.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The state data including the control index.
|
|
/// </remarks>
|
|
public byte* statePtrWithControlIndex
|
|
{
|
|
get
|
|
{
|
|
fixed(byte* ptr = m_StateWithControlIndex)
|
|
return ptr;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The state data excluding the control index.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The state data excluding the control index.
|
|
/// </remarks>
|
|
public byte* statePtrWithoutControlIndex
|
|
{
|
|
get
|
|
{
|
|
fixed(byte* ptr = m_StateWithoutControlIndex)
|
|
return ptr;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Size of the state data including the control index.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Size of the data including the control index.
|
|
/// </remarks>
|
|
public const int kSizeWithControlIndex = 16;
|
|
|
|
/// <summary>
|
|
/// Size of the state data excluding the control index.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Size of the data excluding the control index.
|
|
/// </remarks>
|
|
public const int kSizeWithoutControlIndex = 12;
|
|
}
|
|
|
|
/// <summary>State change record</summary>
|
|
/// <remarks>Input State change record stored in the <see cref="InputStateHistory"/>.</remarks>
|
|
/// <seealso cref="InputStateHistory"/>
|
|
public unsafe struct Record : IEquatable<Record>
|
|
{
|
|
// We store an index rather than a direct pointer to make this struct safer to use.
|
|
private readonly InputStateHistory m_Owner;
|
|
private readonly int m_IndexPlusOne; // Plus one so that default(int) works for us.
|
|
private uint m_Version;
|
|
|
|
internal RecordHeader* header => m_Owner.GetRecord(recordIndex);
|
|
internal int recordIndex => m_IndexPlusOne - 1;
|
|
internal uint version => m_Version;
|
|
|
|
/// <summary>
|
|
/// Identifies if the record is valid.
|
|
/// </summary>
|
|
/// <value>True if the record is a valid entry. False if invalid.</value>
|
|
/// <remarks>
|
|
/// When the history is cleared with <see cref="Clear"/> the entries become invalid.
|
|
/// </remarks>
|
|
public bool valid => m_Owner != default && m_IndexPlusOne != default && header->version == m_Version;
|
|
|
|
/// <summary>
|
|
/// Identifies the owning container for the record.
|
|
/// </summary>
|
|
/// <value>The owning <see cref="InputStateHistory"/> container for the record.</value>
|
|
/// <remarks>
|
|
/// Identifies the owning <see cref="InputStateHistory"/> container for the record.
|
|
/// </remarks>
|
|
public InputStateHistory owner => m_Owner;
|
|
|
|
/// <summary>
|
|
/// The index of the input state record in the owning container.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The index of the input state record in the owning container.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public int index
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
return m_Owner.RecordIndexToUserIndex(recordIndex);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The time stamp of the input state record.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The time stamp of the input state record in the owning container.
|
|
/// <see cref="IInputRuntime.currentTime"/>
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public double time
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
return header->time;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The control associated with the input state record.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The control associated with the input state record.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public InputControl control
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
var controls = m_Owner.controls;
|
|
if (controls.Count == 1 && !m_Owner.m_AddNewControls)
|
|
return controls[0];
|
|
return controls[header->controlIndex];
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The next input state record in the owning container.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The next input state record in the owning <see cref="InputStateHistory"/>container.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public Record next
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
var userIndex = m_Owner.RecordIndexToUserIndex(this.recordIndex);
|
|
if (userIndex + 1 >= m_Owner.Count)
|
|
return default;
|
|
var recordIndex = m_Owner.UserIndexToRecordIndex(userIndex + 1);
|
|
return new Record(m_Owner, recordIndex, m_Owner.GetRecord(recordIndex));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The previous input state record in the owning container.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The previous input state record in the owning <see cref="InputStateHistory"/>container.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public Record previous
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
var userIndex = m_Owner.RecordIndexToUserIndex(this.recordIndex);
|
|
if (userIndex - 1 < 0)
|
|
return default;
|
|
var recordIndex = m_Owner.UserIndexToRecordIndex(userIndex - 1);
|
|
return new Record(m_Owner, recordIndex, m_Owner.GetRecord(recordIndex));
|
|
}
|
|
}
|
|
|
|
internal Record(InputStateHistory owner, int index, RecordHeader* header)
|
|
{
|
|
m_Owner = owner;
|
|
m_IndexPlusOne = index + 1;
|
|
m_Version = header->version;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns value from the control in the record.
|
|
/// </summary>
|
|
/// <typeparam name="TValue">The type of the value being read</typeparam>
|
|
/// <returns>Returns the value from the record.</returns>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value or the specified type is not present.</exception>
|
|
public TValue ReadValue<TValue>()
|
|
where TValue : struct
|
|
{
|
|
CheckValid();
|
|
return m_Owner.ReadValue<TValue>(header);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the control's final, processed value from the given state and return the value as an object.
|
|
/// </summary>
|
|
/// <returns>The value of the control associated with the record.</returns>
|
|
/// <remarks>
|
|
/// This method allocates GC memory and should not be used during normal gameplay operation.
|
|
/// </remarks>
|
|
/// <exception cref="InvalidOperationException">When the specified value is not present.</exception>
|
|
public object ReadValueAsObject()
|
|
{
|
|
CheckValid();
|
|
return m_Owner.ReadValueAsObject(header);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the state memory for the record.
|
|
/// </summary>
|
|
/// <returns>The state memory for the record.</returns>
|
|
/// <remarks>
|
|
/// Read the state memory for the record.
|
|
/// </remarks>
|
|
public void* GetUnsafeMemoryPtr()
|
|
{
|
|
CheckValid();
|
|
return GetUnsafeMemoryPtrUnchecked();
|
|
}
|
|
|
|
internal void* GetUnsafeMemoryPtrUnchecked()
|
|
{
|
|
if (m_Owner.controls.Count == 1 && !m_Owner.m_AddNewControls)
|
|
return header->statePtrWithoutControlIndex;
|
|
return header->statePtrWithControlIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the extra memory for the record.
|
|
/// </summary>
|
|
/// <returns>The extra memory for the record.</returns>
|
|
/// <remarks>
|
|
/// Additional date can be stored in a record in the extra memory section.
|
|
/// </remarks>
|
|
/// <seealso cref="InputStateHistory.extraMemoryPerRecord"/>
|
|
public void* GetUnsafeExtraMemoryPtr()
|
|
{
|
|
CheckValid();
|
|
return GetUnsafeExtraMemoryPtrUnchecked();
|
|
}
|
|
|
|
internal void* GetUnsafeExtraMemoryPtrUnchecked()
|
|
{
|
|
if (m_Owner.extraMemoryPerRecord == 0)
|
|
throw new InvalidOperationException("No extra memory has been set up for history records; set extraMemoryPerRecord");
|
|
return (byte*)header + m_Owner.bytesPerRecord - m_Owner.extraMemoryPerRecord;
|
|
}
|
|
|
|
/// <summary>Copy data from one record to another.</summary>
|
|
/// <param name="record">Source record to copy from.</param>
|
|
/// <remarks>
|
|
/// Copy data from one record to another.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentException">When the source record history is not valid.</exception>
|
|
/// <exception cref="InvalidOperationException">When the control is not tracked by the owning <see cref="InputStateHistory"/> container.</exception>
|
|
public void CopyFrom(Record record)
|
|
{
|
|
if (!record.valid)
|
|
throw new ArgumentException("Given history record is not valid", nameof(record));
|
|
CheckValid();
|
|
|
|
// Find control.
|
|
var control = record.control;
|
|
var controlIndex = m_Owner.controls.IndexOfReference(control);
|
|
if (controlIndex == -1)
|
|
{
|
|
// We haven't found it. Throw if we can't add it.
|
|
if (!m_Owner.m_AddNewControls)
|
|
throw new InvalidOperationException($"Control '{record.control}' is not tracked by target history");
|
|
|
|
controlIndex =
|
|
ArrayHelpers.AppendWithCapacity(ref m_Owner.m_Controls, ref m_Owner.m_ControlCount, control);
|
|
}
|
|
|
|
// Make sure memory sizes match.
|
|
var numBytesForState = m_Owner.m_StateSizeInBytes;
|
|
if (numBytesForState != record.m_Owner.m_StateSizeInBytes)
|
|
throw new InvalidOperationException(
|
|
$"Cannot copy record from owner with state size '{record.m_Owner.m_StateSizeInBytes}' to owner with state size '{numBytesForState}'");
|
|
|
|
// Copy and update header.
|
|
var thisRecordPtr = header;
|
|
var otherRecordPtr = record.header;
|
|
UnsafeUtility.MemCpy(thisRecordPtr, otherRecordPtr, RecordHeader.kSizeWithoutControlIndex);
|
|
thisRecordPtr->version = ++m_Owner.m_CurrentVersion;
|
|
m_Version = thisRecordPtr->version;
|
|
|
|
// Copy state.
|
|
var dstPtr = thisRecordPtr->statePtrWithoutControlIndex;
|
|
if (m_Owner.controls.Count > 1 || m_Owner.m_AddNewControls)
|
|
{
|
|
thisRecordPtr->controlIndex = controlIndex;
|
|
dstPtr = thisRecordPtr->statePtrWithControlIndex;
|
|
}
|
|
var srcPtr = record.m_Owner.m_ControlCount > 1 || record.m_Owner.m_AddNewControls
|
|
? otherRecordPtr->statePtrWithControlIndex
|
|
: otherRecordPtr->statePtrWithoutControlIndex;
|
|
UnsafeUtility.MemCpy(dstPtr, srcPtr, numBytesForState);
|
|
|
|
// Copy extra memory, but only if the size in the source and target
|
|
// history are identical.
|
|
var numBytesExtraMemory = m_Owner.m_ExtraMemoryPerRecord;
|
|
if (numBytesExtraMemory > 0 && numBytesExtraMemory == record.m_Owner.m_ExtraMemoryPerRecord)
|
|
UnsafeUtility.MemCpy(GetUnsafeExtraMemoryPtr(), record.GetUnsafeExtraMemoryPtr(),
|
|
numBytesExtraMemory);
|
|
|
|
// Notify.
|
|
m_Owner.onRecordAdded?.Invoke(this);
|
|
}
|
|
|
|
internal void CheckValid()
|
|
{
|
|
if (m_Owner == default || m_IndexPlusOne == default)
|
|
throw new InvalidOperationException("Value not initialized");
|
|
////TODO: need to check whether memory has been disposed
|
|
if (header->version != m_Version)
|
|
throw new InvalidOperationException("Record is no longer valid");
|
|
}
|
|
|
|
/// <summary>Compare two records.</summary>
|
|
/// <remarks>Compare two records.</remarks>
|
|
/// <param name="other">The record to compare with.</param>
|
|
/// <returns>True if the records are the same, False if they differ.</returns>
|
|
public bool Equals(Record other)
|
|
{
|
|
return ReferenceEquals(m_Owner, other.m_Owner) && m_IndexPlusOne == other.m_IndexPlusOne && m_Version == other.m_Version;
|
|
}
|
|
|
|
/// <summary>Compare two records.</summary>
|
|
/// <remarks>Compare two records.</remarks>
|
|
/// <param name="obj">The record to compare with.</param>
|
|
/// <returns>True if the records are the same, False if they differ.</returns>
|
|
public override bool Equals(object obj)
|
|
{
|
|
return obj is Record other && Equals(other);
|
|
}
|
|
|
|
/// <summary>Return the hash code of the record.</summary>
|
|
/// <remarks>Return the hash code of the record.</remarks>
|
|
/// <returns>The hash code of the record.</returns>
|
|
public override int GetHashCode()
|
|
{
|
|
unchecked
|
|
{
|
|
var hashCode = m_Owner != null ? m_Owner.GetHashCode() : 0;
|
|
hashCode = (hashCode * 397) ^ m_IndexPlusOne;
|
|
hashCode = (hashCode * 397) ^ (int)m_Version;
|
|
return hashCode;
|
|
}
|
|
}
|
|
|
|
/// <summary>Return the string representation of the record.</summary>
|
|
/// <remarks>Includes the control, value and time of the record (or <Invalid> if not valid).</remarks>
|
|
/// <returns>The string representation of the record.</returns>
|
|
public override string ToString()
|
|
{
|
|
if (!valid)
|
|
return "<Invalid>";
|
|
|
|
return $"{{ control={control} value={ReadValueAsObject()} time={time} }}";
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Records value changes of a given control over time.
|
|
/// </summary>
|
|
/// <typeparam name="TValue">The type of the record being stored</typeparam>
|
|
/// <remarks>
|
|
/// This class makes it easy to track input values over time. It will automatically retain input state up to a given
|
|
/// maximum history depth (<see cref="InputStateHistory.historyDepth"/>). When the history is full, it will start overwriting the oldest
|
|
/// entry each time a new history record is received.
|
|
///
|
|
/// The class listens to changes on the given controls by adding change monitors (<see cref="IInputStateChangeMonitor"/>)
|
|
/// to each control.
|
|
/// </remarks>
|
|
public class InputStateHistory<TValue> : InputStateHistory, IReadOnlyList<InputStateHistory<TValue>.Record>
|
|
where TValue : struct
|
|
{
|
|
/// <summary>
|
|
/// Creates a new InputStateHistory class to record all control state changes.
|
|
/// </summary>
|
|
/// <param name="maxStateSizeInBytes">Maximum size of control state in the record entries. Controls with larger state will not be recorded.</param>
|
|
/// <remarks>
|
|
/// Creates a new InputStateHistory to record a history of control state changes.
|
|
///
|
|
/// New controls are automatically added into the state history if there state is smaller than the threshold.
|
|
/// </remarks>
|
|
public InputStateHistory(int? maxStateSizeInBytes = null)
|
|
// Using the size of the value here isn't quite correct but the value is used as an upper
|
|
// bound on stored state size for which the size of the value should be a reasonable guess.
|
|
: base(maxStateSizeInBytes ?? UnsafeUtility.SizeOf<TValue>())
|
|
{
|
|
if (maxStateSizeInBytes < UnsafeUtility.SizeOf<TValue>())
|
|
throw new ArgumentException("Max state size cannot be smaller than sizeof(TValue)", nameof(maxStateSizeInBytes));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new InputStateHistory class to record state changes for a specified control.
|
|
/// </summary>
|
|
/// <param name="control">Control to monitor.</param>
|
|
/// <remarks>
|
|
/// Creates a new InputStateHistory to record a history of state changes for the specified control.
|
|
/// </remarks>
|
|
public InputStateHistory(InputControl<TValue> control)
|
|
: base(control)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new InputStateHistory class to record state changes for a specified control.
|
|
/// </summary>
|
|
/// <param name="path">Control path to identify which controls to monitor.</param>
|
|
/// <remarks>
|
|
/// Creates a new InputStateHistory to record a history of state changes for the specified controls.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <code>
|
|
/// // Track all stick controls in the system.
|
|
/// var history = new InputStateHistory<Vector2>("*/<Stick>");
|
|
/// </code>
|
|
/// </example>
|
|
public InputStateHistory(string path)
|
|
: base(path)
|
|
{
|
|
// Make sure that the value type of all matched controls is compatible with TValue.
|
|
foreach (var control in controls)
|
|
if (!typeof(TValue).IsAssignableFrom(control.valueType))
|
|
throw new ArgumentException(
|
|
$"Control '{control}' matched by '{path}' has value type '{TypeHelpers.GetNiceTypeName(control.valueType)}' which is incompatible with '{TypeHelpers.GetNiceTypeName(typeof(TValue))}'");
|
|
}
|
|
|
|
/// <summary>
|
|
/// InputStateHistory destructor.
|
|
/// </summary>
|
|
~InputStateHistory()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a record to the input state history.
|
|
/// </summary>
|
|
/// <param name="record">Record to add.</param>
|
|
/// <returns>The newly added record from the history array (as a copy is made).</returns>
|
|
/// <remarks>
|
|
/// Add a record to the input state history.
|
|
/// Allocates an entry in the history array and returns this copy of the original data passed to the function.
|
|
/// </remarks>
|
|
public unsafe Record AddRecord(Record record)
|
|
{
|
|
var recordPtr = AllocateRecord(out var index);
|
|
var newRecord = new Record(this, index, recordPtr);
|
|
newRecord.CopyFrom(record);
|
|
return newRecord;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Record a state change for a specific control.
|
|
/// </summary>
|
|
/// <param name="control">The control to record the state change for.</param>
|
|
/// <param name="value">The value to record.</param>
|
|
/// <param name="time">Time stamp to apply (overriding the event timestamp)</param>
|
|
/// <returns>The newly added record.</returns>
|
|
/// <remarks>
|
|
/// Record a state change for a specific control.
|
|
/// Will call the <see cref="InputStateHistory.onRecordAdded"/> delegate after adding the record.
|
|
/// Note this does not call the <see cref="InputStateHistory.onShouldRecordStateChange"/> delegate.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <code>
|
|
/// using (var allTouchTaps = new InputStateHistory<float>(Gamepad.current.leftTrigger))
|
|
/// {
|
|
/// history.RecordStateChange(Gamepad.current.leftTrigger, 0.234f);
|
|
/// }
|
|
/// </code>
|
|
/// </example>
|
|
public unsafe Record RecordStateChange(InputControl<TValue> control, TValue value, double time = -1)
|
|
{
|
|
using (StateEvent.From(control.device, out var eventPtr))
|
|
{
|
|
var statePtr = (byte*)StateEvent.From(eventPtr)->state - control.device.stateBlock.byteOffset;
|
|
control.WriteValueIntoState(value, statePtr);
|
|
if (time >= 0)
|
|
eventPtr.time = time;
|
|
var record = RecordStateChange(control, eventPtr);
|
|
return new Record(this, record.recordIndex, record.header);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate all state history records.
|
|
/// </summary>
|
|
/// <returns>An enumerator going over the state history records.</returns>
|
|
/// <remarks>
|
|
/// Enumerate all state history records.
|
|
/// </remarks>
|
|
/// <seealso cref="GetEnumerator"/>
|
|
public new IEnumerator<Record> GetEnumerator()
|
|
{
|
|
return new Enumerator(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate all state history records.
|
|
/// </summary>
|
|
/// <returns>An enumerator going over the state history records.</returns>
|
|
/// <remarks>
|
|
/// Enumerate all state history records.
|
|
/// </remarks>
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an entry in the state history at the given index.
|
|
/// </summary>
|
|
/// <param name="index">Index into the array.</param>
|
|
/// <remarks>
|
|
/// Returns a <see cref="Record"/> entry from the state history at the given index.
|
|
/// </remarks>
|
|
/// <exception cref="IndexOutOfRangeException"><paramref name="index"/> is less than 0 or greater than <see cref="InputStateHistory.Count"/>.</exception>
|
|
public new unsafe Record this[int index]
|
|
{
|
|
get
|
|
{
|
|
if (index < 0 || index >= Count)
|
|
throw new ArgumentOutOfRangeException(
|
|
$"Index {index} is out of range for history with {Count} entries", nameof(index));
|
|
|
|
var recordIndex = UserIndexToRecordIndex(index);
|
|
return new Record(this, recordIndex, GetRecord(recordIndex));
|
|
}
|
|
set
|
|
{
|
|
if (index < 0 || index >= Count)
|
|
throw new ArgumentOutOfRangeException(
|
|
$"Index {index} is out of range for history with {Count} entries", nameof(index));
|
|
var recordIndex = UserIndexToRecordIndex(index);
|
|
new Record(this, recordIndex, GetRecord(recordIndex)).CopyFrom(value);
|
|
}
|
|
}
|
|
|
|
private struct Enumerator : IEnumerator<Record>
|
|
{
|
|
private readonly InputStateHistory<TValue> m_History;
|
|
private int m_Index;
|
|
|
|
public Enumerator(InputStateHistory<TValue> history)
|
|
{
|
|
m_History = history;
|
|
m_Index = -1;
|
|
}
|
|
|
|
public bool MoveNext()
|
|
{
|
|
if (m_Index + 1 >= m_History.Count)
|
|
return false;
|
|
++m_Index;
|
|
return true;
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
m_Index = -1;
|
|
}
|
|
|
|
public Record Current => m_History[m_Index];
|
|
|
|
object IEnumerator.Current => Current;
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>State change record</summary>
|
|
/// <remarks>Input State change record stored in the <see cref="InputStateHistory{TValue}"/></remarks>
|
|
/// <seealso cref="InputStateHistory{TValue}"/>
|
|
public new unsafe struct Record : IEquatable<Record>
|
|
{
|
|
private readonly InputStateHistory<TValue> m_Owner;
|
|
private readonly int m_IndexPlusOne;
|
|
private uint m_Version;
|
|
|
|
internal RecordHeader* header => m_Owner.GetRecord(recordIndex);
|
|
internal int recordIndex => m_IndexPlusOne - 1;
|
|
|
|
/// <summary>
|
|
/// Identifies if the record is valid.
|
|
/// </summary>
|
|
/// <value>True if the record is a valid entry. False if invalid.</value>
|
|
/// <remarks>
|
|
/// When the history is cleared with <see cref="InputStateHistory.Clear"/> the entries become invalid.
|
|
/// </remarks>
|
|
public bool valid => m_Owner != default && m_IndexPlusOne != default && header->version == m_Version;
|
|
|
|
/// <summary>
|
|
/// Identifies the owning container for the record.
|
|
/// </summary>
|
|
/// <value>The owning <see cref="InputStateHistory"/> container for the record.</value>
|
|
/// <remarks>
|
|
/// Identifies the owning <see cref="InputStateHistory"/> container for the record.
|
|
/// </remarks>
|
|
public InputStateHistory<TValue> owner => m_Owner;
|
|
|
|
/// <summary>
|
|
/// The index of the input state record in the owning container.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The index of the input state record in the owning container.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public int index
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
return m_Owner.RecordIndexToUserIndex(recordIndex);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The time stamp of the input state record.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The time stamp of the input state record in the owning container.
|
|
/// <see cref="IInputRuntime.currentTime"/>
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public double time
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
return header->time;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The control associated with the input state record.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The control associated with the input state record.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public InputControl<TValue> control
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
var controls = m_Owner.controls;
|
|
if (controls.Count == 1 && !m_Owner.m_AddNewControls)
|
|
return (InputControl<TValue>)controls[0];
|
|
return (InputControl<TValue>)controls[header->controlIndex];
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The next input state record in the owning container.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The next input state record in the owning <see cref="InputStateHistory{TValue}"/>container.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public Record next
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
var userIndex = m_Owner.RecordIndexToUserIndex(this.recordIndex);
|
|
if (userIndex + 1 >= m_Owner.Count)
|
|
return default;
|
|
var recordIndex = m_Owner.UserIndexToRecordIndex(userIndex + 1);
|
|
return new Record(m_Owner, recordIndex, m_Owner.GetRecord(recordIndex));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The previous input state record in the owning container.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The previous input state record in the owning <see cref="InputStateHistory{TValue}"/>container.
|
|
/// </value>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
|
|
public Record previous
|
|
{
|
|
get
|
|
{
|
|
CheckValid();
|
|
var userIndex = m_Owner.RecordIndexToUserIndex(this.recordIndex);
|
|
if (userIndex - 1 < 0)
|
|
return default;
|
|
var recordIndex = m_Owner.UserIndexToRecordIndex(userIndex - 1);
|
|
return new Record(m_Owner, recordIndex, m_Owner.GetRecord(recordIndex));
|
|
}
|
|
}
|
|
|
|
internal Record(InputStateHistory<TValue> owner, int index, RecordHeader* header)
|
|
{
|
|
m_Owner = owner;
|
|
m_IndexPlusOne = index + 1;
|
|
m_Version = header->version;
|
|
}
|
|
|
|
internal Record(InputStateHistory<TValue> owner, int index)
|
|
{
|
|
m_Owner = owner;
|
|
m_IndexPlusOne = index + 1;
|
|
m_Version = default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns value from the control in the Record.
|
|
/// </summary>
|
|
/// <returns>Returns value from the Record.</returns>
|
|
/// <exception cref="InvalidOperationException">When the record is no longer value or the specified type is not present.</exception>
|
|
public TValue ReadValue()
|
|
{
|
|
CheckValid();
|
|
return m_Owner.ReadValue<TValue>(header);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the state memory for the record.
|
|
/// </summary>
|
|
/// <returns>The state memory for the record.</returns>
|
|
/// <remarks>
|
|
/// Read the state memory for the record.
|
|
/// </remarks>
|
|
public void* GetUnsafeMemoryPtr()
|
|
{
|
|
CheckValid();
|
|
return GetUnsafeMemoryPtrUnchecked();
|
|
}
|
|
|
|
internal void* GetUnsafeMemoryPtrUnchecked()
|
|
{
|
|
if (m_Owner.controls.Count == 1 && !m_Owner.m_AddNewControls)
|
|
return header->statePtrWithoutControlIndex;
|
|
return header->statePtrWithControlIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the extra memory for the record.
|
|
/// </summary>
|
|
/// <returns>The extra memory for the record.</returns>
|
|
/// <remarks>
|
|
/// Additional date can be stored in a record in the extra memory section.
|
|
/// </remarks>
|
|
/// <seealso cref="InputStateHistory.extraMemoryPerRecord"/>
|
|
public void* GetUnsafeExtraMemoryPtr()
|
|
{
|
|
CheckValid();
|
|
return GetUnsafeExtraMemoryPtrUnchecked();
|
|
}
|
|
|
|
internal void* GetUnsafeExtraMemoryPtrUnchecked()
|
|
{
|
|
if (m_Owner.extraMemoryPerRecord == 0)
|
|
throw new InvalidOperationException("No extra memory has been set up for history records; set extraMemoryPerRecord");
|
|
return (byte*)header + m_Owner.bytesPerRecord - m_Owner.extraMemoryPerRecord;
|
|
}
|
|
|
|
/// <summary>Copy data from one record to another.</summary>
|
|
/// <param name="record">Source Record to copy from.</param>
|
|
/// <remarks>
|
|
/// Copy data from one record to another.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentException">When the source record history is not valid.</exception>
|
|
/// <exception cref="InvalidOperationException">When the control is not tracked by the owning <see cref="InputStateHistory{TValue}"/> container.</exception>
|
|
public void CopyFrom(Record record)
|
|
{
|
|
CheckValid();
|
|
if (!record.valid)
|
|
throw new ArgumentException("Given history record is not valid", nameof(record));
|
|
var temp = new InputStateHistory.Record(m_Owner, recordIndex, header);
|
|
temp.CopyFrom(new InputStateHistory.Record(record.m_Owner, record.recordIndex, record.header));
|
|
m_Version = temp.version;
|
|
}
|
|
|
|
private void CheckValid()
|
|
{
|
|
if (m_Owner == default || m_IndexPlusOne == default)
|
|
throw new InvalidOperationException("Value not initialized");
|
|
if (header->version != m_Version)
|
|
throw new InvalidOperationException("Record is no longer valid");
|
|
}
|
|
|
|
/// <summary>Compare two records.</summary>
|
|
/// <remarks>Compare two records.</remarks>
|
|
/// <param name="other">The record to compare with.</param>
|
|
/// <returns>True if the records are the same, False if they differ.</returns>
|
|
public bool Equals(Record other)
|
|
{
|
|
return ReferenceEquals(m_Owner, other.m_Owner) && m_IndexPlusOne == other.m_IndexPlusOne && m_Version == other.m_Version;
|
|
}
|
|
|
|
/// <summary>Compare two records.</summary>
|
|
/// <remarks>Compare two records.</remarks>
|
|
/// <param name="obj">The record to compare with.</param>
|
|
/// <returns>True if the records are the same, False if they differ.</returns>
|
|
public override bool Equals(object obj)
|
|
{
|
|
return obj is Record other && Equals(other);
|
|
}
|
|
|
|
/// <summary>Return the hash code of the record.</summary>
|
|
/// <remarks>Return the hash code of the record.</remarks>
|
|
/// <returns>The hash code of the record.</returns>
|
|
public override int GetHashCode()
|
|
{
|
|
unchecked
|
|
{
|
|
var hashCode = m_Owner != null ? m_Owner.GetHashCode() : 0;
|
|
hashCode = (hashCode * 397) ^ m_IndexPlusOne;
|
|
hashCode = (hashCode * 397) ^ (int)m_Version;
|
|
return hashCode;
|
|
}
|
|
}
|
|
|
|
/// <summary>Return the string representation of the record.</summary>
|
|
/// <remarks>Includes the control, value and time of the record (or <Invalid> if not valid).</remarks>
|
|
/// <returns>The string representation of the record.</returns>
|
|
public override string ToString()
|
|
{
|
|
if (!valid)
|
|
return "<Invalid>";
|
|
|
|
return $"{{ control={control} value={ReadValue()} time={time} }}";
|
|
}
|
|
}
|
|
}
|
|
}
|